: str_replace(): Passing null to parameter #2 ($replace) of type array|string is deprecated in
* WP_Theme_JSON_Resolver class
* Class that abstracts the processing of the different data sources
* for site-level config and offers an API to work with them.
* This class is for internal core usage and is not supposed to be used by extenders (plugins and/or themes).
* This is a low-level API that may need to do breaking changes. Please,
* use get_global_settings(), get_global_styles(), and get_global_stylesheet() instead.
#[AllowDynamicProperties]
class WP_Theme_JSON_Resolver {
* Container for keep track of registered blocks.
protected static $blocks_cache = array(
* Container for data coming from core.
protected static $core = null;
* Container for data coming from the blocks.
protected static $blocks = null;
* Container for data coming from the theme.
protected static $theme = null;
* Container for data coming from the user.
protected static $user = null;
* Stores the ID of the custom post type
* that holds the user data.
protected static $user_custom_post_type_id = null;
* Container to keep loaded i18n schema for `theme.json`.
* @since 5.8.0 As `$theme_json_i18n`.
* @since 5.9.0 Renamed from `$theme_json_i18n` to `$i18n_schema`.
protected static $i18n_schema = null;
* `theme.json` file cache.
protected static $theme_json_file_cache = array();
* Processes a file that adheres to the theme.json schema
* and returns an array with its contents, or a void array if none found.
* @since 6.1.0 Added caching.
* @param string $file_path Path to file. Empty if no file.
* @return array Contents that adhere to the theme.json schema.
protected static function read_json_file( $file_path ) {
if ( array_key_exists( $file_path, static::$theme_json_file_cache ) ) {
return static::$theme_json_file_cache[ $file_path ];
$decoded_file = wp_json_file_decode( $file_path, array( 'associative' => true ) );
if ( is_array( $decoded_file ) ) {
static::$theme_json_file_cache[ $file_path ] = $decoded_file;
return static::$theme_json_file_cache[ $file_path ];
* Returns a data structure used in theme.json translation.
* @return array An array of theme.json fields that are translatable and the keys that are translatable.
public static function get_fields_to_translate() {
_deprecated_function( __METHOD__, '5.9.0' );
* Given a theme.json structure modifies it in place to update certain values
* by its translated strings according to the language set by the user.
* @param array $theme_json The theme.json to translate.
* @param string $domain Optional. Text domain. Unique identifier for retrieving translated strings.
* @return array Returns the modified $theme_json_structure.
protected static function translate( $theme_json, $domain = 'default' ) {
if ( null === static::$i18n_schema ) {
$i18n_schema = wp_json_file_decode( __DIR__ . '/theme-i18n.json' );
static::$i18n_schema = null === $i18n_schema ? array() : $i18n_schema;
return translate_settings_using_i18n_schema( static::$i18n_schema, $theme_json, $domain );
* Returns core's origin config.
* @return WP_Theme_JSON Entity that holds core data.
public static function get_core_data() {
if ( null !== static::$core && static::has_same_registered_blocks( 'core' ) ) {
$config = static::read_json_file( __DIR__ . '/theme.json' );
$config = static::translate( $config );
* Filters the default data provided by WordPress for global styles & settings.
* @param WP_Theme_JSON_Data $theme_json Class to access and update the underlying data.
$theme_json = apply_filters( 'wp_theme_json_data_default', new WP_Theme_JSON_Data( $config, 'default' ) );
* Backward compatibility for extenders returning a WP_Theme_JSON_Data
* compatible class that is not a WP_Theme_JSON_Data object.
if ( $theme_json instanceof WP_Theme_JSON_Data ) {
static::$core = $theme_json->get_theme_json();
$config = $theme_json->get_data();
static::$core = new WP_Theme_JSON( $config, 'default' );
* Checks whether the registered blocks were already processed for this origin.
* @param string $origin Data source for which to cache the blocks.
* Valid values are 'core', 'blocks', 'theme', and 'user'.
* @return bool True on success, false otherwise.
protected static function has_same_registered_blocks( $origin ) {
// Bail out if the origin is invalid.
if ( ! isset( static::$blocks_cache[ $origin ] ) ) {
$registry = WP_Block_Type_Registry::get_instance();
$blocks = $registry->get_all_registered();
// Is there metadata for all currently registered blocks?
$block_diff = array_diff_key( $blocks, static::$blocks_cache[ $origin ] );
if ( empty( $block_diff ) ) {
foreach ( $blocks as $block_name => $block_type ) {
static::$blocks_cache[ $origin ][ $block_name ] = true;
* Returns the theme's data.
* Data from theme.json will be backfilled from existing
* theme supports, if any. Note that if the same data
* is present in theme.json and in theme supports,
* the theme.json takes precedence.
* @since 5.9.0 Theme supports have been inlined and the `$theme_support_data` argument removed.
* @since 6.0.0 Added an `$options` parameter to allow the theme data to be returned without theme supports.
* @since 6.6.0 Add support for 'default-font-sizes' and 'default-spacing-sizes' theme supports.
* Added registration and merging of block style variations from partial theme.json files and the block styles registry.
* @param array $deprecated Deprecated. Not used.
* @param array $options {
* @type bool $with_supports Whether to include theme supports in the data. Default true.
* @return WP_Theme_JSON Entity that holds theme data.
public static function get_theme_data( $deprecated = array(), $options = array() ) {
if ( ! empty( $deprecated ) ) {
_deprecated_argument( __METHOD__, '5.9.0' );
$options = wp_parse_args( $options, array( 'with_supports' => true ) );
if ( null === static::$theme || ! static::has_same_registered_blocks( 'theme' ) ) {
$wp_theme = wp_get_theme();
$theme_json_file = $wp_theme->get_file_path( 'theme.json' );
if ( is_readable( $theme_json_file ) ) {
$theme_json_data = static::read_json_file( $theme_json_file );
$theme_json_data = static::translate( $theme_json_data, $wp_theme->get( 'TextDomain' ) );
$theme_json_data = array( 'version' => WP_Theme_JSON::LATEST_SCHEMA );
* Register variations defined by theme partials (theme.json files in the styles directory).
* This is required so the variations pass sanitization of theme.json data.
$variations = static::get_style_variations( 'block' );
wp_register_block_style_variations_from_theme_json_partials( $variations );
* Source variations from the block registry and block style variation files. Then, merge them into the existing theme.json data.
* In case the same style properties are defined in several sources, this is how we should resolve the values,
* from higher to lower priority:
* - styles.blocks.blockType.variations from theme.json
* - styles.variations from theme.json
* - variations from block style variation files
* - variations from block styles registry
* See test_add_registered_block_styles_to_theme_data and test_unwraps_block_style_variations.
$theme_json_data = static::inject_variations_from_block_style_variation_files( $theme_json_data, $variations );
$theme_json_data = static::inject_variations_from_block_styles_registry( $theme_json_data );
* Filters the data provided by the theme for global styles and settings.
* @param WP_Theme_JSON_Data $theme_json Class to access and update the underlying data.
$theme_json = apply_filters( 'wp_theme_json_data_theme', new WP_Theme_JSON_Data( $theme_json_data, 'theme' ) );
* Backward compatibility for extenders returning a WP_Theme_JSON_Data
* compatible class that is not a WP_Theme_JSON_Data object.
if ( $theme_json instanceof WP_Theme_JSON_Data ) {
static::$theme = $theme_json->get_theme_json();
$config = $theme_json->get_data();
static::$theme = new WP_Theme_JSON( $config );
if ( $wp_theme->parent() ) {
// Get parent theme.json.
$parent_theme_json_file = $wp_theme->parent()->get_file_path( 'theme.json' );
if ( $theme_json_file !== $parent_theme_json_file && is_readable( $parent_theme_json_file ) ) {
$parent_theme_json_data = static::read_json_file( $parent_theme_json_file );
$parent_theme_json_data = static::translate( $parent_theme_json_data, $wp_theme->parent()->get( 'TextDomain' ) );
$parent_theme = new WP_Theme_JSON( $parent_theme_json_data );
* Merge the child theme.json into the parent theme.json.
* The child theme takes precedence over the parent.
$parent_theme->merge( static::$theme );
static::$theme = $parent_theme;
if ( ! $options['with_supports'] ) {
* We want the presets and settings declared in theme.json
* to override the ones declared via theme supports.
* So we take theme supports, transform it to theme.json shape
* and merge the static::$theme upon that.
$theme_support_data = WP_Theme_JSON::get_from_editor_settings( get_classic_theme_supports_block_editor_settings() );
if ( ! wp_theme_has_theme_json() ) {
* Unlike block themes, classic themes without a theme.json disable
* default presets when custom preset theme support is added. This
* behavior can be overridden by using the corresponding default
$theme_support_data['settings']['color']['defaultPalette'] =
! isset( $theme_support_data['settings']['color']['palette'] ) ||
current_theme_supports( 'default-color-palette' );
$theme_support_data['settings']['color']['defaultGradients'] =
! isset( $theme_support_data['settings']['color']['gradients'] ) ||
current_theme_supports( 'default-gradient-presets' );
$theme_support_data['settings']['typography']['defaultFontSizes'] =
! isset( $theme_support_data['settings']['typography']['fontSizes'] ) ||
current_theme_supports( 'default-font-sizes' );
$theme_support_data['settings']['spacing']['defaultSpacingSizes'] =
! isset( $theme_support_data['settings']['spacing']['spacingSizes'] ) ||
current_theme_supports( 'default-spacing-sizes' );
* Shadow presets are explicitly disabled for classic themes until a
* decision is made for whether the default presets should match the
* other presets or if they should be disabled by default in classic
* themes. See https://github.com/WordPress/gutenberg/issues/59989.
$theme_support_data['settings']['shadow']['defaultPresets'] = false;
// Allow themes to enable link color setting via theme_support.
if ( current_theme_supports( 'link-color' ) ) {
$theme_support_data['settings']['color']['link'] = true;
// Allow themes to enable all border settings via theme_support.
if ( current_theme_supports( 'border' ) ) {
$theme_support_data['settings']['border']['color'] = true;
$theme_support_data['settings']['border']['radius'] = true;
$theme_support_data['settings']['border']['style'] = true;
$theme_support_data['settings']['border']['width'] = true;
// Allow themes to enable appearance tools via theme_support.
if ( current_theme_supports( 'appearance-tools' ) ) {
$theme_support_data['settings']['appearanceTools'] = true;
$with_theme_supports = new WP_Theme_JSON( $theme_support_data );
$with_theme_supports->merge( static::$theme );
return $with_theme_supports;
* Gets the styles for blocks from the block.json file.
public static function get_block_data() {
$registry = WP_Block_Type_Registry::get_instance();
$blocks = $registry->get_all_registered();
if ( null !== static::$blocks && static::has_same_registered_blocks( 'blocks' ) ) {
$config = array( 'version' => WP_Theme_JSON::LATEST_SCHEMA );
foreach ( $blocks as $block_name => $block_type ) {
if ( isset( $block_type->supports['__experimentalStyle'] ) ) {
$config['styles']['blocks'][ $block_name ] = static::remove_json_comments( $block_type->supports['__experimentalStyle'] );
isset( $block_type->supports['spacing']['blockGap']['__experimentalDefault'] ) &&
! isset( $config['styles']['blocks'][ $block_name ]['spacing']['blockGap'] )
* Ensure an empty placeholder value exists for the block, if it provides a default blockGap value.
* The real blockGap value to be used will be determined when the styles are rendered for output.
$config['styles']['blocks'][ $block_name ]['spacing']['blockGap'] = null;
* Filters the data provided by the blocks for global styles & settings.
* @param WP_Theme_JSON_Data $theme_json Class to access and update the underlying data.
$theme_json = apply_filters( 'wp_theme_json_data_blocks', new WP_Theme_JSON_Data( $config, 'blocks' ) );
* Backward compatibility for extenders returning a WP_Theme_JSON_Data
* compatible class that is not a WP_Theme_JSON_Data object.
if ( $theme_json instanceof WP_Theme_JSON_Data ) {
static::$blocks = $theme_json->get_theme_json();
$config = $theme_json->get_data();
static::$blocks = new WP_Theme_JSON( $config, 'blocks' );
* When given an array, this will remove any keys with the name `//`.
* @param array $input_array The array to filter.
* @return array The filtered array.
private static function remove_json_comments( $input_array ) {
unset( $input_array['//'] );
foreach ( $input_array as $k => $v ) {
$input_array[ $k ] = static::remove_json_comments( $v );
* Returns the custom post type that contains the user's origin config
* for the active theme or an empty array if none are found.
* This can also create and return a new draft custom post type.
* @param WP_Theme $theme The theme object. If empty, it
* defaults to the active theme.
* @param bool $create_post Optional. Whether a new custom post
* type should be created if none are
* @param array $post_status_filter Optional. Filter custom post type by
* post status. Default `array( 'publish' )`,
* so it only fetches published posts.
* @return array Custom Post Type for the user's origin config.
public static function get_user_data_from_wp_global_styles( $theme, $create_post = false, $post_status_filter = array( 'publish' ) ) {
if ( ! $theme instanceof WP_Theme ) {
* Bail early if the theme does not support a theme.json.
* Since wp_theme_has_theme_json() only supports the active
* theme, the extra condition for whether $theme is the active theme is
if ( $theme->get_stylesheet() === get_stylesheet() && ! wp_theme_has_theme_json() ) {
$post_type_filter = 'wp_global_styles';
$stylesheet = $theme->get_stylesheet();