first commit

wp-content/plugins/elementor/modules/variables/classes/css-renderer.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace Elementor\Modules\Variables\Classes;
+
+use Elementor\Modules\Variables\Storage\Repository as Variables_Repository;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class CSS_Renderer {
+	private Variables_Repository $repository;
+
+	public function __construct( Variables_Repository $repository ) {
+		$this->repository = $repository;
+	}
+
+	private function global_variables(): array {
+		return $this->repository->variables();
+	}
+
+	public function raw_css(): string {
+		$list_of_variables = $this->global_variables();
+
+		if ( empty( $list_of_variables ) ) {
+			return '';
+		}
+
+		$css_entries = $this->css_entries_for( $list_of_variables );
+
+		if ( empty( $css_entries ) ) {
+			return '';
+		}
+
+		return $this->wrap_with_root( $css_entries );
+	}
+
+	private function css_entries_for( array $list_of_variables ): array {
+		$entries = [];
+
+		foreach ( $list_of_variables as $variable_id => $variable ) {
+			$entry = $this->build_css_variable_entry( $variable_id, $variable );
+
+			if ( empty( $entry ) ) {
+				continue;
+			}
+
+			$entries[] = $entry;
+		}
+
+		return $entries;
+	}
+
+	private function build_css_variable_entry( string $id, array $variable ): ?string {
+		$variable_name = sanitize_text_field( $id );
+
+		if ( ! array_key_exists( 'deleted', $variable ) ) {
+			$variable_name = sanitize_text_field( $variable['label'] ?? '' );
+		}
+
+		$value = sanitize_text_field( $variable['value'] ?? '' );
+
+		if ( empty( $value ) || empty( $variable_name ) ) {
+			return null;
+		}
+
+		return "--{$variable_name}:{$value};";
+	}
+
+	private function wrap_with_root( array $css_entries ): string {
+		return ':root { ' . implode( ' ', $css_entries ) . ' }';
+	}
+}

wp-content/plugins/elementor/modules/variables/classes/fonts.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace Elementor\Modules\Variables\Classes;
+
+use Elementor\Plugin;
+use Elementor\Core\Files\CSS\Post as Post_CSS;
+use Elementor\Modules\Variables\PropTypes\Font_Variable_Prop_Type;
+use Elementor\Modules\Variables\Storage\Repository as Variables_Repository;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Fonts {
+	private Variables_Repository $repository;
+
+	public function __construct( Variables_Repository $repository ) {
+		$this->repository = $repository;
+	}
+
+	public function append_to( Post_CSS $post_css ) {
+		if ( ! Plugin::$instance->kits_manager->is_kit( $post_css->get_post_id() ) ) {
+			return;
+		}
+
+		$list_of_variables = $this->repository->variables();
+
+		foreach ( $list_of_variables as $variable ) {
+			if ( Font_Variable_Prop_Type::get_key() !== $variable['type'] ) {
+				continue;
+			}
+
+			$font_family = sanitize_text_field( $variable['value'] ?? '' );
+
+			if ( empty( $font_family ) ) {
+				continue;
+			}
+
+			$post_css->add_font( $font_family );
+		}
+
+		return $this;
+	}
+}

wp-content/plugins/elementor/modules/variables/classes/rest-api.php

