* 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.

 *

	protected static $core = null;

	protected static $theme = null;

	protected static $theme_has_support = null;

	/**

	 * Container for data coming from the user.

	 *

	 * @since 5.9.0

	 * @var WP_Theme_JSON

	 */

	protected static $user = null;

	 * Stores the ID of the custom post type

	 * that holds the user data.

	 * @since 5.9.0

	 * @var int

	 */

	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;

	protected static function read_json_file( $file_path ) {

			$decoded_file = wp_json_file_decode( $file_path, array( 'associative' => true ) );

	 * @deprecated 5.9.0

		_deprecated_function( __METHOD__, '5.9.0' );

		return array();

	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.

		if ( null !== static::$core ) {

			return static::$core;

		$config       = static::read_json_file( __DIR__ . '/theme.json' );

		$config       = static::translate( $config );

		static::$core = new WP_Theme_JSON( $config, 'default' );

		return static::$core;

	 * 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.

	 * @param array $deprecated Deprecated. Not used.

	 * @param array $options {

	 *     Options arguments.

	 *

	 *     @type bool $with_supports Whether to include theme supports in the data. Default true.

	 * }

	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 ) {

			$theme_json_data = static::read_json_file( static::get_file_path_from_theme( 'theme.json' ) );

			$theme_json_data = static::translate( $theme_json_data, wp_get_theme()->get( 'TextDomain' ) );

			static::$theme   = new WP_Theme_JSON( $theme_json_data );

			if ( wp_get_theme()->parent() ) {

				// Get parent theme.json.

				$parent_theme_json_data = static::read_json_file( static::get_file_path_from_theme( 'theme.json', true ) );

				$parent_theme_json_data = static::translate( $parent_theme_json_data, wp_get_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'] ) {

			return static::$theme;

		 * 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_default_block_editor_settings() );

		if ( ! static::theme_has_support() ) {

			if ( ! isset( $theme_support_data['settings']['color'] ) ) {

				$theme_support_data['settings']['color'] = array();

			}

			$default_palette = false;

			if ( current_theme_supports( 'default-color-palette' ) ) {

				$default_palette = true;

			}

			if ( ! isset( $theme_support_data['settings']['color']['palette'] ) ) {

				// If the theme does not have any palette, we still want to show the core one.

				$default_palette = true;

			}

			$theme_support_data['settings']['color']['defaultPalette'] = $default_palette;

			$default_gradients = false;

			if ( current_theme_supports( 'default-gradient-presets' ) ) {

				$default_gradients = true;

			}

			if ( ! isset( $theme_support_data['settings']['color']['gradients'] ) ) {

				// If the theme does not have any gradients, we still want to show the core ones.

				$default_gradients = true;

			}

			$theme_support_data['settings']['color']['defaultGradients'] = $default_gradients;

			// Classic themes without a theme.json don't support global duotone.

			$theme_support_data['settings']['color']['defaultDuotone'] = false;

		}

		$with_theme_supports->merge( static::$theme );

	 * Returns the custom post type that contains the user's origin config

	 * for the active theme or a void array if none are found.

	 *

	 * This can also create and return a new draft custom post type.

	 *

	 * @since 5.9.0

	 * @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

	 *                                     found. Default false.

	 * @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 ) {

			$theme = wp_get_theme();

		}

		$user_cpt         = array();

		$post_type_filter = 'wp_global_styles';

		$args             = array(

			'numberposts' => 1,

			'orderby'     => 'date',

			'order'       => 'desc',

			'post_type'   => $post_type_filter,

			'post_status' => $post_status_filter,

			'tax_query'   => array(

				array(

					'taxonomy' => 'wp_theme',

					'field'    => 'name',

					'terms'    => $theme->get_stylesheet(),

				),

			),

		);

		$cache_key = sprintf( 'wp_global_styles_%s', md5( serialize( $args ) ) );

		$post_id   = wp_cache_get( $cache_key );

		if ( (int) $post_id > 0 ) {

			return get_post( $post_id, ARRAY_A );

		}

		// Special case: '-1' is a results not found.

		if ( -1 === $post_id && ! $create_post ) {

			return $user_cpt;

		}

		$recent_posts = wp_get_recent_posts( $args );

		if ( is_array( $recent_posts ) && ( count( $recent_posts ) === 1 ) ) {

			$user_cpt = $recent_posts[0];

		} elseif ( $create_post ) {

			$cpt_post_id = wp_insert_post(

				array(

					'post_content' => '{"version": ' . WP_Theme_JSON::LATEST_SCHEMA . ', "isGlobalStylesUserThemeJSON": true }',

					'post_status'  => 'publish',

					'post_title'   => 'Custom Styles',

					'post_type'    => $post_type_filter,

					'post_name'    => 'wp-global-styles-' . urlencode( wp_get_theme()->get_stylesheet() ),

					'tax_input'    => array(

						'wp_theme' => array( wp_get_theme()->get_stylesheet() ),

					),

				),

				true

			);

			$user_cpt    = get_post( $cpt_post_id, ARRAY_A );

		}

		$cache_expiration = $user_cpt ? DAY_IN_SECONDS : HOUR_IN_SECONDS;

		wp_cache_set( $cache_key, $user_cpt ? $user_cpt['ID'] : -1, '', $cache_expiration );

		return $user_cpt;

	}

	/**

	 * Returns the user's origin config.

	 * @since 5.9.0

	 *

	 * @return WP_Theme_JSON Entity that holds styles for user data.

	 */

	public static function get_user_data() {

		if ( null !== static::$user ) {

			return static::$user;

		}

		$config   = array();

		$user_cpt = static::get_user_data_from_wp_global_styles( wp_get_theme() );

		if ( array_key_exists( 'post_content', $user_cpt ) ) {

			$decoded_data = json_decode( $user_cpt['post_content'], true );

			$json_decoding_error = json_last_error();

			if ( JSON_ERROR_NONE !== $json_decoding_error ) {

				trigger_error( 'Error when decoding a theme.json schema for user data. ' . json_last_error_msg() );

				return new WP_Theme_JSON( $config, 'custom' );

			}

			// Very important to verify that the flag isGlobalStylesUserThemeJSON is true.

			// If it's not true then the content was not escaped and is not safe.

			if (

				is_array( $decoded_data ) &&

				isset( $decoded_data['isGlobalStylesUserThemeJSON'] ) &&

				$decoded_data['isGlobalStylesUserThemeJSON']

			) {

				unset( $decoded_data['isGlobalStylesUserThemeJSON'] );

				$config = $decoded_data;

			}

		}

		static::$user = new WP_Theme_JSON( $config, 'custom' );

		return static::$user;

	}

	/**

	 * Returns the data merged from multiple origins.

	 *

	 * There are three sources of data (origins) for a site:

	 * default, theme, and custom. The custom's has higher priority

	 * than the theme's, and the theme's higher than default's.

	 *

	 * Unlike the getters

	 * {@link https://developer.wordpress.org/reference/classes/wp_theme_json_resolver/get_core_data/ get_core_data},

	 * {@link https://developer.wordpress.org/reference/classes/wp_theme_json_resolver/get_theme_data/ get_theme_data},

	 * and {@link https://developer.wordpress.org/reference/classes/wp_theme_json_resolver/get_user_data/ get_user_data},

	 * this method returns data after it has been merged with the previous origins.

	 * This means that if the same piece of data is declared in different origins

	 * (user, theme, and core), the last origin overrides the previous.

	 *

	 * For example, if the user has set a background color

	 * for the paragraph block, and the theme has done it as well,

	 * the user preference wins.

	 * @since 5.9.0 Added user data, removed the `$settings` parameter,

	 *              added the `$origin` parameter.

	 * @param string $origin Optional. To what level should we merge data.

	 *                       Valid values are 'theme' or 'custom'. Default 'custom'.

	public static function get_merged_data( $origin = 'custom' ) {

		if ( is_array( $origin ) ) {

			_deprecated_argument( __FUNCTION__, '5.9.0' );

		}

		$result->merge( static::get_core_data() );

		$result->merge( static::get_theme_data() );

		if ( 'custom' === $origin ) {

			$result->merge( static::get_user_data() );

		}

	 * Returns the ID of the custom post type

	 * that stores user data.

	 *

	 * @since 5.9.0

	 *

	 * @return integer|null

	 */

	public static function get_user_global_styles_post_id() {

		if ( null !== static::$user_custom_post_type_id ) {

			return static::$user_custom_post_type_id;

		}

		$user_cpt = static::get_user_data_from_wp_global_styles( wp_get_theme(), true );

		if ( array_key_exists( 'ID', $user_cpt ) ) {

			static::$user_custom_post_type_id = $user_cpt['ID'];

		}

		return static::$user_custom_post_type_id;

	}

	/**

	 * Determines whether the active theme has a theme.json file.

	 * @since 5.9.0 Added a check in the parent theme.