2020-07-06 12:50:02 +02:00
|
|
|
<?php
|
|
|
|
/**
|
|
|
|
* Register the block patterns and block patterns categories
|
|
|
|
*
|
|
|
|
* @package WordPress
|
|
|
|
* @since 5.5.0
|
|
|
|
*/
|
|
|
|
|
2020-07-16 13:50:07 +02:00
|
|
|
add_theme_support( 'core-block-patterns' );
|
2020-07-06 12:50:02 +02:00
|
|
|
|
2020-07-16 13:50:07 +02:00
|
|
|
/**
|
|
|
|
* Registers the core block patterns and categories.
|
|
|
|
*
|
|
|
|
* @since 5.5.0
|
2023-06-27 13:13:27 +02:00
|
|
|
* @since 6.3.0 Added source to core block patterns.
|
2022-04-12 11:26:16 +02:00
|
|
|
* @access private
|
2020-07-16 13:50:07 +02:00
|
|
|
*/
|
|
|
|
function _register_core_block_patterns_and_categories() {
|
|
|
|
$should_register_core_patterns = get_theme_support( 'core-block-patterns' );
|
|
|
|
|
|
|
|
if ( $should_register_core_patterns ) {
|
|
|
|
$core_block_patterns = array(
|
2021-05-21 13:13:57 +02:00
|
|
|
'query-standard-posts',
|
|
|
|
'query-medium-posts',
|
|
|
|
'query-small-posts',
|
|
|
|
'query-grid-posts',
|
|
|
|
'query-large-title-posts',
|
|
|
|
'query-offset-posts',
|
|
|
|
'social-links-shared-background-color',
|
2020-07-16 13:50:07 +02:00
|
|
|
);
|
|
|
|
|
|
|
|
foreach ( $core_block_patterns as $core_block_pattern ) {
|
2023-06-27 13:13:27 +02:00
|
|
|
$pattern = require __DIR__ . '/block-patterns/' . $core_block_pattern . '.php';
|
|
|
|
$pattern['source'] = 'core';
|
|
|
|
register_block_pattern( 'core/' . $core_block_pattern, $pattern );
|
2020-07-16 13:50:07 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-19 13:21:19 +01:00
|
|
|
register_block_pattern_category( 'banner', array( 'label' => _x( 'Banners', 'Block pattern category' ) ) );
|
|
|
|
register_block_pattern_category(
|
|
|
|
'buttons',
|
|
|
|
array(
|
|
|
|
'label' => _x( 'Buttons', 'Block pattern category' ),
|
|
|
|
'description' => __( 'Patterns that contain buttons and call to actions.' ),
|
|
|
|
)
|
|
|
|
);
|
|
|
|
register_block_pattern_category(
|
|
|
|
'columns',
|
|
|
|
array(
|
|
|
|
'label' => _x( 'Columns', 'Block pattern category' ),
|
|
|
|
'description' => __( 'Multi-column patterns with more complex layouts.' ),
|
|
|
|
)
|
|
|
|
);
|
|
|
|
register_block_pattern_category(
|
|
|
|
'text',
|
|
|
|
array(
|
|
|
|
'label' => _x( 'Text', 'Block pattern category' ),
|
|
|
|
'description' => __( 'Patterns containing mostly text.' ),
|
|
|
|
)
|
|
|
|
);
|
|
|
|
register_block_pattern_category(
|
|
|
|
'query',
|
|
|
|
array(
|
|
|
|
'label' => _x( 'Posts', 'Block pattern category' ),
|
|
|
|
'description' => __( 'Display your latest posts in lists, grids or other layouts.' ),
|
|
|
|
)
|
|
|
|
);
|
|
|
|
register_block_pattern_category(
|
|
|
|
'featured',
|
|
|
|
array(
|
|
|
|
'label' => _x( 'Featured', 'Block pattern category' ),
|
|
|
|
'description' => __( 'A set of high quality curated patterns.' ),
|
|
|
|
)
|
|
|
|
);
|
|
|
|
register_block_pattern_category(
|
|
|
|
'call-to-action',
|
|
|
|
array(
|
|
|
|
'label' => _x( 'Call to Action', 'Block pattern category' ),
|
|
|
|
'description' => __( 'Sections whose purpose is to trigger a specific action.' ),
|
|
|
|
)
|
|
|
|
);
|
|
|
|
register_block_pattern_category(
|
|
|
|
'team',
|
|
|
|
array(
|
|
|
|
'label' => _x( 'Team', 'Block pattern category' ),
|
|
|
|
'description' => __( 'A variety of designs to display your team members.' ),
|
|
|
|
)
|
|
|
|
);
|
|
|
|
register_block_pattern_category(
|
|
|
|
'testimonials',
|
|
|
|
array(
|
|
|
|
'label' => _x( 'Testimonials', 'Block pattern category' ),
|
|
|
|
'description' => __( 'Share reviews and feedback about your brand/business.' ),
|
|
|
|
)
|
|
|
|
);
|
|
|
|
register_block_pattern_category(
|
|
|
|
'services',
|
|
|
|
array(
|
|
|
|
'label' => _x( 'Services', 'Block pattern category' ),
|
|
|
|
'description' => __( 'Briefly describe what your business does and how you can help.' ),
|
|
|
|
)
|
|
|
|
);
|
|
|
|
register_block_pattern_category(
|
|
|
|
'contact',
|
|
|
|
array(
|
|
|
|
'label' => _x( 'Contact', 'Block pattern category' ),
|
|
|
|
'description' => __( 'Display your contact information.' ),
|
|
|
|
)
|
|
|
|
);
|
|
|
|
register_block_pattern_category(
|
|
|
|
'about',
|
|
|
|
array(
|
|
|
|
'label' => _x( 'About', 'Block pattern category' ),
|
|
|
|
'description' => __( 'Introduce yourself.' ),
|
|
|
|
)
|
|
|
|
);
|
|
|
|
register_block_pattern_category(
|
|
|
|
'portfolio',
|
|
|
|
array(
|
|
|
|
'label' => _x( 'Portfolio', 'Block pattern category' ),
|
|
|
|
'description' => __( 'Showcase your latest work.' ),
|
|
|
|
)
|
|
|
|
);
|
|
|
|
register_block_pattern_category(
|
|
|
|
'gallery',
|
|
|
|
array(
|
|
|
|
'label' => _x( 'Gallery', 'Block pattern category' ),
|
|
|
|
'description' => __( 'Different layouts for displaying images.' ),
|
|
|
|
)
|
|
|
|
);
|
|
|
|
register_block_pattern_category(
|
|
|
|
'media',
|
|
|
|
array(
|
|
|
|
'label' => _x( 'Media', 'Block pattern category' ),
|
|
|
|
'description' => __( 'Different layouts containing video or audio.' ),
|
|
|
|
)
|
|
|
|
);
|
|
|
|
register_block_pattern_category(
|
|
|
|
'posts',
|
|
|
|
array(
|
|
|
|
'label' => _x( 'Posts', 'Block pattern category' ),
|
|
|
|
'description' => __( 'Display your latest posts in lists, grids or other layouts.' ),
|
|
|
|
)
|
|
|
|
);
|
|
|
|
register_block_pattern_category(
|
|
|
|
'footer',
|
|
|
|
array(
|
|
|
|
'label' => _x( 'Footers', 'Block pattern category' ),
|
|
|
|
'description' => __( 'A variety of footer designs displaying information and site navigation.' ),
|
|
|
|
)
|
|
|
|
);
|
|
|
|
register_block_pattern_category(
|
|
|
|
'header',
|
|
|
|
array(
|
|
|
|
'label' => _x( 'Headers', 'Block pattern category' ),
|
|
|
|
'description' => __( 'A variety of header designs displaying your site title and navigation.' ),
|
|
|
|
)
|
|
|
|
);
|
2020-07-06 12:50:02 +02:00
|
|
|
}
|
2021-05-26 03:11:59 +02:00
|
|
|
|
2023-02-06 20:40:16 +01:00
|
|
|
/**
|
|
|
|
* Normalize the pattern properties to camelCase.
|
|
|
|
*
|
|
|
|
* The API's format is snake_case, `register_block_pattern()` expects camelCase.
|
|
|
|
*
|
|
|
|
* @since 6.2.0
|
|
|
|
* @access private
|
|
|
|
*
|
|
|
|
* @param array $pattern Pattern as returned from the Pattern Directory API.
|
|
|
|
* @return array Normalized pattern.
|
|
|
|
*/
|
|
|
|
function wp_normalize_remote_block_pattern( $pattern ) {
|
|
|
|
if ( isset( $pattern['block_types'] ) ) {
|
|
|
|
$pattern['blockTypes'] = $pattern['block_types'];
|
|
|
|
unset( $pattern['block_types'] );
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( isset( $pattern['viewport_width'] ) ) {
|
|
|
|
$pattern['viewportWidth'] = $pattern['viewport_width'];
|
|
|
|
unset( $pattern['viewport_width'] );
|
|
|
|
}
|
|
|
|
|
|
|
|
return (array) $pattern;
|
|
|
|
}
|
|
|
|
|
2021-05-26 03:11:59 +02:00
|
|
|
/**
|
2021-06-22 23:24:58 +02:00
|
|
|
* Register Core's official patterns from wordpress.org/patterns.
|
|
|
|
*
|
|
|
|
* @since 5.8.0
|
Editor: Explicitly load remote block patterns in the block and site editor screens.
Remote block patterns from wp.org were to be loaded through a callback hooked into the `current_screen` filter. Within 2 callbacks, i.e. `_load_remote_featured_patterns()` and `_load_remote_block_patterns()`, a guard clause bailed out early if the `$current_screen->is_block_editor` is `false`.
However, the `current_screen` filter is unreliable to detect the block editor. Why? In the block and Site Editor screens, `$current_scren->is_block_editor` is not set until after the filter is executed. Whoopsie.
This commit no longer uses the `current_screen` filter. Instead, it explicitly loads the remote block patterns by invoking both private functions (now not callbacks) directly in the screen files for the block and site editor screens.
With this change, passing `WP_Screen` object into these functions is no longer needed. As the `_load_remote_block_patterns()` function was introduced in 5.8.0, its function parameter is now deprecated and the guard clause retained for backwards compatibility.
Follow-up to [51021], [52377].
Props poena, noisysocks, peterwilsoncc, hellofromTonya, audrasjb.
Fixes #54806.
Built from https://develop.svn.wordpress.org/trunk@52593
git-svn-id: http://core.svn.wordpress.org/trunk@52181 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2022-01-17 23:42:03 +01:00
|
|
|
* @since 5.9.0 The $current_screen argument was removed.
|
2023-02-06 20:40:16 +01:00
|
|
|
* @since 6.2.0 Normalize the pattern from the API (snake_case) to the
|
|
|
|
* format expected by `register_block_pattern` (camelCase).
|
2023-06-27 13:13:27 +02:00
|
|
|
* @since 6.3.0 Add 'pattern-directory/core' to the pattern's 'source'.
|
2021-06-22 23:24:58 +02:00
|
|
|
*
|
Editor: Explicitly load remote block patterns in the block and site editor screens.
Remote block patterns from wp.org were to be loaded through a callback hooked into the `current_screen` filter. Within 2 callbacks, i.e. `_load_remote_featured_patterns()` and `_load_remote_block_patterns()`, a guard clause bailed out early if the `$current_screen->is_block_editor` is `false`.
However, the `current_screen` filter is unreliable to detect the block editor. Why? In the block and Site Editor screens, `$current_scren->is_block_editor` is not set until after the filter is executed. Whoopsie.
This commit no longer uses the `current_screen` filter. Instead, it explicitly loads the remote block patterns by invoking both private functions (now not callbacks) directly in the screen files for the block and site editor screens.
With this change, passing `WP_Screen` object into these functions is no longer needed. As the `_load_remote_block_patterns()` function was introduced in 5.8.0, its function parameter is now deprecated and the guard clause retained for backwards compatibility.
Follow-up to [51021], [52377].
Props poena, noisysocks, peterwilsoncc, hellofromTonya, audrasjb.
Fixes #54806.
Built from https://develop.svn.wordpress.org/trunk@52593
git-svn-id: http://core.svn.wordpress.org/trunk@52181 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2022-01-17 23:42:03 +01:00
|
|
|
* @param WP_Screen $deprecated Unused. Formerly the screen that the current request was triggered from.
|
2021-05-26 03:11:59 +02:00
|
|
|
*/
|
Editor: Explicitly load remote block patterns in the block and site editor screens.
Remote block patterns from wp.org were to be loaded through a callback hooked into the `current_screen` filter. Within 2 callbacks, i.e. `_load_remote_featured_patterns()` and `_load_remote_block_patterns()`, a guard clause bailed out early if the `$current_screen->is_block_editor` is `false`.
However, the `current_screen` filter is unreliable to detect the block editor. Why? In the block and Site Editor screens, `$current_scren->is_block_editor` is not set until after the filter is executed. Whoopsie.
This commit no longer uses the `current_screen` filter. Instead, it explicitly loads the remote block patterns by invoking both private functions (now not callbacks) directly in the screen files for the block and site editor screens.
With this change, passing `WP_Screen` object into these functions is no longer needed. As the `_load_remote_block_patterns()` function was introduced in 5.8.0, its function parameter is now deprecated and the guard clause retained for backwards compatibility.
Follow-up to [51021], [52377].
Props poena, noisysocks, peterwilsoncc, hellofromTonya, audrasjb.
Fixes #54806.
Built from https://develop.svn.wordpress.org/trunk@52593
git-svn-id: http://core.svn.wordpress.org/trunk@52181 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2022-01-17 23:42:03 +01:00
|
|
|
function _load_remote_block_patterns( $deprecated = null ) {
|
|
|
|
if ( ! empty( $deprecated ) ) {
|
|
|
|
_deprecated_argument( __FUNCTION__, '5.9.0' );
|
|
|
|
$current_screen = $deprecated;
|
|
|
|
if ( ! $current_screen->is_block_editor ) {
|
|
|
|
return;
|
|
|
|
}
|
2021-05-26 03:11:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
$supports_core_patterns = get_theme_support( 'core-block-patterns' );
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Filter to disable remote block patterns.
|
|
|
|
*
|
|
|
|
* @since 5.8.0
|
|
|
|
*
|
|
|
|
* @param bool $should_load_remote
|
|
|
|
*/
|
|
|
|
$should_load_remote = apply_filters( 'should_load_remote_block_patterns', true );
|
|
|
|
|
|
|
|
if ( $supports_core_patterns && $should_load_remote ) {
|
2021-06-22 23:24:58 +02:00
|
|
|
$request = new WP_REST_Request( 'GET', '/wp/v2/pattern-directory/patterns' );
|
|
|
|
$core_keyword_id = 11; // 11 is the ID for "core".
|
|
|
|
$request->set_param( 'keyword', $core_keyword_id );
|
|
|
|
$response = rest_do_request( $request );
|
|
|
|
if ( $response->is_error() ) {
|
|
|
|
return;
|
2021-05-26 03:11:59 +02:00
|
|
|
}
|
2021-06-22 23:24:58 +02:00
|
|
|
$patterns = $response->get_data();
|
2021-05-26 03:11:59 +02:00
|
|
|
|
2023-02-06 20:40:16 +01:00
|
|
|
foreach ( $patterns as $pattern ) {
|
2023-06-27 13:13:27 +02:00
|
|
|
$pattern['source'] = 'pattern-directory/core';
|
2023-02-06 20:40:16 +01:00
|
|
|
$normalized_pattern = wp_normalize_remote_block_pattern( $pattern );
|
|
|
|
$pattern_name = 'core/' . sanitize_title( $normalized_pattern['title'] );
|
|
|
|
register_block_pattern( $pattern_name, $normalized_pattern );
|
2021-05-26 03:11:59 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-12-14 20:39:06 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Register `Featured` (category) patterns from wordpress.org/patterns.
|
|
|
|
*
|
|
|
|
* @since 5.9.0
|
2023-02-06 20:40:16 +01:00
|
|
|
* @since 6.2.0 Normalized the pattern from the API (snake_case) to the
|
|
|
|
* format expected by `register_block_pattern()` (camelCase).
|
2023-06-27 13:13:27 +02:00
|
|
|
* @since 6.3.0 Add 'pattern-directory/featured' to the pattern's 'source'.
|
2021-12-14 20:39:06 +01:00
|
|
|
*/
|
Editor: Explicitly load remote block patterns in the block and site editor screens.
Remote block patterns from wp.org were to be loaded through a callback hooked into the `current_screen` filter. Within 2 callbacks, i.e. `_load_remote_featured_patterns()` and `_load_remote_block_patterns()`, a guard clause bailed out early if the `$current_screen->is_block_editor` is `false`.
However, the `current_screen` filter is unreliable to detect the block editor. Why? In the block and Site Editor screens, `$current_scren->is_block_editor` is not set until after the filter is executed. Whoopsie.
This commit no longer uses the `current_screen` filter. Instead, it explicitly loads the remote block patterns by invoking both private functions (now not callbacks) directly in the screen files for the block and site editor screens.
With this change, passing `WP_Screen` object into these functions is no longer needed. As the `_load_remote_block_patterns()` function was introduced in 5.8.0, its function parameter is now deprecated and the guard clause retained for backwards compatibility.
Follow-up to [51021], [52377].
Props poena, noisysocks, peterwilsoncc, hellofromTonya, audrasjb.
Fixes #54806.
Built from https://develop.svn.wordpress.org/trunk@52593
git-svn-id: http://core.svn.wordpress.org/trunk@52181 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2022-01-17 23:42:03 +01:00
|
|
|
function _load_remote_featured_patterns() {
|
2021-12-14 20:39:06 +01:00
|
|
|
$supports_core_patterns = get_theme_support( 'core-block-patterns' );
|
|
|
|
|
|
|
|
/** This filter is documented in wp-includes/block-patterns.php */
|
|
|
|
$should_load_remote = apply_filters( 'should_load_remote_block_patterns', true );
|
|
|
|
|
|
|
|
if ( ! $should_load_remote || ! $supports_core_patterns ) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
$request = new WP_REST_Request( 'GET', '/wp/v2/pattern-directory/patterns' );
|
|
|
|
$featured_cat_id = 26; // This is the `Featured` category id from pattern directory.
|
|
|
|
$request->set_param( 'category', $featured_cat_id );
|
|
|
|
$response = rest_do_request( $request );
|
|
|
|
if ( $response->is_error() ) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
$patterns = $response->get_data();
|
2023-02-06 20:40:16 +01:00
|
|
|
$registry = WP_Block_Patterns_Registry::get_instance();
|
2021-12-14 20:39:06 +01:00
|
|
|
foreach ( $patterns as $pattern ) {
|
2023-06-27 13:13:27 +02:00
|
|
|
$pattern['source'] = 'pattern-directory/featured';
|
2023-02-06 20:40:16 +01:00
|
|
|
$normalized_pattern = wp_normalize_remote_block_pattern( $pattern );
|
|
|
|
$pattern_name = sanitize_title( $normalized_pattern['title'] );
|
2022-01-18 21:29:06 +01:00
|
|
|
// Some patterns might be already registered as core patterns with the `core` prefix.
|
2021-12-14 20:39:06 +01:00
|
|
|
$is_registered = $registry->is_registered( $pattern_name ) || $registry->is_registered( "core/$pattern_name" );
|
|
|
|
if ( ! $is_registered ) {
|
2023-02-06 20:40:16 +01:00
|
|
|
register_block_pattern( $pattern_name, $normalized_pattern );
|
2021-12-14 20:39:06 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-04-12 11:26:16 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Registers patterns from Pattern Directory provided by a theme's
|
|
|
|
* `theme.json` file.
|
|
|
|
*
|
|
|
|
* @since 6.0.0
|
2023-02-06 20:40:16 +01:00
|
|
|
* @since 6.2.0 Normalized the pattern from the API (snake_case) to the
|
|
|
|
* format expected by `register_block_pattern()` (camelCase).
|
2023-06-27 13:13:27 +02:00
|
|
|
* @since 6.3.0 Add 'pattern-directory/theme' to the pattern's 'source'.
|
2022-04-12 11:26:16 +02:00
|
|
|
* @access private
|
|
|
|
*/
|
|
|
|
function _register_remote_theme_patterns() {
|
|
|
|
/** This filter is documented in wp-includes/block-patterns.php */
|
|
|
|
if ( ! apply_filters( 'should_load_remote_block_patterns', true ) ) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
Themes: Introduce wp_theme_has_theme_json() for public consumption.
Adds `wp_theme_has_theme_json()` for public consumption, to replace the private internal Core-only `WP_Theme_JSON_Resolver::theme_has_support()` method. This new global function checks if a theme or its parent has a `theme.json` file.
For performance, results are cached as an integer `1` or `0` in the `'theme_json'` group with `'wp_theme_has_theme_json'` key. This is a non-persistent cache. Why? To make the derived data from `theme.json` is always fresh from the potential modifications done via hooks that can use dynamic data (modify the stylesheet depending on some option, settings depending on user permissions, etc.).
Also adds a new public function `wp_clean_theme_json_cache()` to clear the cache on `'switch_theme'` and `start_previewing_theme'`.
References:
* [https://github.com/WordPress/gutenberg/pull/45168 Gutenberg PR 45168] Add `wp_theme_has_theme_json` as a public API to know whether a theme has a `theme.json`.
* [https://github.com/WordPress/gutenberg/pull/45380 Gutenberg PR 45380] Deprecate `WP_Theme_JSON_Resolver:theme_has_support()`.
* [https://github.com/WordPress/gutenberg/pull/46150 Gutenberg PR 46150] Make `theme.json` object caches non-persistent.
* [https://github.com/WordPress/gutenberg/pull/45979 Gutenberg PR 45979] Don't check if constants set by `wp_initial_constants()` are defined.
* [https://github.com/WordPress/gutenberg/pull/45950 Gutenberg PR 45950] Cleaner logic in `wp_theme_has_theme_json`.
Follow-up to [54493], [53282], [52744], [52049], [50959].
Props oandregal, afragen, alexstine, aristath, azaozz, costdev, flixos90, hellofromTonya, mamaduka, mcsf, ocean90, spacedmonkey.
Fixes #56975.
Built from https://develop.svn.wordpress.org/trunk@55086
git-svn-id: http://core.svn.wordpress.org/trunk@54619 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-01-18 12:40:10 +01:00
|
|
|
if ( ! wp_theme_has_theme_json() ) {
|
2022-04-12 11:26:16 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-06-22 09:16:19 +02:00
|
|
|
$pattern_settings = wp_get_theme_directory_pattern_slugs();
|
2022-04-12 11:26:16 +02:00
|
|
|
if ( empty( $pattern_settings ) ) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
$request = new WP_REST_Request( 'GET', '/wp/v2/pattern-directory/patterns' );
|
2022-04-19 16:58:09 +02:00
|
|
|
$request['slug'] = $pattern_settings;
|
2022-04-12 11:26:16 +02:00
|
|
|
$response = rest_do_request( $request );
|
|
|
|
if ( $response->is_error() ) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
$patterns = $response->get_data();
|
|
|
|
$patterns_registry = WP_Block_Patterns_Registry::get_instance();
|
|
|
|
foreach ( $patterns as $pattern ) {
|
2023-06-27 13:13:27 +02:00
|
|
|
$pattern['source'] = 'pattern-directory/theme';
|
2023-02-06 20:40:16 +01:00
|
|
|
$normalized_pattern = wp_normalize_remote_block_pattern( $pattern );
|
|
|
|
$pattern_name = sanitize_title( $normalized_pattern['title'] );
|
2022-04-12 11:26:16 +02:00
|
|
|
// Some patterns might be already registered as core patterns with the `core` prefix.
|
|
|
|
$is_registered = $patterns_registry->is_registered( $pattern_name ) || $patterns_registry->is_registered( "core/$pattern_name" );
|
|
|
|
if ( ! $is_registered ) {
|
2023-02-06 20:40:16 +01:00
|
|
|
register_block_pattern( $pattern_name, $normalized_pattern );
|
2022-04-12 11:26:16 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Register any patterns that the active theme may provide under its
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
* `./patterns/` directory.
|
2022-04-12 11:26:16 +02:00
|
|
|
*
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
* @since 6.0.0
|
|
|
|
* @since 6.1.0 The `postTypes` property was added.
|
|
|
|
* @since 6.2.0 The `templateTypes` property was added.
|
|
|
|
* @since 6.4.0 Uses the `_wp_get_block_patterns` function.
|
|
|
|
* @access private
|
|
|
|
*/
|
|
|
|
function _register_theme_block_patterns() {
|
|
|
|
/*
|
|
|
|
* Register patterns for the active theme. If the theme is a child theme,
|
|
|
|
* let it override any patterns from the parent theme that shares the same slug.
|
|
|
|
*/
|
|
|
|
$themes = array();
|
|
|
|
$theme = wp_get_theme();
|
|
|
|
$themes[] = $theme;
|
|
|
|
if ( $theme->parent() ) {
|
|
|
|
$themes[] = $theme->parent();
|
|
|
|
}
|
|
|
|
$registry = WP_Block_Patterns_Registry::get_instance();
|
|
|
|
|
|
|
|
foreach ( $themes as $theme ) {
|
2023-10-03 20:19:23 +02:00
|
|
|
$patterns = _wp_get_block_patterns( $theme );
|
|
|
|
$dirpath = $theme->get_stylesheet_directory() . '/patterns/';
|
|
|
|
$text_domain = $theme->get( 'TextDomain' );
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
|
2023-10-03 20:19:23 +02:00
|
|
|
foreach ( $patterns as $file => $pattern_data ) {
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
if ( $registry->is_registered( $pattern_data['slug'] ) ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2023-10-13 18:46:25 +02:00
|
|
|
$file_path = $dirpath . $file;
|
|
|
|
|
|
|
|
if ( ! file_exists( $file_path ) ) {
|
|
|
|
_doing_it_wrong(
|
|
|
|
__FUNCTION__,
|
|
|
|
sprintf(
|
|
|
|
/* translators: %s: file name. */
|
|
|
|
__( 'Could not register file "%s" as a block pattern as the file does not exist.' ),
|
|
|
|
$file
|
|
|
|
),
|
|
|
|
'6.4.0'
|
|
|
|
);
|
|
|
|
$theme->delete_pattern_cache();
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
// The actual pattern content is the output of the file.
|
|
|
|
ob_start();
|
2023-10-13 18:46:25 +02:00
|
|
|
include $file_path;
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
$pattern_data['content'] = ob_get_clean();
|
|
|
|
if ( ! $pattern_data['content'] ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Translate the pattern metadata.
|
|
|
|
// phpcs:ignore WordPress.WP.I18n.NonSingularStringLiteralText,WordPress.WP.I18n.NonSingularStringLiteralDomain,WordPress.WP.I18n.LowLevelTranslationFunction
|
|
|
|
$pattern_data['title'] = translate_with_gettext_context( $pattern_data['title'], 'Pattern title', $text_domain );
|
|
|
|
if ( ! empty( $pattern_data['description'] ) ) {
|
|
|
|
// phpcs:ignore WordPress.WP.I18n.NonSingularStringLiteralText,WordPress.WP.I18n.NonSingularStringLiteralDomain,WordPress.WP.I18n.LowLevelTranslationFunction
|
|
|
|
$pattern_data['description'] = translate_with_gettext_context( $pattern_data['description'], 'Pattern description', $text_domain );
|
|
|
|
}
|
|
|
|
|
|
|
|
register_block_pattern( $pattern_data['slug'], $pattern_data );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
add_action( 'init', '_register_theme_block_patterns' );
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Gets block pattern data for a specified theme.
|
|
|
|
* Each pattern is defined as a PHP file and defines
|
|
|
|
* its metadata using plugin-style headers. The minimum required definition is:
|
2022-04-12 11:26:16 +02:00
|
|
|
*
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
* /**
|
|
|
|
* * Title: My Pattern
|
|
|
|
* * Slug: my-theme/my-pattern
|
|
|
|
* *
|
2022-04-12 11:26:16 +02:00
|
|
|
*
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
* The output of the PHP source corresponds to the content of the pattern, e.g.:
|
2022-04-12 11:26:16 +02:00
|
|
|
*
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
* <main><p><?php echo "Hello"; ?></p></main>
|
2022-04-12 11:26:16 +02:00
|
|
|
*
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
* If applicable, this will collect from both parent and child theme.
|
2022-04-12 11:26:16 +02:00
|
|
|
*
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
* Other settable fields include:
|
2022-04-12 11:26:16 +02:00
|
|
|
*
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
* - Description
|
|
|
|
* - Viewport Width
|
|
|
|
* - Inserter (yes/no)
|
|
|
|
* - Categories (comma-separated values)
|
|
|
|
* - Keywords (comma-separated values)
|
|
|
|
* - Block Types (comma-separated values)
|
|
|
|
* - Post Types (comma-separated values)
|
|
|
|
* - Template Types (comma-separated values)
|
|
|
|
*
|
|
|
|
* @since 6.4.0
|
2022-04-12 11:26:16 +02:00
|
|
|
* @access private
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
*
|
|
|
|
* @param WP_Theme $theme Theme object.
|
|
|
|
* @return array Block pattern data.
|
2022-04-12 11:26:16 +02:00
|
|
|
*/
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
function _wp_get_block_patterns( WP_Theme $theme ) {
|
|
|
|
$can_use_cached = ! wp_is_development_mode( 'theme' );
|
|
|
|
|
2023-10-13 18:46:25 +02:00
|
|
|
$pattern_data = $theme->get_pattern_cache();
|
|
|
|
if ( is_array( $pattern_data ) ) {
|
|
|
|
if ( $can_use_cached ) {
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
return $pattern_data;
|
|
|
|
}
|
2023-10-13 18:46:25 +02:00
|
|
|
// If in development mode, clear pattern cache.
|
|
|
|
$theme->delete_pattern_cache();
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
$dirpath = $theme->get_stylesheet_directory() . '/patterns/';
|
2023-10-03 20:19:23 +02:00
|
|
|
$pattern_data = array();
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
|
|
|
|
if ( ! file_exists( $dirpath ) ) {
|
|
|
|
if ( $can_use_cached ) {
|
2023-10-03 20:19:23 +02:00
|
|
|
$theme->set_pattern_cache( $pattern_data );
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
}
|
|
|
|
return $pattern_data;
|
|
|
|
}
|
|
|
|
$files = glob( $dirpath . '*.php' );
|
|
|
|
if ( ! $files ) {
|
|
|
|
if ( $can_use_cached ) {
|
2023-10-03 20:19:23 +02:00
|
|
|
$theme->set_pattern_cache( $pattern_data );
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
}
|
|
|
|
return $pattern_data;
|
|
|
|
}
|
|
|
|
|
2022-04-12 11:26:16 +02:00
|
|
|
$default_headers = array(
|
|
|
|
'title' => 'Title',
|
|
|
|
'slug' => 'Slug',
|
|
|
|
'description' => 'Description',
|
|
|
|
'viewportWidth' => 'Viewport Width',
|
2023-02-01 16:02:14 +01:00
|
|
|
'inserter' => 'Inserter',
|
2022-04-12 11:26:16 +02:00
|
|
|
'categories' => 'Categories',
|
|
|
|
'keywords' => 'Keywords',
|
|
|
|
'blockTypes' => 'Block Types',
|
2022-09-20 18:29:12 +02:00
|
|
|
'postTypes' => 'Post Types',
|
2023-01-31 17:49:16 +01:00
|
|
|
'templateTypes' => 'Template Types',
|
2022-04-12 11:26:16 +02:00
|
|
|
);
|
|
|
|
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
$properties_to_parse = array(
|
|
|
|
'categories',
|
|
|
|
'keywords',
|
|
|
|
'blockTypes',
|
|
|
|
'postTypes',
|
|
|
|
'templateTypes',
|
|
|
|
);
|
2022-04-12 11:26:16 +02:00
|
|
|
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
foreach ( $files as $file ) {
|
|
|
|
$pattern = get_file_data( $file, $default_headers );
|
|
|
|
|
|
|
|
if ( empty( $pattern['slug'] ) ) {
|
|
|
|
_doing_it_wrong(
|
|
|
|
__FUNCTION__,
|
|
|
|
sprintf(
|
2023-10-03 20:19:23 +02:00
|
|
|
/* translators: 1: file name. */
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
__( 'Could not register file "%s" as a block pattern ("Slug" field missing)' ),
|
|
|
|
$file
|
|
|
|
),
|
|
|
|
'6.0.0'
|
|
|
|
);
|
2022-04-12 11:26:16 +02:00
|
|
|
continue;
|
|
|
|
}
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
|
|
|
|
if ( ! preg_match( '/^[A-z0-9\/_-]+$/', $pattern['slug'] ) ) {
|
|
|
|
_doing_it_wrong(
|
|
|
|
__FUNCTION__,
|
|
|
|
sprintf(
|
2023-10-03 20:19:23 +02:00
|
|
|
/* translators: 1: file name; 2: slug value found. */
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
__( 'Could not register file "%1$s" as a block pattern (invalid slug "%2$s")' ),
|
|
|
|
$file,
|
|
|
|
$pattern['slug']
|
|
|
|
),
|
|
|
|
'6.0.0'
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Title is a required property.
|
|
|
|
if ( ! $pattern['title'] ) {
|
|
|
|
_doing_it_wrong(
|
|
|
|
__FUNCTION__,
|
|
|
|
sprintf(
|
2023-10-03 20:19:23 +02:00
|
|
|
/* translators: 1: file name. */
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
__( 'Could not register file "%s" as a block pattern ("Title" field missing)' ),
|
|
|
|
$file
|
|
|
|
),
|
|
|
|
'6.0.0'
|
|
|
|
);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// For properties of type array, parse data as comma-separated.
|
|
|
|
foreach ( $properties_to_parse as $property ) {
|
|
|
|
if ( ! empty( $pattern[ $property ] ) ) {
|
|
|
|
$pattern[ $property ] = array_filter( wp_parse_list( (string) $pattern[ $property ] ) );
|
|
|
|
} else {
|
|
|
|
unset( $pattern[ $property ] );
|
2022-04-12 11:26:16 +02:00
|
|
|
}
|
|
|
|
}
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
|
|
|
|
// Parse properties of type int.
|
|
|
|
$property = 'viewportWidth';
|
|
|
|
if ( ! empty( $pattern[ $property ] ) ) {
|
|
|
|
$pattern[ $property ] = (int) $pattern[ $property ];
|
|
|
|
} else {
|
|
|
|
unset( $pattern[ $property ] );
|
|
|
|
}
|
|
|
|
|
|
|
|
// Parse properties of type bool.
|
|
|
|
$property = 'inserter';
|
|
|
|
if ( ! empty( $pattern[ $property ] ) ) {
|
|
|
|
$pattern[ $property ] = in_array(
|
|
|
|
strtolower( $pattern[ $property ] ),
|
|
|
|
array( 'yes', 'true' ),
|
|
|
|
true
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
unset( $pattern[ $property ] );
|
|
|
|
}
|
|
|
|
|
|
|
|
$key = str_replace( $dirpath, '', $file );
|
|
|
|
|
2023-10-03 20:19:23 +02:00
|
|
|
$pattern_data[ $key ] = $pattern;
|
2022-04-12 11:26:16 +02:00
|
|
|
}
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
|
|
|
|
if ( $can_use_cached ) {
|
2023-10-03 20:19:23 +02:00
|
|
|
$theme->set_pattern_cache( $pattern_data );
|
Editor: Improve performance of _register_theme_block_patterns function.
The `_register_theme_block_patterns` function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:
- is_dir
- is_readable
- file_exists
- glob
- file_get_contents (utilized via get_file_data)
To address these issues, caching using a transient has been added to a new function call `_wp_get_block_patterns`. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.
Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490
Built from https://develop.svn.wordpress.org/trunk@56765
git-svn-id: http://core.svn.wordpress.org/trunk@56277 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2023-10-03 17:18:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return $pattern_data;
|
2022-04-12 11:26:16 +02:00
|
|
|
}
|