@@ -0,0 +1,497 @@
+<?php
+
+namespace Elementor\Modules\Variables\Classes;
+
+use Exception;
+use WP_Error;
+use WP_REST_Response;
+use WP_REST_Request;
+use WP_REST_Server;
+use Elementor\Plugin;
+use Elementor\Modules\Variables\Module as Variables_Module;
+use Elementor\Modules\Variables\Storage\Repository as Variables_Repository;
+use Elementor\Modules\Variables\Storage\Exceptions\VariablesLimitReached;
+use Elementor\Modules\Variables\Storage\Exceptions\RecordNotFound;
+use Elementor\Modules\Variables\Storage\Exceptions\DuplicatedLabel;
+use Elementor\Modules\Variables\Storage\Exceptions\BatchOperationFailed;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Rest_Api {
+	const API_NAMESPACE = 'elementor/v1';
+	const API_BASE = 'variables';
+	const HTTP_OK = 200;
+	const HTTP_CREATED = 201;
+	const HTTP_BAD_REQUEST = 400;
+	const HTTP_NOT_FOUND = 404;
+	const HTTP_SERVER_ERROR = 500;
+	const MAX_ID_LENGTH = 64;
+	const MAX_LABEL_LENGTH = 50;
+	const MAX_VALUE_LENGTH = 512;
+	private Variables_Repository $variables_repository;
+
+	public function __construct( Variables_Repository $variables_repository ) {
+		$this->variables_repository = $variables_repository;
+	}
+
+	public function enough_permissions_to_perform_ro_action() {
+		return current_user_can( 'edit_posts' );
+	}
+
+	public function enough_permissions_to_perform_rw_action() {
+		return current_user_can( 'manage_options' );
+	}
+
+	public function register_routes() {
+		register_rest_route( self::API_NAMESPACE, '/' . self::API_BASE . '/list', [
+			'methods' => WP_REST_Server::READABLE,
+			'callback' => [ $this, 'get_variables' ],
+			'permission_callback' => [ $this, 'enough_permissions_to_perform_ro_action' ],
+		] );
+
+		register_rest_route( self::API_NAMESPACE, '/' . self::API_BASE . '/create', [
+			'methods' => WP_REST_Server::CREATABLE,
+			'callback' => [ $this, 'create_variable' ],
+			'permission_callback' => [ $this, 'enough_permissions_to_perform_rw_action' ],
+			'args' => [
+				'type' => [
+					'required' => true,
+					'type' => 'string',
+					'validate_callback' => [ $this, 'is_valid_variable_type' ],
+					'sanitize_callback' => [ $this, 'trim_and_sanitize_text_field' ],
+				],
+				'label' => [
+					'required' => true,
+					'type' => 'string',
+					'validate_callback' => [ $this, 'is_valid_variable_label' ],
+					'sanitize_callback' => [ $this, 'trim_and_sanitize_text_field' ],
+				],
+				'value' => [
+					'required' => true,
+					'type' => 'string',
+					'validate_callback' => [ $this, 'is_valid_variable_value' ],
+					'sanitize_callback' => [ $this, 'trim_and_sanitize_text_field' ],
+				],
+			],
+		] );
+
+		register_rest_route( self::API_NAMESPACE, '/' . self::API_BASE . '/update', [
+			'methods' => WP_REST_Server::EDITABLE,
+			'callback' => [ $this, 'update_variable' ],
+			'permission_callback' => [ $this, 'enough_permissions_to_perform_rw_action' ],
+			'args' => [
+				'id' => [
+					'required' => true,
+					'type' => 'string',
+					'validate_callback' => [ $this, 'is_valid_variable_id' ],
+					'sanitize_callback' => [ $this, 'trim_and_sanitize_text_field' ],
+				],
+				'label' => [
+					'required' => true,
+					'type' => 'string',
+					'validate_callback' => [ $this, 'is_valid_variable_label' ],
+					'sanitize_callback' => [ $this, 'trim_and_sanitize_text_field' ],
+				],
+				'value' => [
+					'required' => true,
+					'type' => 'string',
+					'validate_callback' => [ $this, 'is_valid_variable_value' ],
+					'sanitize_callback' => [ $this, 'trim_and_sanitize_text_field' ],
+				],
+			],
+		] );
+
+		register_rest_route( self::API_NAMESPACE, '/' . self::API_BASE . '/delete', [
+			'methods' => WP_REST_Server::EDITABLE,
+			'callback' => [ $this, 'delete_variable' ],
+			'permission_callback' => [ $this, 'enough_permissions_to_perform_rw_action' ],
+			'args' => [
+				'id' => [
+					'required' => true,
+					'type' => 'string',
+					'validate_callback' => [ $this, 'is_valid_variable_id' ],
+					'sanitize_callback' => [ $this, 'trim_and_sanitize_text_field' ],
+				],
+			],
+		] );
+
+		register_rest_route( self::API_NAMESPACE, '/' . self::API_BASE . '/restore', [
+			'methods' => WP_REST_Server::EDITABLE,
+			'callback' => [ $this, 'restore_variable' ],
+			'permission_callback' => [ $this, 'enough_permissions_to_perform_rw_action' ],
+			'args' => [
+				'id' => [
+					'required' => true,
+					'type' => 'string',
+					'validate_callback' => [ $this, 'is_valid_variable_id' ],
+					'sanitize_callback' => [ $this, 'trim_and_sanitize_text_field' ],
+				],
+				'label' => [
+					'required' => false,
+					'type' => 'string',
+					'validate_callback' => [ $this, 'is_valid_variable_label' ],
+					'sanitize_callback' => [ $this, 'trim_and_sanitize_text_field' ],
+				],
+				'value' => [
+					'required' => false,
+					'type' => 'string',
+					'validate_callback' => [ $this, 'is_valid_variable_value' ],
+					'sanitize_callback' => [ $this, 'trim_and_sanitize_text_field' ],
+				],
+			],
+		] );
+
+		register_rest_route( self::API_NAMESPACE, '/' . self::API_BASE . '/batch', [
+			'methods' => WP_REST_Server::CREATABLE,
+			'callback' => [ $this, 'process_batch' ],
+			'permission_callback' => [ $this, 'enough_permissions_to_perform_rw_action' ],
+			'args' => [
+				'watermark' => [
+					'required' => true,
+					'type' => 'integer',
+					'validate_callback' => [ $this, 'is_valid_watermark' ],
+				],
+				'operations' => [
+					'required' => true,
+					'type' => 'array',
+					'validate_callback' => [ $this, 'is_valid_operations_array' ],
+				],
+			],
+		] );
+	}
+
+	public function trim_and_sanitize_text_field( $value ) {
+		return trim( sanitize_text_field( $value ) );
+	}
+
+	public function is_valid_variable_id( $id ) {
+		$id = trim( $id );
+
+		if ( empty( $id ) ) {
+			return new WP_Error(
+				'invalid_variable_id_empty',
+				__( 'ID cannot be empty', 'elementor' )
+			);
+		}
+
+		if ( self::MAX_ID_LENGTH < strlen( $id ) ) {
+			return new WP_Error( 'invalid_variable_id_length', sprintf(
+				/* translators: %d: Maximum ID length. */
+				__( 'ID cannot exceed %d characters', 'elementor' ),
+				self::MAX_ID_LENGTH
+			) );
+		}
+
+		return true;
+	}
+
+	public function is_valid_variable_type( $type ) {
+		$allowed_types = array_keys( Variables_Module::instance()->get_variable_types_registry()->all() );
+
+		return in_array( $type, $allowed_types, true );
+	}
+
+	public function is_valid_variable_label( $label ) {
+		$label = trim( $label );
+
+		if ( empty( $label ) ) {
+			return new WP_Error(
+				'invalid_variable_label_empty',
+				__( 'Label cannot be empty', 'elementor' )
+			);
+		}
+
+		if ( self::MAX_LABEL_LENGTH < strlen( $label ) ) {
+			return new WP_Error( 'invalid_variable_label_length', sprintf(
+				/* translators: %d: Maximum label length. */
+				__( 'Label cannot exceed %d characters', 'elementor' ),
+				self::MAX_LABEL_LENGTH
+			) );
+		}
+
+		return true;
+	}
+
+	public function is_valid_variable_value( $value ) {
+		$value = trim( $value );
+
+		if ( empty( $value ) ) {
+			return new WP_Error(
+				'invalid_variable_value_empty',
+				__( 'Value cannot be empty', 'elementor' )
+			);
+		}
+
+		if ( self::MAX_VALUE_LENGTH < strlen( $value ) ) {
+			return new WP_Error( 'invalid_variable_value_length', sprintf(
+				/* translators: %d: Maximum value length. */
+				__( 'Value cannot exceed %d characters', 'elementor' ),
+				self::MAX_VALUE_LENGTH
+			) );
+		}
+
+		return true;
+	}
+
+	public function create_variable( WP_REST_Request $request ) {
+		try {
+			return $this->create_new_variable( $request );
+		} catch ( Exception $e ) {
+			return $this->error_response( $e );
+		}
+	}
+
+	protected function clear_cache() {
+		Plugin::$instance->files_manager->clear_cache();
+	}
+
+	private function create_new_variable( WP_REST_Request $request ) {
+		$type = $request->get_param( 'type' );
+		$label = $request->get_param( 'label' );
+		$value = $request->get_param( 'value' );
+
+		$result = $this->variables_repository->create( [
+			'type' => $type,
+			'label' => $label,
+			'value' => $value,
+		] );
+
+		$this->clear_cache();
+
+		return $this->success_response( [
+			'variable' => $result['variable'],
+			'watermark' => $result['watermark'],
+		], self::HTTP_CREATED );
+	}
+
+	public function update_variable( WP_REST_Request $request ) {
+		try {
+			return $this->update_existing_variable( $request );
+		} catch ( Exception $e ) {
+			return $this->error_response( $e );
+		}
+	}
+
+	private function update_existing_variable( WP_REST_Request $request ) {
+		$id = $request->get_param( 'id' );
+		$label = $request->get_param( 'label' );
+		$value = $request->get_param( 'value' );
+
+		$result = $this->variables_repository->update( $id, [
+			'label' => $label,
+			'value' => $value,
+		] );
+
+		$this->clear_cache();
+
+		return $this->success_response( [
+			'variable' => $result['variable'],
+			'watermark' => $result['watermark'],
+		] );
+	}
+
+	public function delete_variable( WP_REST_Request $request ) {
+		try {
+			return $this->delete_existing_variable( $request );
+		} catch ( Exception $e ) {
+			return $this->error_response( $e );
+		}
+	}
+
+	private function delete_existing_variable( WP_REST_Request $request ) {
+		$id = $request->get_param( 'id' );
+
+		$result = $this->variables_repository->delete( $id );
+
+		$this->clear_cache();
+
+		return $this->success_response( [
+			'variable' => $result['variable'],
+			'watermark' => $result['watermark'],
+		] );
+	}
+
+	public function restore_variable( WP_REST_Request $request ) {
+		try {
+			return $this->restore_existing_variable( $request );
+		} catch ( Exception $e ) {
+			return $this->error_response( $e );
+		}
+	}
+
+	private function restore_existing_variable( WP_REST_Request $request ) {
+		$id = $request->get_param( 'id' );
+
+		$overrides = [];
+
+		$label = $request->get_param( 'label' );
+
+		if ( $label ) {
+			$overrides['label'] = $label;
+		}
+
+		$value = $request->get_param( 'value' );
+
+		if ( $value ) {
+			$overrides['value'] = $value;
+		}
+
+		$result = $this->variables_repository->restore( $id, $overrides );
+
+		$this->clear_cache();
+
+		return $this->success_response( [
+			'variable' => $result['variable'],
+			'watermark' => $result['watermark'],
+		] );
+	}
+
+	public function get_variables() {
+		try {
+			return $this->list_of_variables();
+		} catch ( Exception $e ) {
+			return $this->error_response( $e );
+		}
+	}
+
+	private function list_of_variables() {
+		$db_record = $this->variables_repository->load();
+
+		return $this->success_response( [
+			'variables' => $db_record['data'],
+			'total' => count( $db_record['data'] ),
+			'watermark' => $db_record['watermark'],
+		] );
+	}
+
+	private function success_response( $payload, $status_code = null ) {
+		return new WP_REST_Response( [
+			'success' => true,
+			'data' => $payload,
+		], $status_code ?? self::HTTP_OK );
+	}
+
+	private function error_response( Exception $e ) {
+		if ( $e instanceof VariablesLimitReached ) {
+			return $this->prepare_error_response(
+				self::HTTP_BAD_REQUEST,
+				'invalid_variable_limit_reached',
+				__( 'Reached the maximum number of variables', 'elementor' )
+			);
+		}
+
+		if ( $e instanceof DuplicatedLabel ) {
+			return $this->prepare_error_response(
+				self::HTTP_BAD_REQUEST,
+				'duplicated_label',
+				__( 'Variable label already exists', 'elementor' )
+			);
+		}
+
+		if ( $e instanceof RecordNotFound ) {
+			return $this->prepare_error_response(
+				self::HTTP_NOT_FOUND,
+				'variable_not_found',
+				__( 'Variable not found', 'elementor' )
+			);
+		}
+
+		return $this->prepare_error_response(
+			self::HTTP_SERVER_ERROR,
+			'unexpected_server_error',
+			__( 'Unexpected server error', 'elementor' )
+		);
+	}
+
+	private function prepare_error_response( $status_code, $error, $message ) {
+		return new WP_REST_Response( [
+			'code' => $error,
+			'message' => $message,
+			'data' => [
+				'status' => $status_code,
+			],
+		], $status_code );
+	}
+
+	public function is_valid_watermark( $watermark ) {
+		if ( ! is_numeric( $watermark ) || $watermark < 0 ) {
+			return new WP_Error(
+				'invalid_watermark',
+				__( 'Watermark must be a non-negative integer', 'elementor' )
+			);
+		}
+
+		return true;
+	}
+
+	public function is_valid_operations_array( $operations ) {
+		if ( ! is_array( $operations ) || empty( $operations ) ) {
+			return new WP_Error(
+				'invalid_operations_empty',
+				__( 'Operations array cannot be empty', 'elementor' )
+			);
+		}
+
+		foreach ( $operations as $index => $operation ) {
+			if ( ! is_array( $operation ) || ! isset( $operation['type'] ) ) {
+				return new WP_Error(
+					'invalid_operation_structure',
+					sprintf(
+						/* translators: %d: operation index */
+						__( 'Invalid operation structure at index %d', 'elementor' ),
+						$index
+					)
+				);
+			}
+
+			$allowed_types = [ 'create', 'update', 'delete', 'restore' ];
+
+			if ( ! in_array( $operation['type'], $allowed_types, true ) ) {
+				return new WP_Error(
+					'invalid_operation_type',
+					sprintf(
+						/* translators: %d: operation index */
+						__( 'Invalid operation type at index %d', 'elementor' ),
+						$index
+					)
+				);
+			}
+		}
+
+		return true;
+	}
+
+	public function process_batch( WP_REST_Request $request ) {
+		try {
+			return $this->process_batch_operations( $request );
+		} catch ( Exception $e ) {
+			return $this->batch_error_response( $e );
+		}
+	}
+
+	private function process_batch_operations( WP_REST_Request $request ) {
+		$watermark = $request->get_param( 'watermark' );
+		$operations = $request->get_param( 'operations' );
+
+		$result = $this->variables_repository->process_atomic_batch( $operations, $watermark );
+
+		$this->clear_cache();
+
+		return $this->success_response( $result );
+	}
+
+	private function batch_error_response( Exception $e ) {
+		if ( $e instanceof BatchOperationFailed ) {
+			return new WP_REST_Response( [
+				'success' => false,
+				'code' => 'atomic_operation_failed',
+				'message' => __( 'Batch operation failed', 'elementor' ),
+				'data' => $e->getErrorDetails(),
+			], self::HTTP_BAD_REQUEST );
+		}
+
+		return $this->error_response( $e );
+	}
+}

