1<?php
2/**
3 * WP_Theme_JSON_Resolver class
4 *
5 * @package WordPress
6 * @subpackage Theme
7 * @since 5.8.0
8 */
9
10/**
11 * Class that abstracts the processing of the different data sources
12 * for site-level config and offers an API to work with them.
13 *
14 * This class is for internal core usage and is not supposed to be used by extenders (plugins and/or themes).
15 * This is a low-level API that may need to do breaking changes. Please,
16 * use get_global_settings(), get_global_styles(), and get_global_stylesheet() instead.
17 *
18 * @access private
19 */
20#[AllowDynamicProperties]
21class WP_Theme_JSON_Resolver {
22
23 /**
24 * Container for keep track of registered blocks.
25 *
26 * @since 6.1.0
27 * @var array
28 */
29 protected static $blocks_cache = array(
30 'core' => array(),
31 'blocks' => array(),
32 'theme' => array(),
33 'user' => array(),
34 );
35
36 /**
37 * Container for data coming from core.
38 *
39 * @since 5.8.0
40 * @var WP_Theme_JSON
41 */
42 protected static $core = null;
43
44 /**
45 * Container for data coming from the blocks.
46 *
47 * @since 6.1.0
48 * @var WP_Theme_JSON
49 */
50 protected static $blocks = null;
51
52 /**
53 * Container for data coming from the theme.
54 *
55 * @since 5.8.0
56 * @var WP_Theme_JSON
57 */
58 protected static $theme = null;
59
60 /**
61 * Container for data coming from the user.
62 *
63 * @since 5.9.0
64 * @var WP_Theme_JSON
65 */
66 protected static $user = null;
67
68 /**
69 * Stores the ID of the custom post type
70 * that holds the user data.
71 *
72 * @since 5.9.0
73 * @var int
74 */
75 protected static $user_custom_post_type_id = null;
76
77 /**
78 * Container to keep loaded i18n schema for `theme.json`.
79 *
80 * @since 5.8.0 As `$theme_json_i18n`.
81 * @since 5.9.0 Renamed from `$theme_json_i18n` to `$i18n_schema`.
82 * @var array
83 */
84 protected static $i18n_schema = null;
85
86 /**
87 * `theme.json` file cache.
88 *
89 * @since 6.1.0
90 * @var array
91 */
92 protected static $theme_json_file_cache = array();
93
94 /**
95 * Processes a file that adheres to the theme.json schema
96 * and returns an array with its contents, or a void array if none found.
97 *
98 * @since 5.8.0
99 * @since 6.1.0 Added caching.
100 *
101 * @param string $file_path Path to file. Empty if no file.
102 * @return array Contents that adhere to the theme.json schema.
103 */
104 protected static function read_json_file( $file_path ) {
105 if ( $file_path ) {
106 if ( array_key_exists( $file_path, static::$theme_json_file_cache ) ) {
107 return static::$theme_json_file_cache[ $file_path ];
108 }
109
110 $decoded_file = wp_json_file_decode( $file_path, array( 'associative' => true ) );
111 if ( is_array( $decoded_file ) ) {
112 static::$theme_json_file_cache[ $file_path ] = $decoded_file;
113 return static::$theme_json_file_cache[ $file_path ];
114 }
115 }
116
117 return array();
118 }
119
120 /**
121 * Returns a data structure used in theme.json translation.
122 *
123 * @since 5.8.0
124 * @deprecated 5.9.0
125 *
126 * @return array An array of theme.json fields that are translatable and the keys that are translatable.
127 */
128 public static function get_fields_to_translate() {
129 _deprecated_function( __METHOD__, '5.9.0' );
130 return array();
131 }
132
133 /**
134 * Given a theme.json structure modifies it in place to update certain values
135 * by its translated strings according to the language set by the user.
136 *
137 * @since 5.8.0
138 *
139 * @param array $theme_json The theme.json to translate.
140 * @param string $domain Optional. Text domain. Unique identifier for retrieving translated strings.
141 * Default 'default'.
142 * @return array Returns the modified $theme_json_structure.
143 */
144 protected static function translate( $theme_json, $domain = 'default' ) {
145 if ( null === static::$i18n_schema ) {
146 $i18n_schema = wp_json_file_decode( __DIR__ . '/theme-i18n.json' );
147 static::$i18n_schema = null === $i18n_schema ? array() : $i18n_schema;
148 }
149
150 return translate_settings_using_i18n_schema( static::$i18n_schema, $theme_json, $domain );
151 }
152
153 /**
154 * Returns core's origin config.
155 *
156 * @since 5.8.0
157 *
158 * @return WP_Theme_JSON Entity that holds core data.
159 */
160 public static function get_core_data() {
161 if ( null !== static::$core && static::has_same_registered_blocks( 'core' ) ) {
162 return static::$core;
163 }
164
165 $config = static::read_json_file( __DIR__ . '/theme.json' );
166 $config = static::translate( $config );
167
168 /**
169 * Filters the default data provided by WordPress for global styles & settings.
170 *
171 * @since 6.1.0
172 *
173 * @param WP_Theme_JSON_Data $theme_json Class to access and update the underlying data.
174 */
175 $theme_json = apply_filters( 'wp_theme_json_data_default', new WP_Theme_JSON_Data( $config, 'default' ) );
176
177 /*
178 * Backward compatibility for extenders returning a WP_Theme_JSON_Data
179 * compatible class that is not a WP_Theme_JSON_Data object.
180 */
181 if ( $theme_json instanceof WP_Theme_JSON_Data ) {
182 static::$core = $theme_json->get_theme_json();
183 } else {
184 $config = $theme_json->get_data();
185 static::$core = new WP_Theme_JSON( $config, 'default' );
186 }
187
188 return static::$core;
189 }
190
191 /**
192 * Checks whether the registered blocks were already processed for this origin.
193 *
194 * @since 6.1.0
195 *
196 * @param string $origin Data source for which to cache the blocks.
197 * Valid values are 'core', 'blocks', 'theme', and 'user'.
198 * @return bool True on success, false otherwise.
199 */
200 protected static function has_same_registered_blocks( $origin ) {
201 // Bail out if the origin is invalid.
202 if ( ! isset( static::$blocks_cache[ $origin ] ) ) {
203 return false;
204 }
205
206 $registry = WP_Block_Type_Registry::get_instance();
207 $blocks = $registry->get_all_registered();
208
209 // Is there metadata for all currently registered blocks?
210 $block_diff = array_diff_key( $blocks, static::$blocks_cache[ $origin ] );
211 if ( empty( $block_diff ) ) {
212 return true;
213 }
214
215 foreach ( $blocks as $block_name => $block_type ) {
216 static::$blocks_cache[ $origin ][ $block_name ] = true;
217 }
218
219 return false;
220 }
221
222 /**
223 * Returns the theme's data.
224 *
225 * Data from theme.json will be backfilled from existing
226 * theme supports, if any. Note that if the same data
227 * is present in theme.json and in theme supports,
228 * the theme.json takes precedence.
229 *
230 * @since 5.8.0
231 * @since 5.9.0 Theme supports have been inlined and the `$theme_support_data` argument removed.
232 * @since 6.0.0 Added an `$options` parameter to allow the theme data to be returned without theme supports.
233 * @since 6.6.0 Add support for 'default-font-sizes' and 'default-spacing-sizes' theme supports.
234 * Added registration and merging of block style variations from partial theme.json files and the block styles registry.
235 *
236 * @param array $deprecated Deprecated. Not used.
237 * @param array $options {
238 * Options arguments.
239 *
240 * @type bool $with_supports Whether to include theme supports in the data. Default true.
241 * }
242 * @return WP_Theme_JSON Entity that holds theme data.
243 */
244 public static function get_theme_data( $deprecated = array(), $options = array() ) {
245 if ( ! empty( $deprecated ) ) {
246 _deprecated_argument( __METHOD__, '5.9.0' );
247 }
248
249 $options = wp_parse_args( $options, array( 'with_supports' => true ) );
250
251 if ( null === static::$theme || ! static::has_same_registered_blocks( 'theme' ) ) {
252 $wp_theme = wp_get_theme();
253 $theme_json_file = $wp_theme->get_file_path( 'theme.json' );
254 if ( is_readable( $theme_json_file ) ) {
255 $theme_json_data = static::read_json_file( $theme_json_file );
256 $theme_json_data = static::translate( $theme_json_data, $wp_theme->get( 'TextDomain' ) );
257 } else {
258 $theme_json_data = array( 'version' => WP_Theme_JSON::LATEST_SCHEMA );
259 }
260
261 /*
262 * Register variations defined by theme partials (theme.json files in the styles directory).
263 * This is required so the variations pass sanitization of theme.json data.
264 */
265 $variations = static::get_style_variations( 'block' );
266 wp_register_block_style_variations_from_theme_json_partials( $variations );
267
268 /*
269 * Source variations from the block registry and block style variation files. Then, merge them into the existing theme.json data.
270 *
271 * In case the same style properties are defined in several sources, this is how we should resolve the values,
272 * from higher to lower priority:
273 *
274 * - styles.blocks.blockType.variations from theme.json
275 * - styles.variations from theme.json
276 * - variations from block style variation files
277 * - variations from block styles registry
278 *
279 * See test_add_registered_block_styles_to_theme_data and test_unwraps_block_style_variations.
280 *
281 */
282 $theme_json_data = static::inject_variations_from_block_style_variation_files( $theme_json_data, $variations );
283 $theme_json_data = static::inject_variations_from_block_styles_registry( $theme_json_data );
284
285 /**
286 * Filters the data provided by the theme for global styles and settings.
287 *
288 * @since 6.1.0
289 *
290 * @param WP_Theme_JSON_Data $theme_json Class to access and update the underlying data.
291 */
292 $theme_json = apply_filters( 'wp_theme_json_data_theme', new WP_Theme_JSON_Data( $theme_json_data, 'theme' ) );
293
294 /*
295 * Backward compatibility for extenders returning a WP_Theme_JSON_Data
296 * compatible class that is not a WP_Theme_JSON_Data object.
297 */
298 if ( $theme_json instanceof WP_Theme_JSON_Data ) {
299 static::$theme = $theme_json->get_theme_json();
300 } else {
301 $config = $theme_json->get_data();
302 static::$theme = new WP_Theme_JSON( $config );
303 }
304
305 if ( $wp_theme->parent() ) {
306 // Get parent theme.json.
307 $parent_theme_json_file = $wp_theme->parent()->get_file_path( 'theme.json' );
308 if ( $theme_json_file !== $parent_theme_json_file && is_readable( $parent_theme_json_file ) ) {
309 $parent_theme_json_data = static::read_json_file( $parent_theme_json_file );
310 $parent_theme_json_data = static::translate( $parent_theme_json_data, $wp_theme->parent()->get( 'TextDomain' ) );
311 $parent_theme = new WP_Theme_JSON( $parent_theme_json_data );
312
313 /*
314 * Merge the child theme.json into the parent theme.json.
315 * The child theme takes precedence over the parent.
316 */
317 $parent_theme->merge( static::$theme );
318 static::$theme = $parent_theme;
319 }
320 }
321 }
322
323 if ( ! $options['with_supports'] ) {
324 return static::$theme;
325 }
326
327 /*
328 * We want the presets and settings declared in theme.json
329 * to override the ones declared via theme supports.
330 * So we take theme supports, transform it to theme.json shape
331 * and merge the static::$theme upon that.
332 */
333 $theme_support_data = WP_Theme_JSON::get_from_editor_settings( get_classic_theme_supports_block_editor_settings() );
334 if ( ! wp_theme_has_theme_json() ) {
335 /*
336 * Unlike block themes, classic themes without a theme.json disable
337 * default presets when custom preset theme support is added. This
338 * behavior can be overridden by using the corresponding default
339 * preset theme support.
340 */
341 $theme_support_data['settings']['color']['defaultPalette'] =
342 ! isset( $theme_support_data['settings']['color']['palette'] ) ||
343 current_theme_supports( 'default-color-palette' );
344 $theme_support_data['settings']['color']['defaultGradients'] =
345 ! isset( $theme_support_data['settings']['color']['gradients'] ) ||
346 current_theme_supports( 'default-gradient-presets' );
347 $theme_support_data['settings']['typography']['defaultFontSizes'] =
348 ! isset( $theme_support_data['settings']['typography']['fontSizes'] ) ||
349 current_theme_supports( 'default-font-sizes' );
350 $theme_support_data['settings']['spacing']['defaultSpacingSizes'] =
351 ! isset( $theme_support_data['settings']['spacing']['spacingSizes'] ) ||
352 current_theme_supports( 'default-spacing-sizes' );
353
354 /*
355 * Shadow presets are explicitly disabled for classic themes until a
356 * decision is made for whether the default presets should match the
357 * other presets or if they should be disabled by default in classic
358 * themes. See https://github.com/WordPress/gutenberg/issues/59989.
359 */
360 $theme_support_data['settings']['shadow']['defaultPresets'] = false;
361
362 // Allow themes to enable link color setting via theme_support.
363 if ( current_theme_supports( 'link-color' ) ) {
364 $theme_support_data['settings']['color']['link'] = true;
365 }
366
367 // Allow themes to enable all border settings via theme_support.
368 if ( current_theme_supports( 'border' ) ) {
369 $theme_support_data['settings']['border']['color'] = true;
370 $theme_support_data['settings']['border']['radius'] = true;
371 $theme_support_data['settings']['border']['style'] = true;
372 $theme_support_data['settings']['border']['width'] = true;
373 }
374
375 // Allow themes to enable appearance tools via theme_support.
376 if ( current_theme_supports( 'appearance-tools' ) ) {
377 $theme_support_data['settings']['appearanceTools'] = true;
378 }
379 }
380 $with_theme_supports = new WP_Theme_JSON( $theme_support_data );
381 $with_theme_supports->merge( static::$theme );
382 return $with_theme_supports;
383 }
384
385 /**
386 * Gets the styles for blocks from the block.json file.
387 *
388 * @since 6.1.0
389 *
390 * @return WP_Theme_JSON
391 */
392 public static function get_block_data() {
393 $registry = WP_Block_Type_Registry::get_instance();
394 $blocks = $registry->get_all_registered();
395
396 if ( null !== static::$blocks && static::has_same_registered_blocks( 'blocks' ) ) {
397 return static::$blocks;
398 }
399
400 $config = array( 'version' => WP_Theme_JSON::LATEST_SCHEMA );
401 foreach ( $blocks as $block_name => $block_type ) {
402 if ( isset( $block_type->supports['__experimentalStyle'] ) ) {
403 $config['styles']['blocks'][ $block_name ] = static::remove_json_comments( $block_type->supports['__experimentalStyle'] );
404 }
405
406 if (
407 isset( $block_type->supports['spacing']['blockGap']['__experimentalDefault'] ) &&
408 ! isset( $config['styles']['blocks'][ $block_name ]['spacing']['blockGap'] )
409 ) {
410 /*
411 * Ensure an empty placeholder value exists for the block, if it provides a default blockGap value.
412 * The real blockGap value to be used will be determined when the styles are rendered for output.
413 */
414 $config['styles']['blocks'][ $block_name ]['spacing']['blockGap'] = null;
415 }
416 }
417
418 /**
419 * Filters the data provided by the blocks for global styles & settings.
420 *
421 * @since 6.1.0
422 *
423 * @param WP_Theme_JSON_Data $theme_json Class to access and update the underlying data.
424 */
425 $theme_json = apply_filters( 'wp_theme_json_data_blocks', new WP_Theme_JSON_Data( $config, 'blocks' ) );
426
427 /*
428 * Backward compatibility for extenders returning a WP_Theme_JSON_Data
429 * compatible class that is not a WP_Theme_JSON_Data object.
430 */
431 if ( $theme_json instanceof WP_Theme_JSON_Data ) {
432 static::$blocks = $theme_json->get_theme_json();
433 } else {
434 $config = $theme_json->get_data();
435 static::$blocks = new WP_Theme_JSON( $config, 'blocks' );
436 }
437
438 return static::$blocks;
439 }
440
441 /**
442 * When given an array, this will remove any keys with the name `//`.
443 *
444 * @since 6.1.0
445 *
446 * @param array $input_array The array to filter.
447 * @return array The filtered array.
448 */
449 private static function remove_json_comments( $input_array ) {
450 unset( $input_array['//'] );
451 foreach ( $input_array as $k => $v ) {
452 if ( is_array( $v ) ) {
453 $input_array[ $k ] = static::remove_json_comments( $v );
454 }
455 }
456
457 return $input_array;
458 }
459
460 /**
461 * Returns the custom post type that contains the user's origin config
462 * for the active theme or an empty array if none are found.
463 *
464 * This can also create and return a new draft custom post type.
465 *
466 * @since 5.9.0
467 *
468 * @param WP_Theme $theme The theme object. If empty, it
469 * defaults to the active theme.
470 * @param bool $create_post Optional. Whether a new custom post
471 * type should be created if none are
472 * found. Default false.
473 * @param array $post_status_filter Optional. Filter custom post type by
474 * post status. Default `array( 'publish' )`,
475 * so it only fetches published posts.
476 * @return array Custom Post Type for the user's origin config.
477 */
478 public static function get_user_data_from_wp_global_styles( $theme, $create_post = false, $post_status_filter = array( 'publish' ) ) {
479 if ( ! $theme instanceof WP_Theme ) {
480 $theme = wp_get_theme();
481 }
482
483 /*
484 * Bail early if the theme does not support a theme.json.
485 *
486 * Since wp_theme_has_theme_json() only supports the active
487 * theme, the extra condition for whether $theme is the active theme is
488 * present here.
489 */
490 if ( $theme->get_stylesheet() === get_stylesheet() && ! wp_theme_has_theme_json() ) {
491 return array();
492 }
493
494 $user_cpt = array();
495 $post_type_filter = 'wp_global_styles';
496 $stylesheet = $theme->get_stylesheet();
497 $args = array(
498 'posts_per_page' => 1,
499 'orderby' => 'date',
500 'order' => 'desc',
501 'post_type' => $post_type_filter,
502 'post_status' => $post_status_filter,
503 'ignore_sticky_posts' => true,
504 'no_found_rows' => true,
505 'update_post_meta_cache' => false,
506 'update_post_term_cache' => false,
507 'tax_query' => array(
508 array(
509 'taxonomy' => 'wp_theme',
510 'field' => 'name',
511 'terms' => $stylesheet,
512 ),
513 ),
514 );
515
516 $global_style_query = new WP_Query();
517 $recent_posts = $global_style_query->query( $args );
518 if ( count( $recent_posts ) === 1 ) {
519 $user_cpt = get_object_vars( $recent_posts[0] );
520 } elseif ( $create_post ) {
521 $cpt_post_id = wp_insert_post(
522 array(
523 'post_content' => '{"version": ' . WP_Theme_JSON::LATEST_SCHEMA . ', "isGlobalStylesUserThemeJSON": true }',
524 'post_status' => 'publish',
525 'post_title' => 'Custom Styles', // Do not make string translatable, see https://core.trac.wordpress.org/ticket/54518.
526 'post_type' => $post_type_filter,
527 'post_name' => sprintf( 'wp-global-styles-%s', urlencode( $stylesheet ) ),
528 'tax_input' => array(
529 'wp_theme' => array( $stylesheet ),
530 ),
531 ),
532 true
533 );
534 if ( ! is_wp_error( $cpt_post_id ) ) {
535 $user_cpt = get_object_vars( get_post( $cpt_post_id ) );
536 }
537 }
538
539 return $user_cpt;
540 }
541
542 /**
543 * Returns the user's origin config.
544 *
545 * @since 5.9.0
546 * @since 6.6.0 The 'isGlobalStylesUserThemeJSON' flag is left on the user data.
547 * Register the block style variations coming from the user data.
548 *
549 * @return WP_Theme_JSON Entity that holds styles for user data.
550 */
551 public static function get_user_data() {
552 if ( null !== static::$user && static::has_same_registered_blocks( 'user' ) ) {
553 return static::$user;
554 }
555
556 $config = array();
557 $user_cpt = static::get_user_data_from_wp_global_styles( wp_get_theme() );
558
559 if ( array_key_exists( 'post_content', $user_cpt ) ) {
560 $decoded_data = json_decode( $user_cpt['post_content'], true );
561
562 $json_decoding_error = json_last_error();
563 if ( JSON_ERROR_NONE !== $json_decoding_error ) {
564 wp_trigger_error( __METHOD__, 'Error when decoding a theme.json schema for user data. ' . json_last_error_msg() );
565 /**
566 * Filters the data provided by the user for global styles & settings.
567 *
568 * @since 6.1.0
569 *
570 * @param WP_Theme_JSON_Data $theme_json Class to access and update the underlying data.
571 */
572 $theme_json = apply_filters( 'wp_theme_json_data_user', new WP_Theme_JSON_Data( $config, 'custom' ) );
573
574 /*
575 * Backward compatibility for extenders returning a WP_Theme_JSON_Data
576 * compatible class that is not a WP_Theme_JSON_Data object.
577 */
578 if ( $theme_json instanceof WP_Theme_JSON_Data ) {
579 return $theme_json->get_theme_json();
580 } else {
581 $config = $theme_json->get_data();
582 return new WP_Theme_JSON( $config, 'custom' );
583 }
584 }
585
586 /*
587 * Very important to verify that the flag isGlobalStylesUserThemeJSON is true.
588 * If it's not true then the content was not escaped and is not safe.
589 */
590 if (
591 is_array( $decoded_data ) &&
592 isset( $decoded_data['isGlobalStylesUserThemeJSON'] ) &&
593 $decoded_data['isGlobalStylesUserThemeJSON']
594 ) {
595 unset( $decoded_data['isGlobalStylesUserThemeJSON'] );
596 $config = $decoded_data;
597 }
598 }
599
600 /** This filter is documented in wp-includes/class-wp-theme-json-resolver.php */
601 $theme_json = apply_filters( 'wp_theme_json_data_user', new WP_Theme_JSON_Data( $config, 'custom' ) );
602
603 /*
604 * Backward compatibility for extenders returning a WP_Theme_JSON_Data
605 * compatible class that is not a WP_Theme_JSON_Data object.
606 */
607 if ( $theme_json instanceof WP_Theme_JSON_Data ) {
608 static::$user = $theme_json->get_theme_json();
609 } else {
610 $config = $theme_json->get_data();
611 static::$user = new WP_Theme_JSON( $config, 'custom' );
612 }
613
614 return static::$user;
615 }
616
617 /**
618 * Returns the data merged from multiple origins.
619 *
620 * There are four sources of data (origins) for a site:
621 *
622 * - default => WordPress
623 * - blocks => each one of the blocks provides data for itself
624 * - theme => the active theme
625 * - custom => data provided by the user
626 *
627 * The custom's has higher priority than the theme's, the theme's higher than blocks',
628 * and block's higher than default's.
629 *
630 * Unlike the getters
631 * {@link https://developer.wordpress.org/reference/classes/wp_theme_json_resolver/get_core_data/ get_core_data},
632 * {@link https://developer.wordpress.org/reference/classes/wp_theme_json_resolver/get_theme_data/ get_theme_data},
633 * and {@link https://developer.wordpress.org/reference/classes/wp_theme_json_resolver/get_user_data/ get_user_data},
634 * this method returns data after it has been merged with the previous origins.
635 * This means that if the same piece of data is declared in different origins
636 * (default, blocks, theme, custom), the last origin overrides the previous.
637 *
638 * For example, if the user has set a background color
639 * for the paragraph block, and the theme has done it as well,
640 * the user preference wins.
641 *
642 * @since 5.8.0
643 * @since 5.9.0 Added user data, removed the `$settings` parameter,
644 * added the `$origin` parameter.
645 * @since 6.1.0 Added block data and generation of spacingSizes array.
646 * @since 6.2.0 Changed ' $origin' parameter values to 'default', 'blocks', 'theme' or 'custom'.
647 *
648 * @param string $origin Optional. To what level should we merge data: 'default', 'blocks', 'theme' or 'custom'.
649 * 'custom' is used as default value as well as fallback value if the origin is unknown.
650 * @return WP_Theme_JSON
651 */
652 public static function get_merged_data( $origin = 'custom' ) {
653 if ( is_array( $origin ) ) {
654 _deprecated_argument( __FUNCTION__, '5.9.0' );
655 }
656
657 $result = new WP_Theme_JSON();
658 $result->merge( static::get_core_data() );
659 if ( 'default' === $origin ) {
660 return $result;
661 }
662
663 $result->merge( static::get_block_data() );
664 if ( 'blocks' === $origin ) {
665 return $result;
666 }
667
668 $result->merge( static::get_theme_data() );
669 if ( 'theme' === $origin ) {
670 return $result;
671 }
672
673 $result->merge( static::get_user_data() );
674
675 return $result;
676 }
677
678 /**
679 * Returns the ID of the custom post type
680 * that stores user data.
681 *
682 * @since 5.9.0
683 *
684 * @return integer|null
685 */
686 public static function get_user_global_styles_post_id() {
687 if ( null !== static::$user_custom_post_type_id ) {
688 return static::$user_custom_post_type_id;
689 }
690
691 $user_cpt = static::get_user_data_from_wp_global_styles( wp_get_theme(), true );
692
693 if ( array_key_exists( 'ID', $user_cpt ) ) {
694 static::$user_custom_post_type_id = $user_cpt['ID'];
695 }
696
697 return static::$user_custom_post_type_id;
698 }
699
700 /**
701 * Determines whether the active theme has a theme.json file.
702 *
703 * @since 5.8.0
704 * @since 5.9.0 Added a check in the parent theme.
705 * @deprecated 6.2.0 Use wp_theme_has_theme_json() instead.
706 *
707 * @return bool
708 */
709 public static function theme_has_support() {
710 _deprecated_function( __METHOD__, '6.2.0', 'wp_theme_has_theme_json()' );
711
712 return wp_theme_has_theme_json();
713 }
714
715 /**
716 * Builds the path to the given file and checks that it is readable.
717 *
718 * If it isn't, returns an empty string, otherwise returns the whole file path.
719 *
720 * @since 5.8.0
721 * @since 5.9.0 Adapted to work with child themes, added the `$template` argument.
722 *
723 * @param string $file_name Name of the file.
724 * @param bool $template Optional. Use template theme directory. Default false.
725 * @return string The whole file path or empty if the file doesn't exist.
726 */
727 protected static function get_file_path_from_theme( $file_name, $template = false ) {
728 $path = $template ? get_template_directory() : get_stylesheet_directory();
729 $candidate = $path . '/' . $file_name;
730
731 return is_readable( $candidate ) ? $candidate : '';
732 }
733
734 /**
735 * Cleans the cached data so it can be recalculated.
736 *
737 * @since 5.8.0
738 * @since 5.9.0 Added the `$user`, `$user_custom_post_type_id`,
739 * and `$i18n_schema` variables to reset.
740 * @since 6.1.0 Added the `$blocks` and `$blocks_cache` variables
741 * to reset.
742 */
743 public static function clean_cached_data() {
744 static::$core = null;
745 static::$blocks = null;
746 static::$blocks_cache = array(
747 'core' => array(),
748 'blocks' => array(),
749 'theme' => array(),
750 'user' => array(),
751 );
752 static::$theme = null;
753 static::$user = null;
754 static::$user_custom_post_type_id = null;
755 static::$i18n_schema = null;
756 }
757
758 /**
759 * Returns an array of all nested JSON files within a given directory.
760 *
761 * @since 6.2.0
762 *
763 * @param string $dir The directory to recursively iterate and list files of.
764 * @return array The merged array.
765 */
766 private static function recursively_iterate_json( $dir ) {
767 $nested_files = new RecursiveIteratorIterator( new RecursiveDirectoryIterator( $dir ) );
768 $nested_json_files = iterator_to_array( new RegexIterator( $nested_files, '/^.+\.json$/i', RecursiveRegexIterator::GET_MATCH ) );
769 return $nested_json_files;
770 }
771
772 /**
773 * Determines if a supplied style variation matches the provided scope.
774 *
775 * For backwards compatibility, if a variation does not define any scope
776 * related property, e.g. `blockTypes`, it is assumed to be a theme style
777 * variation.
778 *
779 * @since 6.6.0
780 *
781 * @param array $variation Theme.json shaped style variation object.
782 * @param string $scope Scope to check e.g. theme, block etc.
783 * @return boolean
784 */
785 private static function style_variation_has_scope( $variation, $scope ) {
786 if ( 'block' === $scope ) {
787 return isset( $variation['blockTypes'] );
788 }
789
790 if ( 'theme' === $scope ) {
791 return ! isset( $variation['blockTypes'] );
792 }
793
794 return false;
795 }
796
797 /**
798 * Returns the style variations defined by the theme.
799 *
800 * @since 6.0.0
801 * @since 6.2.0 Returns parent theme variations if theme is a child.
802 * @since 6.6.0 Added configurable scope parameter to allow filtering
803 * theme.json partial files by the scope to which they
804 * can be applied e.g. theme vs block etc.
805 * Added basic caching for read theme.json partial files.
806 *
807 * @param string $scope The scope or type of style variation to retrieve e.g. theme, block etc.
808 * @return array
809 */
810 public static function get_style_variations( $scope = 'theme' ) {
811 $variation_files = array();
812 $variations = array();
813 $base_directory = get_stylesheet_directory() . '/styles';
814 $template_directory = get_template_directory() . '/styles';
815 if ( is_dir( $base_directory ) ) {
816 $variation_files = static::recursively_iterate_json( $base_directory );
817 }
818 if ( is_dir( $template_directory ) && $template_directory !== $base_directory ) {
819 $variation_files_parent = static::recursively_iterate_json( $template_directory );
820 // If the child and parent variation file basename are the same, only include the child theme's.
821 foreach ( $variation_files_parent as $parent_path => $parent ) {
822 foreach ( $variation_files as $child_path => $child ) {
823 if ( basename( $parent_path ) === basename( $child_path ) ) {
824 unset( $variation_files_parent[ $parent_path ] );
825 }
826 }
827 }
828 $variation_files = array_merge( $variation_files, $variation_files_parent );
829 }
830 ksort( $variation_files );
831 foreach ( $variation_files as $path => $file ) {
832 $decoded_file = self::read_json_file( $path );
833 if ( is_array( $decoded_file ) && static::style_variation_has_scope( $decoded_file, $scope ) ) {
834 $translated = static::translate( $decoded_file, wp_get_theme()->get( 'TextDomain' ) );
835 $variation = ( new WP_Theme_JSON( $translated ) )->get_raw_data();
836 if ( empty( $variation['title'] ) ) {
837 $variation['title'] = basename( $path, '.json' );
838 }
839 $variations[] = $variation;
840 }
841 }
842 return $variations;
843 }
844
845 /**
846 * Resolves relative paths in theme.json styles to theme absolute paths
847 * and returns them in an array that can be embedded
848 * as the value of `_link` object in REST API responses.
849 *
850 * @since 6.6.0
851 * @since 6.7.0 Resolve relative paths in block styles.
852 *
853 * @param WP_Theme_JSON $theme_json A theme json instance.
854 * @return array An array of resolved paths.
855 */
856 public static function get_resolved_theme_uris( $theme_json ) {
857 $resolved_theme_uris = array();
858
859 if ( ! $theme_json instanceof WP_Theme_JSON ) {
860 return $resolved_theme_uris;
861 }
862
863 $theme_json_data = $theme_json->get_raw_data();
864 /*
865 * The same file convention when registering web fonts.
866 * See: WP_Font_Face_Resolver::to_theme_file_uri.
867 */
868 $placeholder = 'file:./';
869
870 // Top level styles.
871 $background_image_url = $theme_json_data['styles']['background']['backgroundImage']['url'] ?? null;
872 if (
873 isset( $background_image_url ) &&
874 is_string( $background_image_url ) &&
875 // Skip if the src doesn't start with the placeholder, as there's nothing to replace.
876 str_starts_with( $background_image_url, $placeholder )
877 ) {
878 $file_type = wp_check_filetype( $background_image_url );
879 $src_url = str_replace( $placeholder, '', $background_image_url );
880 $resolved_theme_uri = array(
881 'name' => $background_image_url,
882 'href' => sanitize_url( get_theme_file_uri( $src_url ) ),
883 'target' => 'styles.background.backgroundImage.url',
884 );
885 if ( isset( $file_type['type'] ) ) {
886 $resolved_theme_uri['type'] = $file_type['type'];
887 }
888 $resolved_theme_uris[] = $resolved_theme_uri;
889 }
890
891 // Block styles.
892 if ( ! empty( $theme_json_data['styles']['blocks'] ) ) {
893 foreach ( $theme_json_data['styles']['blocks'] as $block_name => $block_styles ) {
894 if ( ! isset( $block_styles['background']['backgroundImage']['url'] ) ) {
895 continue;
896 }
897 $background_image_url = $block_styles['background']['backgroundImage']['url'];
898 if (
899 is_string( $background_image_url ) &&
900 // Skip if the src doesn't start with the placeholder, as there's nothing to replace.
901 str_starts_with( $background_image_url, $placeholder )
902 ) {
903 $file_type = wp_check_filetype( $background_image_url );
904 $src_url = str_replace( $placeholder, '', $background_image_url );
905 $resolved_theme_uri = array(
906 'name' => $background_image_url,
907 'href' => sanitize_url( get_theme_file_uri( $src_url ) ),
908 'target' => "styles.blocks.{$block_name}.background.backgroundImage.url",
909 );
910 if ( isset( $file_type['type'] ) ) {
911 $resolved_theme_uri['type'] = $file_type['type'];
912 }
913 $resolved_theme_uris[] = $resolved_theme_uri;
914 }
915 }
916 }
917
918 return $resolved_theme_uris;
919 }
920
921 /**
922 * Resolves relative paths in theme.json styles to theme absolute paths
923 * and merges them with incoming theme JSON.
924 *
925 * @since 6.6.0
926 *
927 * @param WP_Theme_JSON $theme_json A theme json instance.
928 * @return WP_Theme_JSON Theme merged with resolved paths, if any found.
929 */
930 public static function resolve_theme_file_uris( $theme_json ) {
931 $resolved_urls = static::get_resolved_theme_uris( $theme_json );
932 if ( empty( $resolved_urls ) ) {
933 return $theme_json;
934 }
935
936 $resolved_theme_json_data = $theme_json->get_raw_data();
937
938 foreach ( $resolved_urls as $resolved_url ) {
939 $path = explode( '.', $resolved_url['target'] );
940 _wp_array_set( $resolved_theme_json_data, $path, $resolved_url['href'] );
941 }
942
943 return new WP_Theme_JSON( $resolved_theme_json_data );
944 }
945
946 /**
947 * Adds variations sourced from block style variations files to the supplied theme.json data.
948 *
949 * @since 6.6.0
950 *
951 * @param array $data Array following the theme.json specification.
952 * @param array $variations Shared block style variations.
953 * @return array Theme json data including shared block style variation definitions.
954 */
955 private static function inject_variations_from_block_style_variation_files( $data, $variations ) {
956 if ( empty( $variations ) ) {
957 return $data;
958 }
959
960 foreach ( $variations as $variation ) {
961 if ( empty( $variation['styles'] ) || empty( $variation['blockTypes'] ) ) {
962 continue;
963 }
964
965 $variation_name = $variation['slug'] ?? _wp_to_kebab_case( $variation['title'] );
966
967 foreach ( $variation['blockTypes'] as $block_type ) {
968 // First, override partial styles with any top-level styles.
969 $top_level_data = $data['styles']['variations'][ $variation_name ] ?? array();
970 if ( ! empty( $top_level_data ) ) {
971 $variation['styles'] = array_replace_recursive( $variation['styles'], $top_level_data );
972 }
973
974 // Then, override styles so far with any block-level styles.
975 $block_level_data = $data['styles']['blocks'][ $block_type ]['variations'][ $variation_name ] ?? array();
976 if ( ! empty( $block_level_data ) ) {
977 $variation['styles'] = array_replace_recursive( $variation['styles'], $block_level_data );
978 }
979
980 $path = array( 'styles', 'blocks', $block_type, 'variations', $variation_name );
981 _wp_array_set( $data, $path, $variation['styles'] );
982 }
983 }
984
985 return $data;
986 }
987
988 /**
989 * Adds variations sourced from the block styles registry to the supplied theme.json data.
990 *
991 * @since 6.6.0
992 *
993 * @param array $data Array following the theme.json specification.
994 * @return array Theme json data including shared block style variation definitions.
995 */
996 private static function inject_variations_from_block_styles_registry( $data ) {
997 $registry = WP_Block_Styles_Registry::get_instance();
998 $styles = $registry->get_all_registered();
999
1000 foreach ( $styles as $block_type => $variations ) {
1001 foreach ( $variations as $variation_name => $variation ) {
1002 if ( empty( $variation['style_data'] ) ) {
1003 continue;
1004 }
1005
1006 // First, override registry styles with any top-level styles.
1007 $top_level_data = $data['styles']['variations'][ $variation_name ] ?? array();
1008 if ( ! empty( $top_level_data ) ) {
1009 $variation['style_data'] = array_replace_recursive( $variation['style_data'], $top_level_data );
1010 }
1011
1012 // Then, override styles so far with any block-level styles.
1013 $block_level_data = $data['styles']['blocks'][ $block_type ]['variations'][ $variation_name ] ?? array();
1014 if ( ! empty( $block_level_data ) ) {
1015 $variation['style_data'] = array_replace_recursive( $variation['style_data'], $block_level_data );
1016 }
1017
1018 $path = array( 'styles', 'blocks', $block_type, 'variations', $variation_name );
1019 _wp_array_set( $data, $path, $variation['style_data'] );
1020 }
1021 }
1022
1023 return $data;
1024 }
1025}
1026