Changeset 58303 for trunk/src/wp-includes/blocks.php

Timestamp:

06/03/2024 06:30:02 PM (2 years ago)

Author:

ellatrix

Message:

Editor: resolve patterns server side.

See ​https://github.com/WordPress/gutenberg/pull/60349.
See ​https://github.com/WordPress/gutenberg/pull/61757.
See ​https://github.com/WordPress/wordpress-develop/pull/6673.

Fixes #61228.

Props ellatrix, antonvlasenko.

File:

• trunk/src/wp-includes/blocks.php (modified) (1 diff)

trunk/src/wp-includes/blocks.php

@@ -1520 +1520 @@
 
 /**
+ * Replaces patterns in a block tree with their content.
+ *
+ * @since 6.6.0
+ *
+ * @param array $blocks An array blocks.
+ *
+ * @return array An array of blocks with patterns replaced by their content.
+ */
+function resolve_pattern_blocks( $blocks ) {
+        static $inner_content;
+        // Keep track of seen references to avoid infinite loops.
+        static $seen_refs = array();
+        $i                = 0;
+        while ( $i < count( $blocks ) ) {
+                if ( 'core/pattern' === $blocks[ $i ]['blockName'] ) {
+                        $attrs = $blocks[ $i ]['attrs'];
+
+                        if ( empty( $attrs['slug'] ) ) {
+                                ++$i;
+                                continue;
+                        }
+
+                        $slug = $attrs['slug'];
+
+                        if ( isset( $seen_refs[ $slug ] ) ) {
+                                // Skip recursive patterns.
+                                array_splice( $blocks, $i, 1 );
+                                continue;
+                        }
+
+                        $registry = WP_Block_Patterns_Registry::get_instance();
+                        $pattern  = $registry->get_registered( $slug );
+
+                        // Skip unknown patterns.
+                        if ( ! $pattern ) {
+                                ++$i;
+                                continue;
+                        }
+
+                        $blocks_to_insert   = parse_blocks( $pattern['content'] );
+                        $seen_refs[ $slug ] = true;
+                        $prev_inner_content = $inner_content;
+                        $inner_content      = null;
+                        $blocks_to_insert   = resolve_pattern_blocks( $blocks_to_insert );
+                        $inner_content      = $prev_inner_content;
+                        unset( $seen_refs[ $slug ] );
+                        array_splice( $blocks, $i, 1, $blocks_to_insert );
+
+                        // If we have inner content, we need to insert nulls in the
+                        // inner content array, otherwise serialize_blocks will skip
+                        // blocks.
+                        if ( $inner_content ) {
+                                $null_indices  = array_keys( $inner_content, null, true );
+                                $content_index = $null_indices[ $i ];
+                                $nulls         = array_fill( 0, count( $blocks_to_insert ), null );
+                                array_splice( $inner_content, $content_index, 1, $nulls );
+                        }
+
+                        // Skip inserted blocks.
+                        $i += count( $blocks_to_insert );
+                } else {
+                        if ( ! empty( $blocks[ $i ]['innerBlocks'] ) ) {
+                                $prev_inner_content          = $inner_content;
+                                $inner_content               = $blocks[ $i ]['innerContent'];
+                                $blocks[ $i ]['innerBlocks'] = resolve_pattern_blocks(
+                                        $blocks[ $i ]['innerBlocks']
+                                );
+                                $blocks[ $i ]['innerContent'] = $inner_content;
+                                $inner_content               = $prev_inner_content;
+                        }
+                        ++$i;
+                }
+        }
+        return $blocks;
+}
+
+/**
  * Given an array of parsed block trees, applies callbacks before and after serializing them and
  * returns their concatenated output.