wp-content/plugins/elementor/modules/variables/classes/style-schema.php

@@ -0,0 +1,93 @@
+<?php
+
+namespace Elementor\Modules\Variables\Classes;
+
+use Elementor\Modules\AtomicWidgets\PropTypes\Base\Array_Prop_Type;
+use Elementor\Modules\AtomicWidgets\PropTypes\Base\Object_Prop_Type;
+use Elementor\Modules\AtomicWidgets\PropTypes\Primitives\String_Prop_Type;
+use Elementor\Modules\AtomicWidgets\PropTypes\Color_Prop_Type;
+use Elementor\Modules\AtomicWidgets\PropTypes\Union_Prop_Type;
+use Elementor\Modules\Variables\PropTypes\Color_Variable_Prop_Type;
+use Elementor\Modules\Variables\PropTypes\Font_Variable_Prop_Type;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Style_Schema {
+	public function augment( array $schema ): array {
+		foreach ( $schema as $key => $prop_type ) {
+			$schema[ $key ] = $this->update( $prop_type );
+		}
+
+		if ( isset( $schema['font-family'] ) ) {
+			$schema['font-family'] = $this->update_font_family( $schema['font-family'] );
+		}
+
+		return $schema;
+	}
+
+	private function update( $prop_type ) {
+		if ( $prop_type instanceof Color_Prop_Type ) {
+			return $this->update_color( $prop_type );
+		}
+
+		if ( $prop_type instanceof Union_Prop_Type ) {
+			return $this->update_union( $prop_type );
+		}
+
+		if ( $prop_type instanceof Object_Prop_Type ) {
+			return $this->update_object( $prop_type );
+		}
+
+		if ( $prop_type instanceof Array_Prop_Type ) {
+			return $this->update_array( $prop_type );
+		}
+
+		return $prop_type;
+	}
+
+	private function update_font_family( String_Prop_Type $prop_type ): Union_Prop_Type {
+		return Union_Prop_Type::create_from( $prop_type )
+			->add_prop_type( Font_Variable_Prop_Type::make() );
+	}
+
+	private function update_color( Color_Prop_Type $color_prop_type ): Union_Prop_Type {
+		return Union_Prop_Type::create_from( $color_prop_type )
+			->add_prop_type( Color_Variable_Prop_Type::make() );
+	}
+
+	private function update_array( Array_Prop_Type $array_prop_type ): Array_Prop_Type {
+		return $array_prop_type->set_item_type(
+			$this->update( $array_prop_type->get_item_type() )
+		);
+	}
+
+	private function update_object( Object_Prop_Type $object_prop_type ): Object_Prop_Type {
+		return $object_prop_type->set_shape(
+			$this->augment( $object_prop_type->get_shape() )
+		);
+	}
+
+	private function update_union( Union_Prop_Type $union_prop_type ): Union_Prop_Type {
+		$new_union = Union_Prop_Type::make();
+		$dependencies = $union_prop_type->get_dependencies();
+		$new_union->set_dependencies( $dependencies );
+
+		foreach ( $union_prop_type->get_prop_types() as $prop_type ) {
+			$updated = $this->update( $prop_type );
+
+			if ( $updated instanceof Union_Prop_Type ) {
+				foreach ( $updated->get_prop_types() as $updated_prop_type ) {
+					$new_union->add_prop_type( $updated_prop_type );
+				}
+
+				continue;
+			}
+
+			$new_union->add_prop_type( $updated );
+		}
+
+		return $new_union;
+	}
+}

