Adding upstream version 6.4.3+dfsg1.upstream/6.4.3+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 290 insertions, 0 deletions

diff --git a/wp-includes/class-wp-block-patterns-registry.php b/wp-includes/class-wp-block-patterns-registry.php
new file mode 100644
index 0000000..a11bac0
--- /dev/null
+++ b/wp-includes/class-wp-block-patterns-registry.php
@@ -0,0 +1,290 @@
+<?php
+/**
+ * Blocks API: WP_Block_Patterns_Registry class
+ *
+ * @package WordPress
+ * @subpackage Blocks
+ * @since 5.5.0
+ */
+
+/**
+ * Class used for interacting with block patterns.
+ *
+ * @since 5.5.0
+ */
+#[AllowDynamicProperties]
+final class WP_Block_Patterns_Registry {
+	/**
+	 * Registered block patterns array.
+	 *
+	 * @since 5.5.0
+	 * @var array[]
+	 */
+	private $registered_patterns = array();
+
+	/**
+	 * Patterns registered outside the `init` action.
+	 *
+	 * @since 6.0.0
+	 * @var array[]
+	 */
+	private $registered_patterns_outside_init = array();
+
+	/**
+	 * Container for the main instance of the class.
+	 *
+	 * @since 5.5.0
+	 * @var WP_Block_Patterns_Registry|null
+	 */
+	private static $instance = null;
+
+	/**
+	 * Registers a block pattern.
+	 *
+	 * @since 5.5.0
+	 * @since 5.8.0 Added support for the `blockTypes` property.
+	 * @since 6.1.0 Added support for the `postTypes` property.
+	 * @since 6.2.0 Added support for the `templateTypes` property.
+	 *
+	 * @param string $pattern_name       Block pattern name including namespace.
+	 * @param array  $pattern_properties {
+	 *     List of properties for the block pattern.
+	 *
+	 *     @type string   $title         Required. A human-readable title for the pattern.
+	 *     @type string   $content       Required. Block HTML markup for the pattern.
+	 *     @type string   $description   Optional. Visually hidden text used to describe the pattern
+	 *                                   in the inserter. A description is optional, but is strongly
+	 *                                   encouraged when the title does not fully describe what the
+	 *                                   pattern does. The description will help users discover the
+	 *                                   pattern while searching.
+	 *     @type int      $viewportWidth Optional. The intended width of the pattern to allow for a scaled
+	 *                                   preview within the pattern inserter.
+	 *     @type bool     $inserter      Optional. Determines whether the pattern is visible in inserter.
+	 *                                   To hide a pattern so that it can only be inserted programmatically,
+	 *                                   set this to false. Default true.
+	 *     @type string[] $categories    Optional. A list of registered pattern categories used to group
+	 *                                   block patterns. Block patterns can be shown on multiple categories.
+	 *                                   A category must be registered separately in order to be used here.
+	 *     @type string[] $keywords      Optional. A list of aliases or keywords that help users discover
+	 *                                   the pattern while searching.
+	 *     @type string[] $blockTypes    Optional. A list of block names including namespace that could use
+	 *                                   the block pattern in certain contexts (placeholder, transforms).
+	 *                                   The block pattern is available in the block editor inserter
+	 *                                   regardless of this list of block names.
+	 *                                   Certain blocks support further specificity besides the block name
+	 *                                   (e.g. for `core/template-part` you can specify areas
+	 *                                   like `core/template-part/header` or `core/template-part/footer`).
+	 *     @type string[] $postTypes     Optional. An array of post types that the pattern is restricted
+	 *                                   to be used with. The pattern will only be available when editing one
+	 *                                   of the post types passed on the array. For all the other post types
+	 *                                   not part of the array the pattern is not available at all.
+	 *     @type string[] $templateTypes Optional. An array of template types where the pattern fits.
+	 * }
+	 * @return bool True if the pattern was registered with success and false otherwise.
+	 */
+	public function register( $pattern_name, $pattern_properties ) {
+		if ( ! isset( $pattern_name ) || ! is_string( $pattern_name ) ) {
+			_doing_it_wrong(
+				__METHOD__,
+				__( 'Pattern name must be a string.' ),
+				'5.5.0'
+			);
+			return false;
+		}
+
+		if ( ! isset( $pattern_properties['title'] ) || ! is_string( $pattern_properties['title'] ) ) {
+			_doing_it_wrong(
+				__METHOD__,
+				__( 'Pattern title must be a string.' ),
+				'5.5.0'
+			);
+			return false;
+		}
+
+		if ( ! isset( $pattern_properties['content'] ) || ! is_string( $pattern_properties['content'] ) ) {
+			_doing_it_wrong(
+				__METHOD__,
+				__( 'Pattern content must be a string.' ),
+				'5.5.0'
+			);
+			return false;
+		}
+
+		$pattern = array_merge(
+			$pattern_properties,
+			array( 'name' => $pattern_name )
+		);
+
+		$this->registered_patterns[ $pattern_name ] = $pattern;
+
+		// If the pattern is registered inside an action other than `init`, store it
+		// also to a dedicated array. Used to detect deprecated registrations inside
+		// `admin_init` or `current_screen`.
+		if ( current_action() && 'init' !== current_action() ) {
+			$this->registered_patterns_outside_init[ $pattern_name ] = $pattern;
+		}
+
+		return true;
+	}
+
+	/**
+	 * Unregisters a block pattern.
+	 *
+	 * @since 5.5.0
+	 *
+	 * @param string $pattern_name Block pattern name including namespace.
+	 * @return bool True if the pattern was unregistered with success and false otherwise.
+	 */
+	public function unregister( $pattern_name ) {
+		if ( ! $this->is_registered( $pattern_name ) ) {
+			_doing_it_wrong(
+				__METHOD__,
+				/* translators: %s: Pattern name. */
+				sprintf( __( 'Pattern "%s" not found.' ), $pattern_name ),
+				'5.5.0'
+			);
+			return false;
+		}
+
+		unset( $this->registered_patterns[ $pattern_name ] );
+		unset( $this->registered_patterns_outside_init[ $pattern_name ] );
+
+		return true;
+	}
+
+	/**
+	 * Prepares the content of a block pattern. If hooked blocks are registered, they get injected into the pattern,
+	 * when they met the defined criteria.
+	 *
+	 * @since 6.4.0
+	 *
+	 * @param array $pattern       Registered pattern properties.
+	 * @param array $hooked_blocks The list of hooked blocks.
+	 * @return string The content of the block pattern.
+	 */
+	private function prepare_content( $pattern, $hooked_blocks ) {
+		$content = $pattern['content'];
+
+		$before_block_visitor = '_inject_theme_attribute_in_template_part_block';
+		$after_block_visitor  = null;
+		if ( ! empty( $hooked_blocks ) || has_filter( 'hooked_block_types' ) ) {
+			$before_block_visitor = make_before_block_visitor( $hooked_blocks, $pattern );
+			$after_block_visitor  = make_after_block_visitor( $hooked_blocks, $pattern );
+		}
+		$blocks  = parse_blocks( $content );
+		$content = traverse_and_serialize_blocks( $blocks, $before_block_visitor, $after_block_visitor );
+
+		return $content;
+	}
+
+	/**
+	 * Retrieves an array containing the properties of a registered block pattern.
+	 *
+	 * @since 5.5.0
+	 *
+	 * @param string $pattern_name Block pattern name including namespace.
+	 * @return array Registered pattern properties.
+	 */
+	public function get_registered( $pattern_name ) {
+		if ( ! $this->is_registered( $pattern_name ) ) {
+			return null;
+		}
+
+		$pattern            = $this->registered_patterns[ $pattern_name ];
+		$pattern['content'] = $this->prepare_content( $pattern, get_hooked_blocks() );
+
+		return $pattern;
+	}
+
+	/**
+	 * Retrieves all registered block patterns.
+	 *
+	 * @since 5.5.0
+	 *
+	 * @param bool $outside_init_only Return only patterns registered outside the `init` action.
+	 * @return array[] Array of arrays containing the registered block patterns properties,
+	 *                 and per style.
+	 */
+	public function get_all_registered( $outside_init_only = false ) {
+		$patterns      = array_values(
+			$outside_init_only
+				? $this->registered_patterns_outside_init
+				: $this->registered_patterns
+		);
+		$hooked_blocks = get_hooked_blocks();
+		foreach ( $patterns as $index => $pattern ) {
+			$patterns[ $index ]['content'] = $this->prepare_content( $pattern, $hooked_blocks );
+		}
+		return $patterns;
+	}
+
+	/**
+	 * Checks if a block pattern is registered.
+	 *
+	 * @since 5.5.0
+	 *
+	 * @param string $pattern_name Block pattern name including namespace.
+	 * @return bool True if the pattern is registered, false otherwise.
+	 */
+	public function is_registered( $pattern_name ) {
+		return isset( $this->registered_patterns[ $pattern_name ] );
+	}
+
+	public function __wakeup() {
+		if ( ! $this->registered_patterns ) {
+			return;
+		}
+		if ( ! is_array( $this->registered_patterns ) ) {
+			throw new UnexpectedValueException();
+		}
+		foreach ( $this->registered_patterns as $value ) {
+			if ( ! is_array( $value ) ) {
+				throw new UnexpectedValueException();
+			}
+		}
+		$this->registered_patterns_outside_init = array();
+	}
+
+	/**
+	 * Utility method to retrieve the main instance of the class.
+	 *
+	 * The instance will be created if it does not exist yet.
+	 *
+	 * @since 5.5.0
+	 *
+	 * @return WP_Block_Patterns_Registry The main instance.
+	 */
+	public static function get_instance() {
+		if ( null === self::$instance ) {
+			self::$instance = new self();
+		}
+
+		return self::$instance;
+	}
+}
+
+/**
+ * Registers a new block pattern.
+ *
+ * @since 5.5.0
+ *
+ * @param string $pattern_name       Block pattern name including namespace.
+ * @param array  $pattern_properties List of properties for the block pattern.
+ *                                   See WP_Block_Patterns_Registry::register() for accepted arguments.
+ * @return bool True if the pattern was registered with success and false otherwise.
+ */
+function register_block_pattern( $pattern_name, $pattern_properties ) {
+	return WP_Block_Patterns_Registry::get_instance()->register( $pattern_name, $pattern_properties );
+}
+
+/**
+ * Unregisters a block pattern.
+ *
+ * @since 5.5.0
+ *
+ * @param string $pattern_name Block pattern name including namespace.
+ * @return bool True if the pattern was unregistered with success and false otherwise.
+ */
+function unregister_block_pattern( $pattern_name ) {
+	return WP_Block_Patterns_Registry::get_instance()->unregister( $pattern_name );
+}