WP_Theme_JSON::merge() │ public │ WP 5.8.0

Merges new incoming data.

Method of the class: WP_Theme_JSON{}

No Hooks.

Return

null. Nothing (null).

Usage

$WP_Theme_JSON = new WP_Theme_JSON();
$WP_Theme_JSON->merge( $incoming );

$incoming(WP_Theme_JSON) (required)

Data to merge.

Changelog

WP_Theme_JSON::merge() WP Theme JSON::merge code ^{WP 6.6.2}

public function merge( $incoming ) {
	$incoming_data    = $incoming->get_raw_data();
	$this->theme_json = array_replace_recursive( $this->theme_json, $incoming_data );

	/*
	 * Recompute all the spacing sizes based on the new hierarchy of data. In the constructor
	 * spacingScale and spacingSizes are both keyed by origin and VALID_ORIGINS is ordered, so
	 * we can allow partial spacingScale data to inherit missing data from earlier layers when
	 * computing the spacing sizes.
	 *
	 * This happens before the presets are merged to ensure that default spacing sizes can be
	 * removed from the theme origin if $prevent_override is true.
	 */
	$flattened_spacing_scale = array();
	foreach ( static::VALID_ORIGINS as $origin ) {
		$scale_path = array( 'settings', 'spacing', 'spacingScale', $origin );

		// Apply the base spacing scale to the current layer.
		$base_spacing_scale      = _wp_array_get( $this->theme_json, $scale_path, array() );
		$flattened_spacing_scale = array_replace( $flattened_spacing_scale, $base_spacing_scale );

		$spacing_scale = _wp_array_get( $incoming_data, $scale_path, null );
		if ( ! isset( $spacing_scale ) ) {
			continue;
		}

		// Allow partial scale settings by merging with lower layers.
		$flattened_spacing_scale = array_replace( $flattened_spacing_scale, $spacing_scale );

		// Generate and merge the scales for this layer.
		$sizes_path           = array( 'settings', 'spacing', 'spacingSizes', $origin );
		$spacing_sizes        = _wp_array_get( $incoming_data, $sizes_path, array() );
		$spacing_scale_sizes  = static::compute_spacing_sizes( $flattened_spacing_scale );
		$merged_spacing_sizes = static::merge_spacing_sizes( $spacing_scale_sizes, $spacing_sizes );

		_wp_array_set( $incoming_data, $sizes_path, $merged_spacing_sizes );
	}

	/*
	 * The array_replace_recursive algorithm merges at the leaf level,
	 * but we don't want leaf arrays to be merged, so we overwrite it.
	 *
	 * For leaf values that are sequential arrays it will use the numeric indexes for replacement.
	 * We rather replace the existing with the incoming value, if it exists.
	 * This is the case of spacing.units.
	 *
	 * For leaf values that are associative arrays it will merge them as expected.
	 * This is also not the behavior we want for the current associative arrays (presets).
	 * We rather replace the existing with the incoming value, if it exists.
	 * This happens, for example, when we merge data from theme.json upon existing
	 * theme supports or when we merge anything coming from the same source twice.
	 * This is the case of color.palette, color.gradients, color.duotone,
	 * typography.fontSizes, or typography.fontFamilies.
	 *
	 * Additionally, for some preset types, we also want to make sure the
	 * values they introduce don't conflict with default values. We do so
	 * by checking the incoming slugs for theme presets and compare them
	 * with the equivalent default presets: if a slug is present as a default
	 * we remove it from the theme presets.
	 */
	$nodes        = static::get_setting_nodes( $incoming_data );
	$slugs_global = static::get_default_slugs( $this->theme_json, array( 'settings' ) );
	foreach ( $nodes as $node ) {
		// Replace the spacing.units.
		$path   = $node['path'];
		$path[] = 'spacing';
		$path[] = 'units';

		$content = _wp_array_get( $incoming_data, $path, null );
		if ( isset( $content ) ) {
			_wp_array_set( $this->theme_json, $path, $content );
		}

		// Replace the presets.
		foreach ( static::PRESETS_METADATA as $preset_metadata ) {
			$prevent_override = $preset_metadata['prevent_override'];
			if ( is_array( $prevent_override ) ) {
				$prevent_override = _wp_array_get( $this->theme_json['settings'], $preset_metadata['prevent_override'] );
			}

			foreach ( static::VALID_ORIGINS as $origin ) {
				$base_path = $node['path'];
				foreach ( $preset_metadata['path'] as $leaf ) {
					$base_path[] = $leaf;
				}

				$path   = $base_path;
				$path[] = $origin;

				$content = _wp_array_get( $incoming_data, $path, null );
				if ( ! isset( $content ) ) {
					continue;
				}

				// Set names for theme presets based on the slug if they are not set and can use default names.
				if ( 'theme' === $origin && $preset_metadata['use_default_names'] ) {
					foreach ( $content as $key => $item ) {
						if ( ! isset( $item['name'] ) ) {
							$name = static::get_name_from_defaults( $item['slug'], $base_path );
							if ( null !== $name ) {
								$content[ $key ]['name'] = $name;
							}
						}
					}
				}

				// Filter out default slugs from theme presets when defaults should not be overridden.
				if ( 'theme' === $origin && $prevent_override ) {
					$slugs_node    = static::get_default_slugs( $this->theme_json, $node['path'] );
					$preset_global = _wp_array_get( $slugs_global, $preset_metadata['path'], array() );
					$preset_node   = _wp_array_get( $slugs_node, $preset_metadata['path'], array() );
					$preset_slugs  = array_merge_recursive( $preset_global, $preset_node );

					$content = static::filter_slugs( $content, $preset_slugs );
				}

				_wp_array_set( $this->theme_json, $path, $content );
			}
		}
	}
}