wp-content/plugins/elementor/modules/variables/classes/style-transformers.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Elementor\Modules\Variables\Classes;
+
+use Elementor\Modules\AtomicWidgets\PropsResolver\Transformers_Registry;
+use Elementor\Modules\Variables\PropTypes\Color_Variable_Prop_Type;
+use Elementor\Modules\Variables\PropTypes\Font_Variable_Prop_Type;
+use Elementor\Modules\Variables\Transformers\Global_Variable_Transformer;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Style_Transformers {
+	public function append_to( Transformers_Registry $transformers_registry ): self {
+		$transformer = new Global_Variable_Transformer();
+
+		$transformers_registry->register( Color_Variable_Prop_Type::get_key(), $transformer );
+		$transformers_registry->register( Font_Variable_Prop_Type::get_key(), $transformer );
+
+		return $this;
+	}
+}

wp-content/plugins/elementor/modules/variables/classes/variable-types-registry.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Elementor\Modules\Variables\Classes;
+
+use Elementor\Modules\AtomicWidgets\PropTypes\Contracts\Transformable_Prop_Type;
+use InvalidArgumentException;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Variable_Types_Registry {
+	private array $types = [];
+
+	public function register( string $key, Transformable_Prop_Type $prop_type ): void {
+		if ( isset( $this->types[ $key ] ) ) {
+			throw new InvalidArgumentException( esc_html( "Key '{$key}' is already registered." ) );
+		}
+
+		$this->types[ $key ] = $prop_type;
+	}
+
+	public function get( $key ) {
+		return $this->types[ $key ] ?? null;
+	}
+
+	public function all(): array {
+		return $this->types;
+	}
+}

