WordPress.org
Get WordPress

Make WordPress Core

Changeset 54274


Ignore:
Timestamp:
09/21/2022 01:00:29 PM (4 years ago)
Author:
hellofromTonya
Message:

Editor: Improves layout block support in wp_get_layout_style().

This commit merges the remaining changes from ​Gutenberg PR 40875. It's Part 2 (see [54162] for Part 1) of a layout improvement initiative and targets wp_get_layout_style() in layout.php.

Context:
The overall initiative is to improve layout block support:

to use centralised layout definitions, output base layout styles from global styles, introduce a layout type semantic classname, reduce duplication of container class and style tag output, and fix blockGap at the block level in global styles.

Changes include:

  • Adding an optional parameter $block_spacing to wp_get_layout_style() for setting a custom spacing on the block.
  • Adding handle for the block spacing.
  • Using the style engine to to enqueue and render layout styles via wp_style_engine_get_stylesheet_from_css_rules().
  • Introduces a new test file for wp_get_layout_style().

Follow-up to [54162], [54160], [54159], [53421], [52380], [53085], [52069].

Props andrewserong, isabel_brison, costdev, hellofromTonya.
See #56467.

Location:
trunk
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/wp-includes/block-supports/layout.php

    r53568 r54274  
    3434 *
    3535 * @since 5.9.0
     36 * @since 6.1.0 Added `$block_spacing` param, use style engine to enqueue styles.
    3637 * @access private
    3738 *
    38  * @param string  $selector                      CSS selector.
    39  * @param array   $layout                        Layout object. The one that is passed has already checked
    40  *                                               the existence of default block layout.
    41  * @param boolean $has_block_gap_support         Whether the theme has support for the block gap.
    42  * @param string  $gap_value                     The block gap value to apply.
    43  * @param boolean $should_skip_gap_serialization Whether to skip applying the user-defined value set in the editor.
    44  * @param string  $fallback_gap_value            The custom fallback value for block gap.
     39 * @param string               $selector                      CSS selector.
     40 * @param array                $layout                        Layout object. The one that is passed has already checked
     41 *                                                            the existence of default block layout.
     42 * @param boolean              $has_block_gap_support         Whether the theme has support for the block gap.
     43 * @param string|string[]|null $gap_value                     Optional. The block gap value to apply. Default null.
     44 * @param boolean              $should_skip_gap_serialization Whether to skip applying the user-defined value set in the editor.
     45 * @param string               $fallback_gap_value            The block gap value to apply.
     46 * @param array|null           $block_spacing                 Optional. Custom spacing set on the block. Default null.
    4547 * @return string CSS style.
    4648 */
    47 function wp_get_layout_style( $selector, $layout, $has_block_gap_support = false, $gap_value = null, $should_skip_gap_serialization = false, $fallback_gap_value = '0.5em' ) {
    48         $layout_type = isset( $layout['type'] ) ? $layout['type'] : 'default';
    49 
    50         $style = '';
     49function wp_get_layout_style( $selector, $layout, $has_block_gap_support = false, $gap_value = null, $should_skip_gap_serialization = false, $fallback_gap_value = '0.5em', $block_spacing = null ) {
     50        $layout_type   = isset( $layout['type'] ) ? $layout['type'] : 'default';
     51        $layout_styles = array();
     52
    5153        if ( 'default' === $layout_type ) {
    52                 $content_size = isset( $layout['contentSize'] ) ? $layout['contentSize'] : '';
    53                 $wide_size    = isset( $layout['wideSize'] ) ? $layout['wideSize'] : '';
     54                if ( $has_block_gap_support ) {
     55                        if ( is_array( $gap_value ) ) {
     56                                $gap_value = isset( $gap_value['top'] ) ? $gap_value['top'] : null;
     57                        }
     58                        if ( null !== $gap_value && ! $should_skip_gap_serialization ) {
     59                                array_push(
     60                                        $layout_styles,
     61                                        array(
     62                                                'selector'     => "$selector > *",
     63                                                'declarations' => array(
     64                                                        'margin-block-start' => '0',
     65                                                        'margin-block-end'   => '0',
     66                                                ),
     67                                        ),
     68                                        array(
     69                                                'selector'     => "$selector$selector > * + *",
     70                                                'declarations' => array(
     71                                                        'margin-block-start' => $gap_value,
     72                                                        'margin-block-end'   => '0',
     73                                                ),
     74                                        )
     75                                );
     76                        }
     77                }
     78        } elseif ( 'constrained' === $layout_type ) {
     79                $content_size    = isset( $layout['contentSize'] ) ? $layout['contentSize'] : '';
     80                $wide_size       = isset( $layout['wideSize'] ) ? $layout['wideSize'] : '';
     81                $justify_content = isset( $layout['justifyContent'] ) ? $layout['justifyContent'] : 'center';
    5482
    5583                $all_max_width_value  = $content_size ? $content_size : $wide_size;
    … …  
    6088                $wide_max_width_value = safecss_filter_attr( explode( ';', $wide_max_width_value )[0] );
    6189
     90                $margin_left  = 'left' === $justify_content ? '0 !important' : 'auto !important';
     91                $margin_right = 'right' === $justify_content ? '0 !important' : 'auto !important';
     92
    6293                if ( $content_size || $wide_size ) {
    63                         $style  = "$selector > :where(:not(.alignleft):not(.alignright)) {";
    64                         $style .= 'max-width: ' . esc_html( $all_max_width_value ) . ';';
    65                         $style .= 'margin-left: auto !important;';
    66                         $style .= 'margin-right: auto !important;';
    67                         $style .= '}';
    68 
    69                         $style .= "$selector > .alignwide { max-width: " . esc_html( $wide_max_width_value ) . ';}';
    70                         $style .= "$selector .alignfull { max-width: none; }";
    71                 }
    72 
    73                 $style .= "$selector > .alignleft { float: left; margin-inline-start: 0; margin-inline-end: 2em; }";
    74                 $style .= "$selector > .alignright { float: right; margin-inline-start: 2em; margin-inline-end: 0; }";
    75                 $style .= "$selector > .aligncenter { margin-left: auto !important; margin-right: auto !important; }";
     94                        array_push(
     95                                $layout_styles,
     96                                array(
     97                                        'selector'     => "$selector > :where(:not(.alignleft):not(.alignright):not(.alignfull))",
     98                                        'declarations' => array(
     99                                                'max-width'    => $all_max_width_value,
     100                                                'margin-left'  => $margin_left,
     101                                                'margin-right' => $margin_right,
     102                                        ),
     103                                ),
     104                                array(
     105                                        'selector'     => "$selector > .alignwide",
     106                                        'declarations' => array( 'max-width' => $wide_max_width_value ),
     107                                ),
     108                                array(
     109                                        'selector'     => "$selector .alignfull",
     110                                        'declarations' => array( 'max-width' => 'none' ),
     111                                )
     112                        );
     113
     114                        if ( isset( $block_spacing ) ) {
     115                                $block_spacing_values = wp_style_engine_get_styles(
     116                                        array(
     117                                                'spacing' => $block_spacing,
     118                                        )
     119                                );
     120
     121                                /*
     122                                 * Handle negative margins for alignfull children of blocks with custom padding set.
     123                                 * They're added separately because padding might only be set on one side.
     124                                 */
     125                                if ( isset( $block_spacing_values['declarations']['padding-right'] ) ) {
     126                                        $padding_right   = $block_spacing_values['declarations']['padding-right'];
     127                                        $layout_styles[] = array(
     128                                                'selector'     => "$selector > .alignfull",
     129                                                'declarations' => array( 'margin-right' => "calc($padding_right * -1)" ),
     130                                        );
     131                                }
     132                                if ( isset( $block_spacing_values['declarations']['padding-left'] ) ) {
     133                                        $padding_left    = $block_spacing_values['declarations']['padding-left'];
     134                                        $layout_styles[] = array(
     135                                                'selector'     => "$selector > .alignfull",
     136                                                'declarations' => array( 'margin-left' => "calc($padding_left * -1)" ),
     137                                        );
     138                                }
     139                        }
     140                }
     141
     142                if ( 'left' === $justify_content ) {
     143                        $layout_styles[] = array(
     144                                'selector'     => "$selector > :where(:not(.alignleft):not(.alignright):not(.alignfull))",
     145                                'declarations' => array( 'margin-left' => '0 !important' ),
     146                        );
     147                }
     148
     149                if ( 'right' === $justify_content ) {
     150                        $layout_styles[] = array(
     151                                'selector'     => "$selector > :where(:not(.alignleft):not(.alignright):not(.alignfull))",
     152                                'declarations' => array( 'margin-right' => '0 !important' ),
     153                        );
     154                }
     155
    76156                if ( $has_block_gap_support ) {
    77157                        if ( is_array( $gap_value ) ) {
    78158                                $gap_value = isset( $gap_value['top'] ) ? $gap_value['top'] : null;
    79159                        }
    80                         $gap_style = $gap_value && ! $should_skip_gap_serialization ? $gap_value : 'var( --wp--style--block-gap )';
    81                         $style    .= "$selector > * { margin-block-start: 0; margin-block-end: 0; }";
    82                         $style    .= "$selector > * + * { margin-block-start: $gap_style; margin-block-end: 0; }";
     160                        if ( null !== $gap_value && ! $should_skip_gap_serialization ) {
     161                                // Get spacing CSS variable from preset value if provided.
     162                                if ( is_string( $gap_value ) && str_contains( $gap_value, 'var:preset|spacing|' ) ) {
     163                                        $index_to_splice = strrpos( $gap_value, '|' ) + 1;
     164                                        $slug            = _wp_to_kebab_case( substr( $gap_value, $index_to_splice ) );
     165                                        $gap_value       = "var(--wp--preset--spacing--$slug)";
     166                                }
     167
     168                                array_push(
     169                                        $layout_styles,
     170                                        array(
     171                                                'selector'     => "$selector > *",
     172                                                'declarations' => array(
     173                                                        'margin-block-start' => '0',
     174                                                        'margin-block-end'   => '0',
     175                                                ),
     176                                        ),
     177                                        array(
     178                                                'selector'     => "$selector$selector > * + *",
     179                                                'declarations' => array(
     180                                                        'margin-block-start' => $gap_value,
     181                                                        'margin-block-end'   => '0',
     182                                                ),
     183                                        )
     184                                );
     185                        }
    83186                }
    84187        } elseif ( 'flex' === $layout_type ) {
    … …  
    91194                );
    92195
     196                $vertical_alignment_options = array(
     197                        'top'    => 'flex-start',
     198                        'center' => 'center',
     199                        'bottom' => 'flex-end',
     200                );
     201
    93202                if ( 'horizontal' === $layout_orientation ) {
    94203                        $justify_content_options += array( 'space-between' => 'space-between' );
    95204                }
    96205
    97                 $flex_wrap_options = array( 'wrap', 'nowrap' );
    98                 $flex_wrap         = ! empty( $layout['flexWrap'] ) && in_array( $layout['flexWrap'], $flex_wrap_options, true ) ?
    99                         $layout['flexWrap'] :
    100                         'wrap';
    101 
    102                 $style  = "$selector {";
    103                 $style .= 'display: flex;';
    104                 if ( $has_block_gap_support ) {
    105                         if ( is_array( $gap_value ) ) {
    106                                 $gap_row    = isset( $gap_value['top'] ) ? $gap_value['top'] : $fallback_gap_value;
    107                                 $gap_column = isset( $gap_value['left'] ) ? $gap_value['left'] : $fallback_gap_value;
    108                                 $gap_value  = $gap_row === $gap_column ? $gap_row : $gap_row . ' ' . $gap_column;
    109                         }
    110                         $gap_style = $gap_value && ! $should_skip_gap_serialization ? $gap_value : "var( --wp--style--block-gap, $fallback_gap_value )";
    111                         $style    .= "gap: $gap_style;";
    112                 } else {
    113                         $style .= "gap: $fallback_gap_value;";
    114                 }
    115 
    116                 $style .= "flex-wrap: $flex_wrap;";
     206                if ( ! empty( $layout['flexWrap'] ) && 'nowrap' === $layout['flexWrap'] ) {
     207                        $layout_styles[] = array(
     208                                'selector'     => $selector,
     209                                'declarations' => array( 'flex-wrap' => 'nowrap' ),
     210                        );
     211                }
     212
     213                if ( $has_block_gap_support && isset( $gap_value ) ) {
     214                        $combined_gap_value = '';
     215                        $gap_sides          = is_array( $gap_value ) ? array( 'top', 'left' ) : array( 'top' );
     216
     217                        foreach ( $gap_sides as $gap_side ) {
     218                                $process_value = is_string( $gap_value ) ? $gap_value : _wp_array_get( $gap_value, array( $gap_side ), $fallback_gap_value );
     219                                // Get spacing CSS variable from preset value if provided.
     220                                if ( is_string( $process_value ) && str_contains( $process_value, 'var:preset|spacing|' ) ) {
     221                                        $index_to_splice = strrpos( $process_value, '|' ) + 1;
     222                                        $slug            = _wp_to_kebab_case( substr( $process_value, $index_to_splice ) );
     223                                        $process_value   = "var(--wp--preset--spacing--$slug)";
     224                                }
     225                                $combined_gap_value .= "$process_value ";
     226                        }
     227                        $gap_value = trim( $combined_gap_value );
     228
     229                        if ( null !== $gap_value && ! $should_skip_gap_serialization ) {
     230                                $layout_styles[] = array(
     231                                        'selector'     => $selector,
     232                                        'declarations' => array( 'gap' => $gap_value ),
     233                                );
     234                        }
     235                }
     236
    117237                if ( 'horizontal' === $layout_orientation ) {
    118                         $style .= 'align-items: center;';
    119                         /**
     238                        /*
    120239                         * Add this style only if is not empty for backwards compatibility,
    121240                         * since we intend to convert blocks that had flex layout implemented
    … …  
    123242                         */
    124243                        if ( ! empty( $layout['justifyContent'] ) && array_key_exists( $layout['justifyContent'], $justify_content_options ) ) {
    125                                 $style .= "justify-content: {$justify_content_options[ $layout['justifyContent'] ]};";
     244                                $layout_styles[] = array(
     245                                        'selector'     => $selector,
     246                                        'declarations' => array( 'justify-content' => $justify_content_options[ $layout['justifyContent'] ] ),
     247                                );
     248                        }
     249
     250                        if ( ! empty( $layout['verticalAlignment'] ) && array_key_exists( $layout['verticalAlignment'], $vertical_alignment_options ) ) {
     251                                $layout_styles[] = array(
     252                                        'selector'     => $selector,
     253                                        'declarations' => array( 'align-items' => $vertical_alignment_options[ $layout['verticalAlignment'] ] ),
     254                                );
    126255                        }
    127256                } else {
    128                         $style .= 'flex-direction: column;';
     257                        $layout_styles[] = array(
     258                                'selector'     => $selector,
     259                                'declarations' => array( 'flex-direction' => 'column' ),
     260                        );
    129261                        if ( ! empty( $layout['justifyContent'] ) && array_key_exists( $layout['justifyContent'], $justify_content_options ) ) {
    130                                 $style .= "align-items: {$justify_content_options[ $layout['justifyContent'] ]};";
     262                                $layout_styles[] = array(
     263                                        'selector'     => $selector,
     264                                        'declarations' => array( 'align-items' => $justify_content_options[ $layout['justifyContent'] ] ),
     265                                );
    131266                        } else {
    132                                 $style .= 'align-items: flex-start;';
    133                         }
    134                 }
    135                 $style .= '}';
    136 
    137                 $style .= "$selector > * { margin: 0; }";
    138         }
    139 
    140         return $style;
     267                                $layout_styles[] = array(
     268                                        'selector'     => $selector,
     269                                        'declarations' => array( 'align-items' => 'flex-start' ),
     270                                );
     271                        }
     272                }
     273        }
     274
     275        if ( ! empty( $layout_styles ) ) {
     276                /*
     277                 * Add to the style engine store to enqueue and render layout styles.
     278                 * Return compiled layout styles to retain backwards compatibility.
     279                 * Since https://github.com/WordPress/gutenberg/pull/42452,
     280                 * wp_enqueue_block_support_styles is no longer called in this block supports file.
     281                 */
     282                return wp_style_engine_get_stylesheet_from_css_rules(
     283                        $layout_styles,
     284                        array(
     285                                'context'  => 'block-supports',
     286                                'prettify' => false,
     287                        )
     288                );
     289        }
     290
     291        return '';
    141292}
    142293
    … …  
    159310        }
    160311
    161         $block_gap             = wp_get_global_settings( array( 'spacing', 'blockGap' ) );
    162         $default_layout        = wp_get_global_settings( array( 'layout' ) );
    163         $has_block_gap_support = isset( $block_gap ) ? null !== $block_gap : false;
    164         $default_block_layout  = _wp_array_get( $block_type->supports, array( '__experimentalLayout', 'default' ), array() );
    165         $used_layout           = isset( $block['attrs']['layout'] ) ? $block['attrs']['layout'] : $default_block_layout;
     312        $block_gap              = wp_get_global_settings( array( 'spacing', 'blockGap' ) );
     313        $global_layout_settings = wp_get_global_settings( array( 'layout' ) );
     314        $has_block_gap_support  = isset( $block_gap ) ? null !== $block_gap : false;
     315        $default_block_layout   = _wp_array_get( $block_type->supports, array( '__experimentalLayout', 'default' ), array() );
     316        $used_layout            = isset( $block['attrs']['layout'] ) ? $block['attrs']['layout'] : $default_block_layout;
     317
    166318        if ( isset( $used_layout['inherit'] ) && $used_layout['inherit'] ) {
    167                 if ( ! $default_layout ) {
     319                if ( ! $global_layout_settings ) {
    168320                        return $block_content;
    169321                }
    170                 $used_layout = $default_layout;
    171         }
    172 
    173         $class_names     = array();
    174         $container_class = wp_unique_id( 'wp-container-' );
    175         $class_names[]   = $container_class;
    176 
    177         // The following section was added to reintroduce a small set of layout classnames that were
    178         // removed in the 5.9 release (https://github.com/WordPress/gutenberg/issues/38719). It is
    179         // not intended to provide an extended set of classes to match all block layout attributes
    180         // here.
     322        }
     323
     324        $class_names        = array();
     325        $layout_definitions = _wp_array_get( $global_layout_settings, array( 'definitions' ), array() );
     326        $block_classname    = wp_get_block_default_classname( $block['blockName'] );
     327        $container_class    = wp_unique_id( 'wp-container-' );
     328        $layout_classname   = '';
     329
     330        // Set the correct layout type for blocks using legacy content width.
     331        if ( isset( $used_layout['inherit'] ) && $used_layout['inherit'] || isset( $used_layout['contentSize'] ) && $used_layout['contentSize'] ) {
     332                $used_layout['type'] = 'constrained';
     333        }
     334
     335        if (
     336                wp_get_global_settings( array( 'useRootPaddingAwareAlignments' ) ) &&
     337                isset( $used_layout['type'] ) &&
     338                'constrained' === $used_layout['type']
     339        ) {
     340                $class_names[] = 'has-global-padding';
     341        }
     342
     343        /*
     344         * The following section was added to reintroduce a small set of layout classnames that were
     345         * removed in the 5.9 release (https://github.com/WordPress/gutenberg/issues/38719). It is
     346         * not intended to provide an extended set of classes to match all block layout attributes
     347         * here.
     348         */
    181349        if ( ! empty( $block['attrs']['layout']['orientation'] ) ) {
    182350                $class_names[] = 'is-' . sanitize_title( $block['attrs']['layout']['orientation'] );
    … …  
    191359        }
    192360
    193         $gap_value = _wp_array_get( $block, array( 'attrs', 'style', 'spacing', 'blockGap' ) );
    194         // Skip if gap value contains unsupported characters.
    195         // Regex for CSS value borrowed from `safecss_filter_attr`, and used here
    196         // because we only want to match against the value, not the CSS attribute.
    197         if ( is_array( $gap_value ) ) {
    198                 foreach ( $gap_value as $key => $value ) {
    199                         $gap_value[ $key ] = $value && preg_match( '%[\\\(&=}]|/\*%', $value ) ? null : $value;
    200                 }
     361        // Get classname for layout type.
     362        if ( isset( $used_layout['type'] ) ) {
     363                $layout_classname = _wp_array_get( $layout_definitions, array( $used_layout['type'], 'className' ), '' );
    201364        } else {
    202                 $gap_value = $gap_value && preg_match( '%[\\\(&=}]|/\*%', $gap_value ) ? null : $gap_value;
    203         }
    204 
    205         $fallback_gap_value = _wp_array_get( $block_type->supports, array( 'spacing', 'blockGap', '__experimentalDefault' ), '0.5em' );
    206 
    207         // If a block's block.json skips serialization for spacing or spacing.blockGap,
    208         // don't apply the user-defined value to the styles.
    209         $should_skip_gap_serialization = wp_should_skip_block_supports_serialization( $block_type, 'spacing', 'blockGap' );
    210         $style                         = wp_get_layout_style( ".$container_class", $used_layout, $has_block_gap_support, $gap_value, $should_skip_gap_serialization, $fallback_gap_value );
    211         // This assumes the hook only applies to blocks with a single wrapper.
    212         // I think this is a reasonable limitation for that particular hook.
     365                $layout_classname = _wp_array_get( $layout_definitions, array( 'default', 'className' ), '' );
     366        }
     367
     368        if ( $layout_classname && is_string( $layout_classname ) ) {
     369                $class_names[] = sanitize_title( $layout_classname );
     370        }
     371
     372        /*
     373         * Only generate Layout styles if the theme has not opted-out.
     374         * Attribute-based Layout classnames are output in all cases.
     375         */
     376        if ( ! current_theme_supports( 'disable-layout-styles' ) ) {
     377
     378                $gap_value = _wp_array_get( $block, array( 'attrs', 'style', 'spacing', 'blockGap' ) );
     379                /*
     380                 * Skip if gap value contains unsupported characters.
     381                 * Regex for CSS value borrowed from `safecss_filter_attr`, and used here
     382                 * to only match against the value, not the CSS attribute.
     383                 */
     384                if ( is_array( $gap_value ) ) {
     385                        foreach ( $gap_value as $key => $value ) {
     386                                $gap_value[ $key ] = $value && preg_match( '%[\\\(&=}]|/\*%', $value ) ? null : $value;
     387                        }
     388                } else {
     389                        $gap_value = $gap_value && preg_match( '%[\\\(&=}]|/\*%', $gap_value ) ? null : $gap_value;
     390                }
     391
     392                $fallback_gap_value = _wp_array_get( $block_type->supports, array( 'spacing', 'blockGap', '__experimentalDefault' ), '0.5em' );
     393                $block_spacing      = _wp_array_get( $block, array( 'attrs', 'style', 'spacing' ), null );
     394
     395                /*
     396                 * If a block's block.json skips serialization for spacing or spacing.blockGap,
     397                 * don't apply the user-defined value to the styles.
     398                 */
     399                $should_skip_gap_serialization = wp_should_skip_block_supports_serialization( $block_type, 'spacing', 'blockGap' );
     400
     401                $style = wp_get_layout_style(
     402                        ".$block_classname.$container_class",
     403                        $used_layout,
     404                        $has_block_gap_support,
     405                        $gap_value,
     406                        $should_skip_gap_serialization,
     407                        $fallback_gap_value,
     408                        $block_spacing
     409                );
     410
     411                // Only add container class and enqueue block support styles if unique styles were generated.
     412                if ( ! empty( $style ) ) {
     413                        $class_names[] = $container_class;
     414                }
     415        }
     416
     417        /*
     418         * This assumes the hook only applies to blocks with a single wrapper.
     419         * A limitation of this hook is that nested inner blocks wrappers are not yet supported.
     420         */
    213421        $content = preg_replace(
    214422                '/' . preg_quote( 'class="', '/' ) . '/',
    … …  
    217425                1
    218426        );
    219 
    220         wp_enqueue_block_support_styles( $style );
    221427
    222428        return $content;

  • trunk/tests/phpunit/data/blocks/fixtures/core__column.server.html

    r53157 r54274  
    11
    2 <div class="wp-container-1 wp-block-column">
     2<div class="is-layout-flow wp-block-column">
    33       
    44        <p>Column One, Paragraph One</p>

  • trunk/tests/phpunit/data/blocks/fixtures/core__columns.server.html

    r53157 r54274  
    11
    2 <div class="wp-container-1 wp-block-columns has-3-columns">
     2<div class="is-layout-flex wp-container-1 wp-block-columns has-3-columns">
    33       
    4         <div class="wp-container-1 wp-block-column">
     4        <div class="is-layout-flow wp-block-column">
    55               
    66                <p>Column One, Paragraph One</p>
    … …  
    1212       
    1313       
    14         <div class="wp-container-1 wp-block-column">
     14        <div class="is-layout-flow wp-block-column">
    1515               
    1616                <p>Column Two, Paragraph One</p>

  • trunk/tests/phpunit/data/blocks/fixtures/core__columns__deprecated.server.html

    r53157 r54274  
    11
    2 <div class="wp-container-1 wp-block-columns has-3-columns">
     2<div class="is-layout-flex wp-container-1 wp-block-columns has-3-columns">
    33       
    44        <p class="layout-column-1">Column One, Paragraph One</p>

  • trunk/tests/phpunit/data/blocks/fixtures/core__gallery.server.html

    r53261 r54274  
    11
    2 <figure class="wp-container-1 wp-block-gallery-1 wp-block-gallery has-nested-images columns-default is-cropped columns-2">
     2<figure class="is-layout-flex wp-block-gallery-1 wp-block-gallery has-nested-images columns-default is-cropped columns-2">
    33       
    44        <figure class="wp-block-image size-large">

  • trunk/tests/phpunit/data/blocks/fixtures/core__gallery__columns.server.html

    r53261 r54274  
    11
    2 <figure class="wp-container-1 wp-block-gallery-1 wp-block-gallery has-nested-images is-cropped columns-1" >
     2<figure class="is-layout-flex wp-block-gallery-1 wp-block-gallery has-nested-images is-cropped columns-1" >
    33       
    44        <figure class="wp-block-image size-large">
Note: See TracChangeset for help on using the changeset viewer.