From 1e791f041dd9eecb00f2e4e4eb42270cd4850987 Mon Sep 17 00:00:00 2001 From: audrasjb Date: Wed, 14 Sep 2022 12:48:16 +0000 Subject: [PATCH] Editor: Backport Style Engine API functions, classes and tests. This PR migrates the Style Engine PHP functions, classes and tests into Core for 6.1. It backports the original [WordPress/gutenberg#40260 PR #40260] from Gutenberg repository. Props ramonopoly, bernhard-reiter, costdev, azaozz, andrewserong, mukesh27, aristath. See #56467. Built from https://develop.svn.wordpress.org/trunk@54156 git-svn-id: http://core.svn.wordpress.org/trunk@53715 1a063a9b-81f0-0310-95a4-ce76da25c4cd --- wp-includes/style-engine.php | 154 +++++ ...class-wp-style-engine-css-declarations.php | 189 ++++++ .../class-wp-style-engine-css-rule.php | 139 +++++ .../class-wp-style-engine-css-rules-store.php | 163 +++++ .../class-wp-style-engine-processor.php | 165 ++++++ .../style-engine/class-wp-style-engine.php | 560 ++++++++++++++++++ wp-includes/version.php | 2 +- wp-settings.php | 6 + 8 files changed, 1377 insertions(+), 1 deletion(-) create mode 100644 wp-includes/style-engine.php create mode 100644 wp-includes/style-engine/class-wp-style-engine-css-declarations.php create mode 100644 wp-includes/style-engine/class-wp-style-engine-css-rule.php create mode 100644 wp-includes/style-engine/class-wp-style-engine-css-rules-store.php create mode 100644 wp-includes/style-engine/class-wp-style-engine-processor.php create mode 100644 wp-includes/style-engine/class-wp-style-engine.php diff --git a/wp-includes/style-engine.php b/wp-includes/style-engine.php new file mode 100644 index 0000000000..1a572e4583 --- /dev/null +++ b/wp-includes/style-engine.php @@ -0,0 +1,154 @@ + array( 'text' => '#cccccc' ) ) ); + * // Returns `array( 'css' => 'color: #cccccc', 'declarations' => array( 'color' => '#cccccc' ), 'classnames' => 'has-color' )`. + * + * @access public + * @since 6.1.0 + * + * @param array $block_styles The style object. + * @param array $options { + * Optional. An array of options. Default empty array. + * + * @type string|null $context An identifier describing the origin of the style object, e.g., 'block-supports' or 'global-styles'. Default is `null`. + * When set, the style engine will attempt to store the CSS rules, where a selector is also passed. + * @type bool $convert_vars_to_classnames Whether to skip converting incoming CSS var patterns, e.g., `var:preset||`, to var( --wp--preset--* ) values. Default `false`. + * @type string $selector Optional. When a selector is passed, the value of `$css` in the return value will comprise a full CSS rule `$selector { ...$css_declarations }`, + * otherwise, the value will be a concatenated string of CSS declarations. + * } + * + * @return array { + * @type string $css A CSS ruleset or declarations block formatted to be placed in an HTML `style` attribute or tag. + * @type string[] $declarations An associative array of CSS definitions, e.g., array( "$property" => "$value", "$property" => "$value" ). + * @type string $classnames Classnames separated by a space. + * } + */ +function wp_style_engine_get_styles( $block_styles, $options = array() ) { + $options = wp_parse_args( + $options, + array( + 'selector' => null, + 'context' => null, + 'convert_vars_to_classnames' => false, + ) + ); + + $parsed_styles = WP_Style_Engine::parse_block_styles( $block_styles, $options ); + + // Output. + $styles_output = array(); + + if ( ! empty( $parsed_styles['declarations'] ) ) { + $styles_output['css'] = WP_Style_Engine::compile_css( $parsed_styles['declarations'], $options['selector'] ); + $styles_output['declarations'] = $parsed_styles['declarations']; + if ( ! empty( $options['context'] ) ) { + WP_Style_Engine::store_css_rule( $options['context'], $options['selector'], $parsed_styles['declarations'] ); + } + } + + if ( ! empty( $parsed_styles['classnames'] ) ) { + $styles_output['classnames'] = implode( ' ', array_unique( $parsed_styles['classnames'] ) ); + } + + return array_filter( $styles_output ); +} + +/** + * Returns compiled CSS from a collection of selectors and declarations. + * Useful for returning a compiled stylesheet from any collection of CSS selector + declarations. + * + * Example usage: + * $css_rules = array( array( 'selector' => '.elephant-are-cool', 'declarations' => array( 'color' => 'gray', 'width' => '3em' ) ) ); + * $css = wp_style_engine_get_stylesheet_from_css_rules( $css_rules ); + * // Returns `.elephant-are-cool{color:gray;width:3em}`. + * + * @since 6.1.0 + * + * @param array $css_rules { + * Required. A collection of CSS rules. + * + * @type array ...$0 { + * @type string $selector A CSS selector. + * @type string[] $declarations An associative array of CSS definitions, e.g., array( "$property" => "$value", "$property" => "$value" ). + * } + * } + * @param array $options { + * Optional. An array of options. Default empty array. + * + * @type string|null $context An identifier describing the origin of the style object, e.g., 'block-supports' or 'global-styles'. Default is 'block-supports'. + * When set, the style engine will attempt to store the CSS rules. + * @type bool $optimize Whether to optimize the CSS output, e.g., combine rules. Default is `false`. + * @type bool $prettify Whether to add new lines and indents to output. Default is the test of whether the global constant `SCRIPT_DEBUG` is defined. + * } + * + * @return string A string of compiled CSS declarations, or empty string. + */ +function wp_style_engine_get_stylesheet_from_css_rules( $css_rules, $options = array() ) { + if ( empty( $css_rules ) ) { + return ''; + } + + $options = wp_parse_args( + $options, + array( + 'context' => null, + ) + ); + + $css_rule_objects = array(); + foreach ( $css_rules as $css_rule ) { + if ( empty( $css_rule['selector'] ) || empty( $css_rule['declarations'] ) || ! is_array( $css_rule['declarations'] ) ) { + continue; + } + + if ( ! empty( $options['context'] ) ) { + WP_Style_Engine::store_css_rule( $options['context'], $css_rule['selector'], $css_rule['declarations'] ); + } + + $css_rule_objects[] = new WP_Style_Engine_CSS_Rule( $css_rule['selector'], $css_rule['declarations'] ); + } + + if ( empty( $css_rule_objects ) ) { + return ''; + } + + return WP_Style_Engine::compile_stylesheet_from_css_rules( $css_rule_objects, $options ); +} + +/** + * Returns compiled CSS from a store, if found. + * + * @since 6.1.0 + * + * @param string $context A valid context name, corresponding to an existing store key. + * @param array $options { + * Optional. An array of options. Default empty array. + * + * @type bool $optimize Whether to optimize the CSS output, e.g., combine rules. Default is `false`. + * @type bool $prettify Whether to add new lines and indents to output. Default is the test of whether the global constant `SCRIPT_DEBUG` is defined. + * } + * + * @return string A compiled CSS string. + */ +function wp_style_engine_get_stylesheet_from_context( $context, $options = array() ) { + return WP_Style_Engine::compile_stylesheet_from_css_rules( WP_Style_Engine::get_store( $context )->get_all_rules(), $options ); +} diff --git a/wp-includes/style-engine/class-wp-style-engine-css-declarations.php b/wp-includes/style-engine/class-wp-style-engine-css-declarations.php new file mode 100644 index 0000000000..0b9eb59a15 --- /dev/null +++ b/wp-includes/style-engine/class-wp-style-engine-css-declarations.php @@ -0,0 +1,189 @@ + value pairs). + * + * @since 6.1.0 + * + * @var array + */ + protected $declarations = array(); + + /** + * Constructor for this object. + * + * If a `$declarations` array is passed, it will be used to populate + * the initial $declarations prop of the object by calling add_declarations(). + * + * @since 6.1.0 + * + * @param string[] $declarations An associative array of CSS definitions, e.g., array( "$property" => "$value", "$property" => "$value" ). + */ + public function __construct( $declarations = array() ) { + $this->add_declarations( $declarations ); + } + + /** + * Adds a single declaration. + * + * @since 6.1.0 + * + * @param string $property The CSS property. + * @param string $value The CSS value. + * + * @return WP_Style_Engine_CSS_Declarations Returns the object to allow chaining methods. + */ + public function add_declaration( $property, $value ) { + // Sanitizes the property. + $property = $this->sanitize_property( $property ); + // Bails early if the property is empty. + if ( empty( $property ) ) { + return $this; + } + + // Trims the value. If empty, bail early. + $value = trim( $value ); + if ( '' === $value ) { + return $this; + } + + // Adds the declaration property/value pair. + $this->declarations[ $property ] = $value; + + return $this; + } + + /** + * Removes a single declaration. + * + * @since 6.1.0 + * + * @param string $property The CSS property. + * + * @return WP_Style_Engine_CSS_Declarations Returns the object to allow chaining methods. + */ + public function remove_declaration( $property ) { + unset( $this->declarations[ $property ] ); + return $this; + } + + /** + * Adds multiple declarations. + * + * @since 6.1.0 + * + * @param array $declarations An array of declarations. + * + * @return WP_Style_Engine_CSS_Declarations Returns the object to allow chaining methods. + */ + public function add_declarations( $declarations ) { + foreach ( $declarations as $property => $value ) { + $this->add_declaration( $property, $value ); + } + return $this; + } + + /** + * Removes multiple declarations. + * + * @since 6.1.0 + * + * @param array $properties An array of properties. + * + * @return WP_Style_Engine_CSS_Declarations Returns the object to allow chaining methods. + */ + public function remove_declarations( $properties = array() ) { + foreach ( $properties as $property ) { + $this->remove_declaration( $property ); + } + return $this; + } + + /** + * Gets the declarations array. + * + * @since 6.1.0 + * + * @return array + */ + public function get_declarations() { + return $this->declarations; + } + + /** + * Filters a CSS property + value pair. + * + * @since 6.1.0 + * + * @param string $property The CSS property. + * @param string $value The value to be filtered. + * @param string $spacer The spacer between the colon and the value. Defaults to an empty string. + * + * @return string The filtered declaration or an empty string. + */ + protected static function filter_declaration( $property, $value, $spacer = '' ) { + $filtered_value = wp_strip_all_tags( $value, true ); + if ( '' !== $filtered_value ) { + return safecss_filter_attr( "{$property}:{$spacer}{$filtered_value}" ); + } + return ''; + } + + /** + * Filters and compiles the CSS declarations. + * + * @since 6.1.0 + * + * @param bool $should_prettify Whether to add spacing, new lines and indents. + * @param number $indent_count The number of tab indents to apply to the rule. Applies if `prettify` is `true`. + * + * @return string The CSS declarations. + */ + public function get_declarations_string( $should_prettify = false, $indent_count = 0 ) { + $declarations_array = $this->get_declarations(); + $declarations_output = ''; + $indent = $should_prettify ? str_repeat( "\t", $indent_count ) : ''; + $suffix = $should_prettify ? ' ' : ''; + $suffix = $should_prettify && $indent_count > 0 ? "\n" : $suffix; + $spacer = $should_prettify ? ' ' : ''; + + foreach ( $declarations_array as $property => $value ) { + $filtered_declaration = static::filter_declaration( $property, $value, $spacer ); + if ( $filtered_declaration ) { + $declarations_output .= "{$indent}{$filtered_declaration};$suffix"; + } + } + return rtrim( $declarations_output ); + } + + /** + * Sanitizes property names. + * + * @since 6.1.0 + * + * @param string $property The CSS property. + * + * @return string The sanitized property name. + */ + protected function sanitize_property( $property ) { + return sanitize_key( $property ); + } +} diff --git a/wp-includes/style-engine/class-wp-style-engine-css-rule.php b/wp-includes/style-engine/class-wp-style-engine-css-rule.php new file mode 100644 index 0000000000..6e53418121 --- /dev/null +++ b/wp-includes/style-engine/class-wp-style-engine-css-rule.php @@ -0,0 +1,139 @@ + "$value", "$property" => "$value" ), + * or a WP_Style_Engine_CSS_Declarations object. + */ + public function __construct( $selector = '', $declarations = array() ) { + $this->set_selector( $selector ); + $this->add_declarations( $declarations ); + } + + /** + * Sets the selector. + * + * @since 6.1.0 + * + * @param string $selector The CSS selector. + * + * @return WP_Style_Engine_CSS_Rule Returns the object to allow chaining of methods. + */ + public function set_selector( $selector ) { + $this->selector = $selector; + return $this; + } + + /** + * Sets the declarations. + * + * @since 6.1.0 + * + * @param array|WP_Style_Engine_CSS_Declarations $declarations An array of declarations (property => value pairs), + * or a WP_Style_Engine_CSS_Declarations object. + * + * @return WP_Style_Engine_CSS_Rule Returns the object to allow chaining of methods. + */ + public function add_declarations( $declarations ) { + $is_declarations_object = ! is_array( $declarations ); + $declarations_array = $is_declarations_object ? $declarations->get_declarations() : $declarations; + + if ( null === $this->declarations ) { + if ( $is_declarations_object ) { + $this->declarations = $declarations; + return $this; + } + $this->declarations = new WP_Style_Engine_CSS_Declarations( $declarations_array ); + } + $this->declarations->add_declarations( $declarations_array ); + + return $this; + } + + /** + * Gets the declarations object. + * + * @since 6.1.0 + * + * @return WP_Style_Engine_CSS_Declarations The declarations object. + */ + public function get_declarations() { + return $this->declarations; + } + + /** + * Gets the full selector. + * + * @since 6.1.0 + * + * @return string + */ + public function get_selector() { + return $this->selector; + } + + /** + * Gets the CSS. + * + * @since 6.1.0 + * + * @param bool $should_prettify Whether to add spacing, new lines and indents. + * @param number $indent_count The number of tab indents to apply to the rule. Applies if `prettify` is `true`. + * + * @return string + */ + public function get_css( $should_prettify = false, $indent_count = 0 ) { + $rule_indent = $should_prettify ? str_repeat( "\t", $indent_count ) : ''; + $declarations_indent = $should_prettify ? $indent_count + 1 : 0; + $suffix = $should_prettify ? "\n" : ''; + $spacer = $should_prettify ? ' ' : ''; + $selector = $should_prettify ? str_replace( ',', ",\n", $this->get_selector() ) : $this->get_selector(); + $css_declarations = $this->declarations->get_declarations_string( $should_prettify, $declarations_indent ); + + if ( empty( $css_declarations ) ) { + return ''; + } + + return "{$rule_indent}{$selector}{$spacer}{{$suffix}{$css_declarations}{$suffix}{$rule_indent}}"; + } +} diff --git a/wp-includes/style-engine/class-wp-style-engine-css-rules-store.php b/wp-includes/style-engine/class-wp-style-engine-css-rules-store.php new file mode 100644 index 0000000000..9b1ed7e706 --- /dev/null +++ b/wp-includes/style-engine/class-wp-style-engine-css-rules-store.php @@ -0,0 +1,163 @@ +set_name( $store_name ); + } + return static::$stores[ $store_name ]; + } + + /** + * Gets an array of all available stores. + * + * @since 6.1.0 + * + * @return WP_Style_Engine_CSS_Rules_Store[] + */ + public static function get_stores() { + return static::$stores; + } + + /** + * Clears all stores from static::$stores. + * + * @since 6.1.0 + * + * @return void + */ + public static function remove_all_stores() { + static::$stores = array(); + } + + /** + * Sets the store name. + * + * @since 6.1.0 + * + * @param string $name The store name. + * + * @return void + */ + public function set_name( $name ) { + $this->name = $name; + } + + /** + * Gets the store name. + * + * @since 6.1.0 + * + * @return string + */ + public function get_name() { + return $this->name; + } + + /** + * Gets an array of all rules. + * + * @since 6.1.0 + * + * @return WP_Style_Engine_CSS_Rule[] + */ + public function get_all_rules() { + return $this->rules; + } + + /** + * Gets a WP_Style_Engine_CSS_Rule object by its selector. + * If the rule does not exist, it will be created. + * + * @since 6.1.0 + * + * @param string $selector The CSS selector. + * + * @return WP_Style_Engine_CSS_Rule|void Returns a WP_Style_Engine_CSS_Rule object, or null if the selector is empty. + */ + public function add_rule( $selector ) { + $selector = trim( $selector ); + + // Bail early if there is no selector. + if ( empty( $selector ) ) { + return; + } + + // Create the rule if it doesn't exist. + if ( empty( $this->rules[ $selector ] ) ) { + $this->rules[ $selector ] = new WP_Style_Engine_CSS_Rule( $selector ); + } + + return $this->rules[ $selector ]; + } + + /** + * Removes a selector from the store. + * + * @since 6.1.0 + * + * @param string $selector The CSS selector. + * + * @return void + */ + public function remove_rule( $selector ) { + unset( $this->rules[ $selector ] ); + } +} diff --git a/wp-includes/style-engine/class-wp-style-engine-processor.php b/wp-includes/style-engine/class-wp-style-engine-processor.php new file mode 100644 index 0000000000..8e035b59ee --- /dev/null +++ b/wp-includes/style-engine/class-wp-style-engine-processor.php @@ -0,0 +1,165 @@ +stores[ $store->get_name() ] = $store; + + return $this; + } + + /** + * Adds rules to be processed. + * + * @since 6.1.0 + * + * @param WP_Style_Engine_CSS_Rule|WP_Style_Engine_CSS_Rule[] $css_rules A single, or an array of, WP_Style_Engine_CSS_Rule objects from a store or otherwise. + * + * @return WP_Style_Engine_Processor Returns the object to allow chaining methods. + */ + public function add_rules( $css_rules ) { + if ( ! is_array( $css_rules ) ) { + $css_rules = array( $css_rules ); + } + + foreach ( $css_rules as $rule ) { + $selector = $rule->get_selector(); + if ( isset( $this->css_rules[ $selector ] ) ) { + $this->css_rules[ $selector ]->add_declarations( $rule->get_declarations() ); + continue; + } + $this->css_rules[ $rule->get_selector() ] = $rule; + } + + return $this; + } + + /** + * Gets the CSS rules as a string. + * + * @since 6.1.0 + * + * @param array $options { + * Optional. An array of options. Default empty array. + * + * @type bool $optimize Whether to optimize the CSS output, e.g., combine rules. Default is `false`. + * @type bool $prettify Whether to add new lines and indents to output. Default is the test of whether the global constant `SCRIPT_DEBUG` is defined. + * } + * + * @return string The computed CSS. + */ + public function get_css( $options = array() ) { + $defaults = array( + 'optimize' => true, + 'prettify' => defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG, + ); + $options = wp_parse_args( $options, $defaults ); + + // If we have stores, get the rules from them. + foreach ( $this->stores as $store ) { + $this->add_rules( $store->get_all_rules() ); + } + + // Combine CSS selectors that have identical declarations. + if ( true === $options['optimize'] ) { + $this->combine_rules_selectors(); + } + + // Build the CSS. + $css = ''; + foreach ( $this->css_rules as $rule ) { + $css .= $rule->get_css( $options['prettify'] ); + $css .= $options['prettify'] ? "\n" : ''; + } + return $css; + } + + /** + * Combines selectors from the rules store when they have the same styles. + * + * @since 6.1.0 + * + * @return void + */ + private function combine_rules_selectors() { + // Build an array of selectors along with the JSON-ified styles to make comparisons easier. + $selectors_json = array(); + foreach ( $this->css_rules as $rule ) { + $declarations = $rule->get_declarations()->get_declarations(); + ksort( $declarations ); + $selectors_json[ $rule->get_selector() ] = wp_json_encode( $declarations ); + } + + // Combine selectors that have the same styles. + foreach ( $selectors_json as $selector => $json ) { + // Get selectors that use the same styles. + $duplicates = array_keys( $selectors_json, $json, true ); + // Skip if there are no duplicates. + if ( 1 >= count( $duplicates ) ) { + continue; + } + + $declarations = $this->css_rules[ $selector ]->get_declarations(); + + foreach ( $duplicates as $key ) { + // Unset the duplicates from the $selectors_json array to avoid looping through them as well. + unset( $selectors_json[ $key ] ); + // Remove the rules from the rules collection. + unset( $this->css_rules[ $key ] ); + } + // Create a new rule with the combined selectors. + $duplicate_selectors = implode( ',', $duplicates ); + $this->css_rules[ $duplicate_selectors ] = new WP_Style_Engine_CSS_Rule( $duplicate_selectors, $declarations ); + } + } +} diff --git a/wp-includes/style-engine/class-wp-style-engine.php b/wp-includes/style-engine/class-wp-style-engine.php new file mode 100644 index 0000000000..7aab1cbb22 --- /dev/null +++ b/wp-includes/style-engine/class-wp-style-engine.php @@ -0,0 +1,560 @@ + (array) an array of classnames to be returned for block styles. The key is a classname or pattern. + * A value of `true` means the classname should be applied always. Otherwise, a valid CSS property (string) + * to match the incoming value, e.g., "color" to match var:preset|color|somePresetSlug. + * - css_vars => (array) an array of key value pairs used to generate CSS var values. The key is a CSS var pattern, whose `$slug` fragment will be replaced with a preset slug. + * The value should be a valid CSS property (string) to match the incoming value, e.g., "color" to match var:preset|color|somePresetSlug. + * - property_keys => (array) array of keys whose values represent a valid CSS property, e.g., "margin" or "border". + * - path => (array) a path that accesses the corresponding style value in the block style object. + * - value_func => (string) the name of a function to generate a CSS definition array for a particular style object. The output of this function should be `array( "$property" => "$value", ... )`. + * + * @since 6.1.0 + * @var array + */ + const BLOCK_STYLE_DEFINITIONS_METADATA = array( + 'color' => array( + 'text' => array( + 'property_keys' => array( + 'default' => 'color', + ), + 'path' => array( 'color', 'text' ), + 'css_vars' => array( + 'color' => '--wp--preset--color--$slug', + ), + 'classnames' => array( + 'has-text-color' => true, + 'has-$slug-color' => 'color', + ), + ), + 'background' => array( + 'property_keys' => array( + 'default' => 'background-color', + ), + 'path' => array( 'color', 'background' ), + 'classnames' => array( + 'has-background' => true, + 'has-$slug-background-color' => 'color', + ), + ), + 'gradient' => array( + 'property_keys' => array( + 'default' => 'background', + ), + 'path' => array( 'color', 'gradient' ), + 'classnames' => array( + 'has-background' => true, + 'has-$slug-gradient-background' => 'gradient', + ), + ), + ), + 'border' => array( + 'color' => array( + 'property_keys' => array( + 'default' => 'border-color', + 'individual' => 'border-%s-color', + ), + 'path' => array( 'border', 'color' ), + 'classnames' => array( + 'has-border-color' => true, + 'has-$slug-border-color' => 'color', + ), + ), + 'radius' => array( + 'property_keys' => array( + 'default' => 'border-radius', + 'individual' => 'border-%s-radius', + ), + 'path' => array( 'border', 'radius' ), + ), + 'style' => array( + 'property_keys' => array( + 'default' => 'border-style', + 'individual' => 'border-%s-style', + ), + 'path' => array( 'border', 'style' ), + ), + 'width' => array( + 'property_keys' => array( + 'default' => 'border-width', + 'individual' => 'border-%s-width', + ), + 'path' => array( 'border', 'width' ), + ), + 'top' => array( + 'value_func' => 'static::get_individual_property_css_declarations', + 'path' => array( 'border', 'top' ), + 'css_vars' => array( + 'color' => '--wp--preset--color--$slug', + ), + ), + 'right' => array( + 'value_func' => 'static::get_individual_property_css_declarations', + 'path' => array( 'border', 'right' ), + 'css_vars' => array( + 'color' => '--wp--preset--color--$slug', + ), + ), + 'bottom' => array( + 'value_func' => 'static::get_individual_property_css_declarations', + 'path' => array( 'border', 'bottom' ), + 'css_vars' => array( + 'color' => '--wp--preset--color--$slug', + ), + ), + 'left' => array( + 'value_func' => 'static::get_individual_property_css_declarations', + 'path' => array( 'border', 'left' ), + 'css_vars' => array( + 'color' => '--wp--preset--color--$slug', + ), + ), + ), + 'spacing' => array( + 'padding' => array( + 'property_keys' => array( + 'default' => 'padding', + 'individual' => 'padding-%s', + ), + 'path' => array( 'spacing', 'padding' ), + 'css_vars' => array( + 'spacing' => '--wp--preset--spacing--$slug', + ), + ), + 'margin' => array( + 'property_keys' => array( + 'default' => 'margin', + 'individual' => 'margin-%s', + ), + 'path' => array( 'spacing', 'margin' ), + 'css_vars' => array( + 'spacing' => '--wp--preset--spacing--$slug', + ), + ), + ), + 'typography' => array( + 'fontSize' => array( + 'property_keys' => array( + 'default' => 'font-size', + ), + 'path' => array( 'typography', 'fontSize' ), + 'classnames' => array( + 'has-$slug-font-size' => 'font-size', + ), + ), + 'fontFamily' => array( + 'property_keys' => array( + 'default' => 'font-family', + ), + 'path' => array( 'typography', 'fontFamily' ), + 'classnames' => array( + 'has-$slug-font-family' => 'font-family', + ), + ), + 'fontStyle' => array( + 'property_keys' => array( + 'default' => 'font-style', + ), + 'path' => array( 'typography', 'fontStyle' ), + ), + 'fontWeight' => array( + 'property_keys' => array( + 'default' => 'font-weight', + ), + 'path' => array( 'typography', 'fontWeight' ), + ), + 'lineHeight' => array( + 'property_keys' => array( + 'default' => 'line-height', + ), + 'path' => array( 'typography', 'lineHeight' ), + ), + 'textDecoration' => array( + 'property_keys' => array( + 'default' => 'text-decoration', + ), + 'path' => array( 'typography', 'textDecoration' ), + ), + 'textTransform' => array( + 'property_keys' => array( + 'default' => 'text-transform', + ), + 'path' => array( 'typography', 'textTransform' ), + ), + 'letterSpacing' => array( + 'property_keys' => array( + 'default' => 'letter-spacing', + ), + 'path' => array( 'typography', 'letterSpacing' ), + ), + ), + ); + + /** + * Util: Extracts the slug in kebab case from a preset string, e.g., "heavenly-blue" from 'var:preset|color|heavenlyBlue'. + * + * @since 6.1.0 + * + * @param string $style_value A single CSS preset value. + * @param string $property_key The CSS property that is the second element of the preset string. Used for matching. + * + * @return string The slug, or empty string if not found. + */ + protected static function get_slug_from_preset_value( $style_value, $property_key ) { + if ( is_string( $style_value ) && is_string( $property_key ) && str_contains( $style_value, "var:preset|{$property_key}|" ) ) { + $index_to_splice = strrpos( $style_value, '|' ) + 1; + return _wp_to_kebab_case( substr( $style_value, $index_to_splice ) ); + } + return ''; + } + + /** + * Util: Generates a CSS var string, e.g., var(--wp--preset--color--background) from a preset string such as `var:preset|space|50`. + * + * @since 6.1.0 + * + * @param string $style_value A single css preset value. + * @param string[] $css_vars An associate array of css var patterns used to generate the var string. + * + * @return string The css var, or an empty string if no match for slug found. + */ + protected static function get_css_var_value( $style_value, $css_vars ) { + foreach ( $css_vars as $property_key => $css_var_pattern ) { + $slug = static::get_slug_from_preset_value( $style_value, $property_key ); + if ( static::is_valid_style_value( $slug ) ) { + $var = strtr( + $css_var_pattern, + array( '$slug' => $slug ) + ); + return "var($var)"; + } + } + return ''; + } + + /** + * Util: Checks whether an incoming block style value is valid. + * + * @since 6.1.0 + * + * @param string $style_value A single CSS preset value. + * + * @return bool + */ + protected static function is_valid_style_value( $style_value ) { + return '0' === $style_value || ! empty( $style_value ); + } + + /** + * Stores a CSS rule using the provided CSS selector and CSS declarations. + * + * @since 6.1.0 + * + * @param string $store_name A valid store key. + * @param string $css_selector When a selector is passed, the function will return a full CSS rule `$selector { ...rules }`, otherwise a concatenated string of properties and values. + * @param string[] $css_declarations An associative array of CSS definitions, e.g., array( "$property" => "$value", "$property" => "$value" ). + * + * @return void. + */ + public static function store_css_rule( $store_name, $css_selector, $css_declarations ) { + if ( empty( $store_name ) || empty( $css_selector ) || empty( $css_declarations ) ) { + return; + } + static::get_store( $store_name )->add_rule( $css_selector )->add_declarations( $css_declarations ); + } + + /** + * Returns a store by store key. + * + * @since 6.1.0 + * + * @param string $store_name A store key. + * + * @return WP_Style_Engine_CSS_Rules_Store + */ + public static function get_store( $store_name ) { + return WP_Style_Engine_CSS_Rules_Store::get_store( $store_name ); + } + + /** + * Returns classnames and CSS based on the values in a styles object. + * Return values are parsed based on the instructions in BLOCK_STYLE_DEFINITIONS_METADATA. + * + * @since 6.1.0 + * + * @param array $block_styles The style object. + * @param array $options { + * Optional. An array of options. Default empty array. + * + * @type bool $convert_vars_to_classnames Whether to skip converting incoming CSS var patterns, e.g., `var:preset||`, to var( --wp--preset--* ) values. Default `false`. + * @type string $selector Optional. When a selector is passed, the value of `$css` in the return value will comprise a full CSS rule `$selector { ...$css_declarations }`, + * otherwise, the value will be a concatenated string of CSS declarations. + * } + * + * @return array { + * @type string $classnames Classnames separated by a space. + * @type string[] $declarations An associative array of CSS definitions, e.g., array( "$property" => "$value", "$property" => "$value" ). + * } + */ + public static function parse_block_styles( $block_styles, $options ) { + $parsed_styles = array( + 'classnames' => array(), + 'declarations' => array(), + ); + if ( empty( $block_styles ) || ! is_array( $block_styles ) ) { + return $parsed_styles; + } + + // Collect CSS and classnames. + foreach ( static::BLOCK_STYLE_DEFINITIONS_METADATA as $definition_group_key => $definition_group_style ) { + if ( empty( $block_styles[ $definition_group_key ] ) ) { + continue; + } + foreach ( $definition_group_style as $style_definition ) { + $style_value = _wp_array_get( $block_styles, $style_definition['path'], null ); + + if ( ! static::is_valid_style_value( $style_value ) ) { + continue; + } + + $parsed_styles['classnames'] = array_merge( $parsed_styles['classnames'], static::get_classnames( $style_value, $style_definition ) ); + $parsed_styles['declarations'] = array_merge( $parsed_styles['declarations'], static::get_css_declarations( $style_value, $style_definition, $options ) ); + } + } + + return $parsed_styles; + } + + /** + * Returns classnames, and generates classname(s) from a CSS preset property pattern, e.g., '`var:preset||`'. + * + * @since 6.1.0 + * + * @param array $style_value A single raw style value or css preset property from the $block_styles array. + * @param array $style_definition A single style definition from BLOCK_STYLE_DEFINITIONS_METADATA. + * + * @return array|string[] An array of CSS classnames, or empty array. + */ + protected static function get_classnames( $style_value, $style_definition ) { + if ( empty( $style_value ) ) { + return array(); + } + + $classnames = array(); + if ( ! empty( $style_definition['classnames'] ) ) { + foreach ( $style_definition['classnames'] as $classname => $property_key ) { + if ( true === $property_key ) { + $classnames[] = $classname; + } + + $slug = static::get_slug_from_preset_value( $style_value, $property_key ); + + if ( $slug ) { + /* + * Right now we expect a classname pattern to be stored in BLOCK_STYLE_DEFINITIONS_METADATA. + * One day, if there are no stored schemata, we could allow custom patterns or + * generate classnames based on other properties + * such as a path or a value or a prefix passed in options. + */ + $classnames[] = strtr( $classname, array( '$slug' => $slug ) ); + } + } + } + + return $classnames; + } + + /** + * Returns an array of CSS declarations based on valid block style values. + * + * @since 6.1.0 + * + * @param array $style_value A single raw style value from $block_styles array. + * @param array $style_definition A single style definition from BLOCK_STYLE_DEFINITIONS_METADATA. + * @param array $options { + * Optional. An array of options. Default empty array. + * + * @type bool $convert_vars_to_classnames Whether to skip converting incoming CSS var patterns, e.g., `var:preset||`, to var( --wp--preset--* ) values. Default `false`. + * } + * + * @return string[] An associative array of CSS definitions, e.g., array( "$property" => "$value", "$property" => "$value" ). + */ + protected static function get_css_declarations( $style_value, $style_definition, $options = array() ) { + if ( isset( $style_definition['value_func'] ) && is_callable( $style_definition['value_func'] ) ) { + return call_user_func( $style_definition['value_func'], $style_value, $style_definition, $options ); + } + + $css_declarations = array(); + $style_property_keys = $style_definition['property_keys']; + $should_skip_css_vars = isset( $options['convert_vars_to_classnames'] ) && true === $options['convert_vars_to_classnames']; + + /* + * Build CSS var values from `var:preset||` values, e.g, `var(--wp--css--rule-slug )`. + * Check if the value is a CSS preset and there's a corresponding css_var pattern in the style definition. + */ + if ( is_string( $style_value ) && str_contains( $style_value, 'var:' ) ) { + if ( ! $should_skip_css_vars && ! empty( $style_definition['css_vars'] ) ) { + $css_var = static::get_css_var_value( $style_value, $style_definition['css_vars'] ); + if ( static::is_valid_style_value( $css_var ) ) { + $css_declarations[ $style_property_keys['default'] ] = $css_var; + } + } + return $css_declarations; + } + + /* + * Default rule builder. + * If the input contains an array, assume box model-like properties + * for styles such as margins and padding. + */ + if ( is_array( $style_value ) ) { + // Bail out early if the `'individual'` property is not defined. + if ( ! isset( $style_property_keys['individual'] ) ) { + return $css_declarations; + } + + foreach ( $style_value as $key => $value ) { + if ( is_string( $value ) && str_contains( $value, 'var:' ) && ! $should_skip_css_vars && ! empty( $style_definition['css_vars'] ) ) { + $value = static::get_css_var_value( $value, $style_definition['css_vars'] ); + } + + $individual_property = sprintf( $style_property_keys['individual'], _wp_to_kebab_case( $key ) ); + + if ( $individual_property && static::is_valid_style_value( $value ) ) { + $css_declarations[ $individual_property ] = $value; + } + } + + return $css_declarations; + } + + $css_declarations[ $style_property_keys['default'] ] = $style_value; + return $css_declarations; + } + + /** + * Style value parser that returns a CSS definition array comprising style properties + * that have keys representing individual style properties, otherwise known as longhand CSS properties. + * e.g., "$style_property-$individual_feature: $value;", which could represent the following: + * "border-{top|right|bottom|left}-{color|width|style}: {value};" or, + * "border-image-{outset|source|width|repeat|slice}: {value};" + * + * @since 6.1.0 + * + * @param array $style_value A single raw style value from $block_styles array. + * @param array $individual_property_definition A single style definition from BLOCK_STYLE_DEFINITIONS_METADATA representing an individual property of a CSS property, e.g., 'top' in 'border-top'. + * @param array $options { + * Optional. An array of options. Default empty array. + * + * @type bool $convert_vars_to_classnames Whether to skip converting incoming CSS var patterns, e.g., `var:preset||`, to var( --wp--preset--* ) values. Default `false`. + * } + * + * @return string[] An associative array of CSS definitions, e.g., array( "$property" => "$value", "$property" => "$value" ). + */ + protected static function get_individual_property_css_declarations( $style_value, $individual_property_definition, $options = array() ) { + if ( ! is_array( $style_value ) || empty( $style_value ) || empty( $individual_property_definition['path'] ) ) { + return array(); + } + + /* + * The first item in $individual_property_definition['path'] array tells us the style property, e.g., "border". + * We use this to get a corresponding CSS style definition such as "color" or "width" from the same group. + * The second item in $individual_property_definition['path'] array refers to the individual property marker, e.g., "top". + */ + $definition_group_key = $individual_property_definition['path'][0]; + $individual_property_key = $individual_property_definition['path'][1]; + $should_skip_css_vars = isset( $options['convert_vars_to_classnames'] ) && true === $options['convert_vars_to_classnames']; + $css_declarations = array(); + + foreach ( $style_value as $css_property => $value ) { + if ( empty( $value ) ) { + continue; + } + + // Build a path to the individual rules in definitions. + $style_definition_path = array( $definition_group_key, $css_property ); + $style_definition = _wp_array_get( static::BLOCK_STYLE_DEFINITIONS_METADATA, $style_definition_path, null ); + + if ( $style_definition && isset( $style_definition['property_keys']['individual'] ) ) { + // Set a CSS var if there is a valid preset value. + if ( is_string( $value ) && str_contains( $value, 'var:' ) && ! $should_skip_css_vars && ! empty( $individual_property_definition['css_vars'] ) ) { + $value = static::get_css_var_value( $value, $individual_property_definition['css_vars'] ); + } + $individual_css_property = sprintf( $style_definition['property_keys']['individual'], $individual_property_key ); + $css_declarations[ $individual_css_property ] = $value; + } + } + return $css_declarations; + } + + /** + * Returns compiled CSS from css_declarations. + * + * @since 6.1.0 + * + * @param string[] $css_declarations An associative array of CSS definitions, e.g., array( "$property" => "$value", "$property" => "$value" ). + * @param string $css_selector When a selector is passed, the function will return a full CSS rule `$selector { ...rules }`, otherwise a concatenated string of properties and values. + * + * @return string A compiled CSS string. + */ + public static function compile_css( $css_declarations, $css_selector ) { + if ( empty( $css_declarations ) || ! is_array( $css_declarations ) ) { + return ''; + } + + // Return an entire rule if there is a selector. + if ( $css_selector ) { + $css_rule = new WP_Style_Engine_CSS_Rule( $css_selector, $css_declarations ); + return $css_rule->get_css(); + } + + $css_declarations = new WP_Style_Engine_CSS_Declarations( $css_declarations ); + return $css_declarations->get_declarations_string(); + } + + /** + * Returns a compiled stylesheet from stored CSS rules. + * + * @since 6.1.0 + * + * @param WP_Style_Engine_CSS_Rule[] $css_rules An array of WP_Style_Engine_CSS_Rule objects from a store or otherwise. + * @param array $options { + * Optional. An array of options. Default empty array. + * + * @type bool $optimize Whether to optimize the CSS output, e.g., combine rules. Default is `false`. + * @type bool $prettify Whether to add new lines and indents to output. Default is the test of whether the global constant `SCRIPT_DEBUG` is defined. + * } + * + * @return string A compiled stylesheet from stored CSS rules. + */ + public static function compile_stylesheet_from_css_rules( $css_rules, $options = array() ) { + $processor = new WP_Style_Engine_Processor(); + $processor->add_rules( $css_rules ); + return $processor->get_css( $options ); + } +} diff --git a/wp-includes/version.php b/wp-includes/version.php index 602401333c..fe98f3a0ff 100644 --- a/wp-includes/version.php +++ b/wp-includes/version.php @@ -16,7 +16,7 @@ * * @global string $wp_version */ -$wp_version = '6.1-alpha-54155'; +$wp_version = '6.1-alpha-54156'; /** * Holds the WordPress DB revision, increments when changes are made to the WordPress DB schema. diff --git a/wp-settings.php b/wp-settings.php index 8fe16195e0..6f0e33bd7e 100644 --- a/wp-settings.php +++ b/wp-settings.php @@ -332,6 +332,12 @@ require ABSPATH . WPINC . '/block-supports/generated-classname.php'; require ABSPATH . WPINC . '/block-supports/layout.php'; require ABSPATH . WPINC . '/block-supports/spacing.php'; require ABSPATH . WPINC . '/block-supports/typography.php'; +require ABSPATH . WPINC . '/style-engine.php'; +require ABSPATH . WPINC . '/style-engine/class-wp-style-engine.php'; +require ABSPATH . WPINC . '/style-engine/class-wp-style-engine-css-declarations.php'; +require ABSPATH . WPINC . '/style-engine/class-wp-style-engine-css-rule.php'; +require ABSPATH . WPINC . '/style-engine/class-wp-style-engine-css-rules-store.php'; +require ABSPATH . WPINC . '/style-engine/class-wp-style-engine-processor.php'; $GLOBALS['wp_embed'] = new WP_Embed();