wp-content/plugins/elementor/modules/variables/classes/variables.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Elementor\Modules\Variables\Classes;
+
+use Elementor\Modules\Variables\Storage\Repository as Variables_Repository;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Variables {
+	private static $lookup = [];
+
+	public static function init( Variables_Repository $repository ) {
+		self::$lookup = $repository->variables();
+	}
+
+	public static function by_id( string $id ) {
+		return self::$lookup[ $id ] ?? null;
+	}
+}

wp-content/plugins/elementor/modules/variables/hooks.php

@@ -0,0 +1,120 @@
+<?php
+
+namespace Elementor\Modules\Variables;
+
+use Elementor\Modules\Variables\Classes\Variable_Types_Registry;
+use Elementor\Modules\Variables\PropTypes\Color_Variable_Prop_Type;
+use Elementor\Modules\Variables\PropTypes\Font_Variable_Prop_Type;
+use Elementor\Plugin;
+use Elementor\Core\Files\CSS\Post as Post_CSS;
+use Elementor\Modules\Variables\Classes\CSS_Renderer as Variables_CSS_Renderer;
+use Elementor\Modules\Variables\Classes\Fonts;
+use Elementor\Modules\Variables\Classes\Rest_Api as Variables_API;
+use Elementor\Modules\Variables\Storage\Repository as Variables_Repository;
+use Elementor\Modules\Variables\Classes\Style_Schema;
+use Elementor\Modules\Variables\Classes\Style_Transformers;
+use Elementor\Modules\Variables\Classes\Variables;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Hooks {
+	const PACKAGES = [
+		'editor-variables',
+	];
+
+	public function register() {
+		$this->register_styles_transformers()
+			->register_packages()
+			->filter_for_style_schema()
+			->register_css_renderer()
+			->register_fonts()
+			->register_api_endpoints()
+			->register_variable_types();
+
+		return $this;
+	}
+
+	private function register_variable_types() {
+		add_action( 'elementor/variables/register', function ( Variable_Types_Registry $registry ) {
+			$registry->register( Color_Variable_Prop_Type::get_key(), new Color_Variable_Prop_Type() );
+			$registry->register( Font_Variable_Prop_Type::get_key(), new Font_Variable_Prop_Type() );
+		} );
+
+		return $this;
+	}
+
+	private function register_packages() {
+		add_filter( 'elementor/editor/v2/packages', function ( $packages ) {
+			return array_merge( $packages, self::PACKAGES );
+		} );
+
+		return $this;
+	}
+
+	private function register_styles_transformers() {
+		add_action( 'elementor/atomic-widgets/styles/transformers/register', function ( $registry ) {
+			Variables::init( $this->variables_repository() );
+			( new Style_Transformers() )->append_to( $registry );
+		} );
+
+		return $this;
+	}
+
+	private function filter_for_style_schema() {
+		add_filter( 'elementor/atomic-widgets/styles/schema', function ( array $schema ) {
+			return ( new Style_Schema() )->augment( $schema );
+		} );
+
+		return $this;
+	}
+
+	private function css_renderer() {
+		return new Variables_CSS_Renderer( $this->variables_repository() );
+	}
+
+	private function register_css_renderer() {
+		add_action( 'elementor/css-file/post/parse', function ( Post_CSS $post_css ) {
+			if ( ! Plugin::$instance->kits_manager->is_kit( $post_css->get_post_id() ) ) {
+				return;
+			}
+
+			$post_css->get_stylesheet()->add_raw_css(
+				$this->css_renderer()->raw_css()
+			);
+		} );
+
+		return $this;
+	}
+
+	private function fonts() {
+		return new Fonts( $this->variables_repository() );
+	}
+
+	private function register_fonts() {
+		add_action( 'elementor/css-file/post/parse', function ( $post_css ) {
+			$this->fonts()->append_to( $post_css );
+		} );
+
+		return $this;
+	}
+
+	private function rest_api() {
+		return new Variables_API( $this->variables_repository() );
+	}
+
+	private function register_api_endpoints() {
+		add_action( 'rest_api_init', function () {
+			$this->rest_api()->register_routes();
+		} );
+
+		return $this;
+	}
+
+	private function variables_repository() {
+		return new Variables_Repository(
+			Plugin::$instance->kits_manager->get_active_kit()
+		);
+	}
+}

wp-content/plugins/elementor/modules/variables/module.php

@@ -0,0 +1,80 @@
+<?php
+
+namespace Elementor\Modules\Variables;
+
+use Elementor\Core\Base\Module as BaseModule;
+use Elementor\Core\Experiments\Manager as ExperimentsManager;
+use Elementor\Modules\AtomicWidgets\Module as AtomicWidgetsModule;
+use Elementor\Modules\Variables\Classes\Variable_Types_Registry;
+use Elementor\Plugin;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Module extends BaseModule {
+	const MODULE_NAME = 'e-variables';
+	const EXPERIMENT_NAME = 'e_variables';
+	const EXPERIMENT_MANAGER_NAME = 'e_variables_manager';
+
+	private Variable_Types_Registry $variable_types_registry;
+
+	public function get_name() {
+		return self::MODULE_NAME;
+	}
+
+	public static function get_experimental_data(): array {
+		return [
+			'name' => self::EXPERIMENT_NAME,
+			'title' => esc_html__( 'Variables', 'elementor' ),
+			'description' => esc_html__( 'Enable variables. (For this feature to work - Atomic Widgets must be active)', 'elementor' ),
+			'hidden' => true,
+			'default' => ExperimentsManager::STATE_ACTIVE,
+			'release_status' => ExperimentsManager::RELEASE_STATUS_ALPHA,
+		];
+	}
+
+	private function hooks() {
+		return new Hooks();
+	}
+
+	public function __construct() {
+		parent::__construct();
+
+		if ( ! $this->is_experiment_active() ) {
+			return;
+		}
+		$this->register_features();
+
+		$this->hooks()->register();
+
+		add_action( 'init', [ $this, 'init_variable_types_registry' ] );
+	}
+
+	private function register_features() {
+		Plugin::$instance->experiments->add_feature([
+			'name' => self::EXPERIMENT_MANAGER_NAME,
+			'title' => esc_html__( 'Variables Manager', 'elementor' ),
+			'description' => esc_html__( 'Enable variables manager. (For this feature to work - Variables must be active)', 'elementor' ),
+			'hidden' => true,
+			'default' => ExperimentsManager::STATE_INACTIVE,
+			'release_status' => ExperimentsManager::RELEASE_STATUS_ALPHA,
+		]);
+	}
+
+	private function is_experiment_active(): bool {
+		return Plugin::$instance->experiments->is_feature_active( self::EXPERIMENT_NAME )
+			&& Plugin::$instance->experiments->is_feature_active( AtomicWidgetsModule::EXPERIMENT_NAME );
+	}
+
+	public function init_variable_types_registry(): void {
+		$this->variable_types_registry = new Variable_Types_Registry();
+
+		do_action( 'elementor/variables/register', $this->variable_types_registry );
+	}
+
+
+	public function get_variable_types_registry(): Variable_Types_Registry {
+		return $this->variable_types_registry;
+	}
+}

wp-content/plugins/elementor/modules/variables/prop-types/color-variable-prop-type.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Elementor\Modules\Variables\PropTypes;
+
+use Elementor\Modules\AtomicWidgets\PropTypes\Primitives\String_Prop_Type;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Color_Variable_Prop_Type extends String_Prop_Type {
+	public static function get_key(): string {
+		return 'global-color-variable';
+	}
+}

wp-content/plugins/elementor/modules/variables/prop-types/font-variable-prop-type.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Elementor\Modules\Variables\PropTypes;
+
+use Elementor\Modules\AtomicWidgets\PropTypes\Primitives\String_Prop_Type;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Font_Variable_Prop_Type extends String_Prop_Type {
+	public static function get_key(): string {
+		return 'global-font-variable';
+	}
+}

wp-content/plugins/elementor/modules/variables/storage/exceptions/batch-operation-failed.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Elementor\Modules\Variables\Storage\Exceptions;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class BatchOperationFailed extends \Exception {
+	private array $error_details;
+
+	public function __construct( string $message, array $error_details = [] ) {
+		parent::__construct( $message );
+		$this->error_details = $error_details;
+	}
+
+	public function getErrorDetails(): array {
+		return $this->error_details;
+	}
+}

wp-content/plugins/elementor/modules/variables/storage/exceptions/duplicated-label.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Elementor\Modules\Variables\Storage\Exceptions;
+
+use Exception;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class DuplicatedLabel extends Exception {}

wp-content/plugins/elementor/modules/variables/storage/exceptions/fatal-error.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Elementor\Modules\Variables\Storage\Exceptions;
+
+use Exception;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class FatalError extends Exception {}

wp-content/plugins/elementor/modules/variables/storage/exceptions/record-not-found.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Elementor\Modules\Variables\Storage\Exceptions;
+
+use Exception;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class RecordNotFound extends Exception {}

wp-content/plugins/elementor/modules/variables/storage/exceptions/variables-limit-reached.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Elementor\Modules\Variables\Storage\Exceptions;
+
+use Exception;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class VariablesLimitReached extends Exception {}

wp-content/plugins/elementor/modules/variables/storage/repository.php

@@ -0,0 +1,455 @@
+<?php
+
+namespace Elementor\Modules\Variables\Storage;
+
+use Elementor\Core\Kits\Documents\Kit;
+use Elementor\Modules\AtomicWidgets\Utils;
+use Elementor\Modules\Variables\Storage\Exceptions\DuplicatedLabel;
+use Elementor\Modules\Variables\Storage\Exceptions\RecordNotFound;
+use Elementor\Modules\Variables\Storage\Exceptions\VariablesLimitReached;
+use Elementor\Modules\Variables\Storage\Exceptions\FatalError;
+use Elementor\Modules\Variables\Storage\Exceptions\BatchOperationFailed;
+use Exception;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Repository {
+	const TOTAL_VARIABLES_COUNT = 100;
+	const FORMAT_VERSION_V1 = 1;
+	const VARIABLES_META_KEY = '_elementor_global_variables';
+	private Kit $kit;
+
+	public function __construct( Kit $kit ) {
+		$this->kit = $kit;
+	}
+
+	/**
+	 * @throws VariablesLimitReached
+	 */
+	private function assert_if_variables_limit_reached( array $db_record ) {
+		$variables_in_use = 0;
+
+		foreach ( $db_record['data'] as $variable ) {
+			if ( isset( $variable['deleted'] ) && $variable['deleted'] ) {
+				continue;
+			}
+
+			++$variables_in_use;
+		}
+
+		if ( self::TOTAL_VARIABLES_COUNT < $variables_in_use ) {
+			throw new VariablesLimitReached( 'Total variables count limit reached' );
+		}
+	}
+
+	/**
+	 * @throws DuplicatedLabel
+	 */
+	private function assert_if_variable_label_is_duplicated( array $db_record, array $variable = [] ) {
+		foreach ( $db_record['data'] as $id => $existing_variable ) {
+			if ( isset( $existing_variable['deleted'] ) && $existing_variable['deleted'] ) {
+				continue;
+			}
+
+			if ( isset( $variable['id'] ) && $variable['id'] === $id ) {
+				continue;
+			}
+
+			if ( ! isset( $variable['label'] ) || ! isset( $existing_variable['label'] ) ) {
+				continue;
+			}
+
+			if ( strtolower( $existing_variable['label'] ) === strtolower( $variable['label'] ) ) {
+				throw new DuplicatedLabel( 'Variable label already exists' );
+			}
+		}
+	}
+
+	public function variables(): array {
+		$db_record = $this->load();
+
+		return $db_record['data'] ?? [];
+	}
+
+	public function load(): array {
+		$db_record = $this->kit->get_json_meta( static::VARIABLES_META_KEY );
+
+		if ( is_array( $db_record ) && ! empty( $db_record ) ) {
+			return $db_record;
+		}
+
+		return $this->get_default_meta();
+	}
+
+	/**
+	 * @throws FatalError
+	 */
+	public function create( array $variable ) {
+		$db_record = $this->load();
+
+		$list_of_variables = $db_record['data'] ?? [];
+
+		$id = $this->new_id_for( $list_of_variables );
+		$new_variable = $this->extract_from( $variable, [
+			'type',
+			'label',
+			'value',
+		] );
+
+		$this->assert_if_variable_label_is_duplicated( $db_record, $new_variable );
+
+		$list_of_variables[ $id ] = $new_variable;
+		$db_record['data'] = $list_of_variables;
+
+		$this->assert_if_variables_limit_reached( $db_record );
+
+		$watermark = $this->save( $db_record );
+
+		if ( false === $watermark ) {
+			throw new FatalError( 'Failed to create variable' );
+		}
+
+		return [
+			'variable' => array_merge( [ 'id' => $id ], $list_of_variables[ $id ] ),
+			'watermark' => $watermark,
+		];
+	}
+
+	/**
+	 * @throws RecordNotFound
+	 * @throws FatalError
+	 */
+	public function update( string $id, array $variable ) {
+		$db_record = $this->load();
+
+		$list_of_variables = $db_record['data'] ?? [];
+
+		if ( ! isset( $list_of_variables[ $id ] ) ) {
+			throw new RecordNotFound( 'Variable not found' );
+		}
+
+		$updated_variable = array_merge( $list_of_variables[ $id ], $this->extract_from( $variable, [
+			'label',
+			'value',
+		] ) );
+
+		$this->assert_if_variable_label_is_duplicated( $db_record, array_merge( $updated_variable, [ 'id' => $id ] ) );
+
+		$list_of_variables[ $id ] = $updated_variable;
+		$db_record['data'] = $list_of_variables;
+
+		$watermark = $this->save( $db_record );
+
+		if ( false === $watermark ) {
+			throw new FatalError( 'Failed to update variable' );
+		}
+
+		return [
+			'variable' => array_merge( [ 'id' => $id ], $list_of_variables[ $id ] ),
+			'watermark' => $watermark,
+		];
+	}
+
+	/**
+	 * @throws RecordNotFound
+	 * @throws FatalError
+	 */
+	public function delete( string $id ) {
+		$db_record = $this->load();
+
+		$list_of_variables = $db_record['data'] ?? [];
+
+		if ( ! isset( $list_of_variables[ $id ] ) ) {
+			throw new RecordNotFound( 'Variable not found' );
+		}
+
+		$list_of_variables[ $id ]['deleted'] = true;
+		$list_of_variables[ $id ]['deleted_at'] = $this->now();
+
+		$db_record['data'] = $list_of_variables;
+
+		$watermark = $this->save( $db_record );
+
+		if ( false === $watermark ) {
+			throw new FatalError( 'Failed to delete variable' );
+		}
+
+		return [
+			'variable' => array_merge( [ 'id' => $id ], $list_of_variables[ $id ] ),
+			'watermark' => $watermark,
+		];
+	}
+
+	/**
+	 * @throws RecordNotFound
+	 * @throws FatalError
+	 */
+	public function restore( string $id, $overrides = [] ) {
+		$db_record = $this->load();
+
+		$list_of_variables = $db_record['data'] ?? [];
+
+		if ( ! isset( $list_of_variables[ $id ] ) ) {
+			throw new RecordNotFound( 'Variable not found' );
+		}
+
+		$restored_variable = $this->extract_from( $list_of_variables[ $id ], [
+			'label',
+			'value',
+			'type',
+		] );
+
+		if ( array_key_exists( 'label', $overrides ) ) {
+			$restored_variable['label'] = $overrides['label'];
+		}
+
+		if ( array_key_exists( 'value', $overrides ) ) {
+			$restored_variable['value'] = $overrides['value'];
+		}
+
+		$this->assert_if_variable_label_is_duplicated( $db_record, array_merge( $restored_variable, [ 'id' => $id ] ) );
+
+		$list_of_variables[ $id ] = $restored_variable;
+		$db_record['data'] = $list_of_variables;
+
+		$this->assert_if_variables_limit_reached( $db_record );
+
+		$watermark = $this->save( $db_record );
+
+		if ( false === $watermark ) {
+			throw new FatalError( 'Failed to restore variable' );
+		}
+
+		return [
+			'variable' => array_merge( [ 'id' => $id ], $restored_variable ),
+			'watermark' => $watermark,
+		];
+	}
+
+	/**
+	 * Process multiple operations atomically
+	 *
+	 * @throws BatchOperationFailed
+	 * @throws FatalError
+	 */
+	public function process_atomic_batch( array $operations, int $expected_watermark ): array {
+		$db_record = $this->load();
+		$results = [];
+		$errors = [];
+
+		foreach ( $operations as $index => $operation ) {
+			try {
+				$result = $this->process_single_operation( $db_record, $operation );
+				$results[] = $result;
+			} catch ( Exception $e ) {
+				$operation_id = $this->get_operation_identifier( $operation, $index );
+				$errors[ $operation_id ] = [
+					'status' => $this->get_error_status_code( $e ),
+					'message' => $e->getMessage(),
+				];
+			}
+		}
+
+		if ( ! empty( $errors ) ) {
+			$error_details = [];
+
+			foreach ( $errors as $operation_id => $error ) {
+				$error_details[ esc_html( $operation_id ) ] = [
+					'status' => (int) $error['status'],
+					'message' => esc_html( $error['message'] ),
+				];
+			}
+
+			// phpcs:ignore WordPress.Security.EscapeOutput.ExceptionNotEscaped
+			throw new BatchOperationFailed( 'Batch operation failed', $error_details );
+		}
+
+		$watermark = $this->save( $db_record );
+
+		if ( false === $watermark ) {
+			throw new FatalError( 'Failed to save batch operations' );
+		}
+
+		return [
+			'success' => true,
+			'watermark' => $watermark,
+			'results' => $results,
+		];
+	}
+
+	private function process_single_operation( array &$db_record, array $operation ): array {
+		switch ( $operation['type'] ) {
+			case 'create':
+				return $this->process_create_operation( $db_record, $operation );
+
+			case 'update':
+				return $this->process_update_operation( $db_record, $operation );
+
+			case 'delete':
+				return $this->process_delete_operation( $db_record, $operation );
+
+			case 'restore':
+				return $this->process_restore_operation( $db_record, $operation );
+
+			default:
+				throw new BatchOperationFailed( 'Invalid operation type: ' . esc_html( $operation['type'] ), [] );
+		}
+	}
+
+	private function process_create_operation( array &$db_record, array $operation ): array {
+		$variable_data = $operation['variable'];
+
+		$temp_id = $variable_data['id'] ?? null;
+		$new_variable = $this->extract_from( $variable_data, [ 'type', 'label', 'value' ] );
+
+		$this->assert_if_variable_label_is_duplicated( $db_record, $new_variable );
+
+		$this->assert_if_variables_limit_reached( $db_record );
+
+		$id = $this->new_id_for( $db_record['data'] );
+		$now = $this->now();
+
+		$new_variable['created_at'] = $now;
+		$new_variable['updated_at'] = $now;
+
+		$db_record['data'][ $id ] = $new_variable;
+
+		return [
+			'id' => $id,
+			'variable' => array_merge( [ 'id' => $id ], $new_variable ),
+			'temp_id' => $temp_id,
+		];
+	}
+
+	private function process_update_operation( array &$db_record, array $operation ): array {
+		$id = $operation['id'];
+		$variable_data = $operation['variable'];
+
+		if ( ! isset( $db_record['data'][ $id ] ) ) {
+			throw new \Elementor\Modules\Variables\Storage\Exceptions\RecordNotFound( 'Variable not found' );
+		}
+
+		$updated_fields = $this->extract_from( $variable_data, [ 'label', 'value' ] );
+		$updated_variable = array_merge( $db_record['data'][ $id ], $updated_fields );
+		$updated_variable['updated_at'] = $this->now();
+
+		$this->assert_if_variable_label_is_duplicated( $db_record, array_merge( $updated_variable, [ 'id' => $id ] ) );
+
+		$db_record['data'][ $id ] = $updated_variable;
+
+		return [
+			'id' => $id,
+			'variable' => array_merge( [ 'id' => $id ], $updated_variable ),
+		];
+	}
+
+	private function process_delete_operation( array &$db_record, array $operation ): array {
+		$id = $operation['id'];
+
+		if ( ! isset( $db_record['data'][ $id ] ) ) {
+			throw new RecordNotFound( 'Variable not found' );
+		}
+
+		$db_record['data'][ $id ]['deleted'] = true;
+		$db_record['data'][ $id ]['deleted_at'] = $this->now();
+
+		return [
+			'id' => $id,
+			'deleted' => true,
+		];
+	}
+
+	private function process_restore_operation( array &$db_record, array $operation ): array {
+		$id = $operation['id'];
+
+		if ( ! isset( $db_record['data'][ $id ] ) ) {
+			throw new RecordNotFound( 'Variable not found' );
+		}
+
+		$overrides = [];
+
+		if ( isset( $operation['label'] ) ) {
+			$overrides['label'] = $operation['label'];
+		}
+
+		if ( isset( $operation['value'] ) ) {
+			$overrides['value'] = $operation['value'];
+		}
+
+		$restored_variable = $this->extract_from( $db_record['data'][ $id ], [ 'label', 'value', 'type' ] );
+		$restored_variable = array_merge( $restored_variable, $overrides );
+		$restored_variable['updated_at'] = $this->now();
+
+		$this->assert_if_variable_label_is_duplicated( $db_record, array_merge( $restored_variable, [ 'id' => $id ] ) );
+
+		$this->assert_if_variables_limit_reached( $db_record );
+
+		$db_record['data'][ $id ] = $restored_variable;
+
+		return [
+			'id' => $id,
+			'variable' => array_merge( [ 'id' => $id ], $restored_variable ),
+		];
+	}
+
+	private function get_operation_identifier( array $operation, int $index ): string {
+		if ( 'create' === $operation['type'] && isset( $operation['variable']['id'] ) ) {
+			return $operation['variable']['id'];
+		}
+
+		if ( isset( $operation['id'] ) ) {
+			return $operation['id'];
+		}
+
+		return "operation_{$index}";
+	}
+
+	private function get_error_status_code( Exception $e ): int {
+		if ( $e instanceof RecordNotFound ) {
+			return 404;
+		}
+
+		if ( $e instanceof DuplicatedLabel ||
+			 $e instanceof VariablesLimitReached ) {
+			return 400;
+		}
+
+		return 500;
+	}
+
+	private function save( array $db_record ) {
+		if ( PHP_INT_MAX === $db_record['watermark'] ) {
+			$db_record['watermark'] = 0;
+		}
+
+		++$db_record['watermark'];
+
+		if ( $this->kit->update_json_meta( static::VARIABLES_META_KEY, $db_record ) ) {
+			return $db_record['watermark'];
+		}
+
+		return false;
+	}
+
+	private function new_id_for( array $list_of_variables ): string {
+		return Utils::generate_id( 'e-gv-', array_keys( $list_of_variables ) );
+	}
+
+	private function now(): string {
+		return gmdate( 'Y-m-d H:i:s' );
+	}
+
+	private function extract_from( array $source, array $fields ): array {
+		return array_intersect_key( $source, array_flip( $fields ) );
+	}
+
+	private function get_default_meta(): array {
+		return [
+			'data' => [],
+			'watermark' => 0,
+			'version' => self::FORMAT_VERSION_V1,
+		];
+	}
+}

wp-content/plugins/elementor/modules/variables/transformers/global-variable-transformer.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Elementor\Modules\Variables\Transformers;
+
+use Elementor\Modules\Variables\Classes\Variables;
+use Elementor\Modules\AtomicWidgets\PropsResolver\Transformer_Base;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Global_Variable_Transformer extends Transformer_Base {
+	public function transform( $value, $key ) {
+		$variable = Variables::by_id( $value );
+
+		if ( ! $variable ) {
+			return null;
+		}
+
+		if ( array_key_exists( 'deleted', $variable ) && $variable['deleted'] ) {
+			return "var(--{$value})";
+		}
+
+		$identifier = $variable['label'];
+
+		if ( ! trim( $identifier ) ) {
+			return null;
+		}
+
+		return "var(--{$identifier})";
+	}
+}