Project-Pro/carei.pagedev.pl
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
Roman Pyrih
2026-03-10 09:50:10 +01:00
commit 64c4a90405
7289 changed files with 2645777 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
wp-content/plugins/elementor/modules/variables/adapters/prop-type-adapter.php Normal file
View File

@@ -0,0 +1,128 @@
<?php
namespace Elementor\Modules\Variables\Adapters;
use Elementor\Modules\AtomicWidgets\PropTypes\Color_Prop_Type;
use Elementor\Modules\AtomicWidgets\PropTypes\Primitives\String_Prop_Type;
use Elementor\Modules\AtomicWidgets\PropTypes\Size_Prop_Type;
use Elementor\Modules\AtomicWidgets\Styles\Size_Constants;
use Elementor\Modules\Variables\PropTypes\Color_Variable_Prop_Type;
use Elementor\Modules\Variables\PropTypes\Font_Variable_Prop_Type;
use Elementor\Modules\Variables\PropTypes\Size_Variable_Prop_Type;
use Elementor\Modules\Variables\Storage\Entities\Variable;
use Elementor\Modules\Variables\Storage\Variables_Collection;
class Prop_Type_Adapter {
public const GLOBAL_CUSTOM_SIZE_VARIABLE_KEY = 'global-custom-size-variable';
public static function to_storage( Variables_Collection $collection ): array {
$schema = self::get_schema();
$collection->set_version( Variables_Collection::FORMAT_VERSION_V2 );
$record = $collection->serialize();
$collection->each( function( Variable $variable ) use ( $schema, &$record ) {
$type = $variable->type();
$value = $variable->value();
$id = $variable->id();
$variable = $variable->to_array();
$prop_type = $schema[ $type ] ?? null;
if ( is_array( $value ) || ! $prop_type ) {
return;
}
if ( Size_Variable_Prop_Type::get_key() === $type ) {
$value = self::parse_size_value( $value );
}
if ( self::GLOBAL_CUSTOM_SIZE_VARIABLE_KEY === $type ) {
$value = [
'size' => $value,
'unit' => 'custom',
];
$variable['type'] = Size_Variable_Prop_Type::get_key();
}
$record['data'][ $id ] = array_merge( $variable, [ 'value' => $prop_type::generate( $value ) ] );
} );
return $record;
}
public static function from_storage( Variables_Collection $collection ): Variables_Collection {
$collection->each( function( Variable $variable ) {
$value = $variable->value();
if ( ! is_array( $value ) ) {
return;
}
$value = $value['value'];
if ( isset( $value['unit'] ) && 'custom' === $value['unit'] ) {
$value = $value['size'];
$variable->set_type( self::GLOBAL_CUSTOM_SIZE_VARIABLE_KEY );
}
if ( Size_Variable_Prop_Type::get_key() === $variable->type() ) {
if ( ! is_array( $value ) ) {
$value = [
'size' => '',
'unit' => Size_Constants::DEFAULT_UNIT,
];
}
$value['size'] = $value['size'] ?? '';
$value['unit'] = empty( $value['unit'] ) ? Size_Constants::DEFAULT_UNIT : $value['unit'];
$value = $value['size'] . $value['unit'];
}
$variable->set_value( $value );
} );
$collection->set_version( Variables_Collection::FORMAT_VERSION_V1 );
return $collection;
}
private static function get_schema(): array {
return [
Color_Variable_Prop_Type::get_key() => Color_Prop_Type::class,
Font_Variable_Prop_Type::get_key() => String_Prop_Type::class,
Size_Variable_Prop_Type::get_key() => Size_Prop_Type::class,
self::GLOBAL_CUSTOM_SIZE_VARIABLE_KEY => Size_Prop_Type::class,
];
}
private static function parse_size_value( ?string $value ) {
$value = trim( strtolower( $value ) );
if ( 'auto' === $value ) {
return [
'size' => '',
'unit' => 'auto',
];
}
if ( preg_match( '/^(-?\d*\.?\d+)([a-z%]+)$/i', trim( $value ), $matches ) ) {
return [
'size' => $matches[1] + 0,
'unit' => strtolower( $matches[2] ),
];
}
if ( empty( $value ) ) {
return [
'size' => '',
'unit' => Size_Constants::DEFAULT_UNIT,
];
}
return $value;
}
}

73
wp-content/plugins/elementor/modules/variables/classes/css-renderer.php Normal file
View File

@@ -0,0 +1,73 @@
<?php
namespace Elementor\Modules\Variables\Classes;
use Elementor\Modules\Variables\Services\Variables_Service;
if ( ! defined( 'ABSPATH' ) ) {
exit; // Exit if accessed directly.
}
class CSS_Renderer {
private Variables_Service $service;
public function __construct( Variables_Service $service ) {
$this->service = $service;
}
private function global_variables(): array {
return $this->service->get_variables_list();
}
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_at', $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 ) . ' }';
}
}

44
wp-content/plugins/elementor/modules/variables/classes/fonts.php Normal file
View File

@@ -0,0 +1,44 @@
<?php
namespace Elementor\Modules\Variables\Classes;
use Elementor\Modules\Variables\Services\Variables_Service;
use Elementor\Plugin;
use Elementor\Core\Files\CSS\Post as Post_CSS;
use Elementor\Modules\Variables\PropTypes\Font_Variable_Prop_Type;
if ( ! defined( 'ABSPATH' ) ) {
exit; // Exit if accessed directly.
}
class Fonts {
private Variables_Service $service;
public function __construct( Variables_Service $service ) {
$this->service = $service;
}
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->service->get_variables_list();
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;
}
}

617
wp-content/plugins/elementor/modules/variables/classes/rest-api.php Normal file
View File

@@ -0,0 +1,617 @@
<?php
namespace Elementor\Modules\Variables\Classes;
use Elementor\Modules\Variables\Storage\Exceptions\Type_Mismatch;
use WP_Error;
use Exception;
use WP_REST_Server;
use WP_REST_Request;
use Elementor\Plugin;
use WP_REST_Response;
use Elementor\Modules\Variables\Services\Variables_Service;
use Elementor\Modules\Variables\Module as Variables_Module;
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_Service $service;
public function __construct( Variables_Service $service ) {
$this->service = $service;
}
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' ],
],
'order' => [
'required' => false,
'type' => 'integer',
'validate_callback' => [ $this, 'is_valid_order' ],
],
'type' => [
'required' => false,
'type' => 'string',
'validate_callback' => [ $this, 'is_valid_variable_type' ],
'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' ],
],
'type' => [
'required' => false,
'type' => 'string',
'validate_callback' => [ $this, 'is_valid_variable_type' ],
'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_order( $order ) {
if ( ! is_numeric( $order ) || $order < 0 ) {
return new WP_Error(
'invalid_order',
__( 'Order must be a non-negative integer', 'elementor' )
);
}
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->service->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' );
$order = $request->get_param( 'order' );
$type = $request->get_param( 'type' );
$update_data = [
'label' => $label,
'value' => $value,
];
if ( $type ) {
$update_data['type'] = $type;
}
if ( null !== $order ) {
$update_data['order'] = $order;
}
$result = $this->service->update( $id, $update_data );
$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->service->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;
}
$type = $request->get_param( 'type' );
if ( $type ) {
$overrides['type'] = $type;
}
$result = $this->service->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->service->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' )
);
}
if ( $e instanceof Type_Mismatch ) {
return $this->prepare_error_response(
self::HTTP_BAD_REQUEST,
'type_mismatch',
$e->getMessage()
);
}
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'] ) ) {
$sanitized_index = absint( $index );
return new WP_Error(
'invalid_operation_structure',
sprintf(
/* translators: %d: operation index */
__( 'Invalid operation structure at index %d', 'elementor' ),
$sanitized_index
)
);
}
$allowed_types = [ 'create', 'update', 'delete', 'restore', 'reorder' ];
if ( ! in_array( $operation['type'], $allowed_types, true ) ) {
$sanitized_index = absint( $index );
return new WP_Error(
'invalid_operation_type',
sprintf(
/* translators: %d: operation index */
__( 'Invalid operation type at index %d', 'elementor' ),
$sanitized_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 ) {
$operations = $request->get_param( 'operations' );
$result = $this->service->process_batch( $operations );
$this->clear_cache();
return $this->success_response( $result );
}
private function batch_error_response( Exception $e ) {
if ( $e instanceof BatchOperationFailed ) {
$error_details = $e->getErrorDetails();
$batch_error_context = $this->determine_batch_error_context( $error_details );
return new WP_REST_Response( [
'success' => false,
'code' => $batch_error_context['code'],
'message' => $batch_error_context['message'],
'data' => $batch_error_context['filtered_errors'],
], self::HTTP_BAD_REQUEST );
}
return $this->error_response( $e );
}
private function determine_batch_error_context( array $error_details ) {
$error_config = [
'invalid_variable_limit_reached' => [
'batch_code' => 'batch_variables_limit_reached',
'batch_message' => __( 'Batch operation failed: Reached the maximum number of variables', 'elementor' ),
'status' => self::HTTP_BAD_REQUEST,
'message' => __( 'Reached the maximum number of variables', 'elementor' ),
],
'duplicated_label' => [
'batch_code' => 'batch_duplicated_label',
'batch_message' => __( 'Batch operation failed: Variable labels already exist', 'elementor' ),
'status' => self::HTTP_BAD_REQUEST,
'message' => __( 'Variable label already exists', 'elementor' ),
],
'variable_not_found' => [
'batch_code' => 'batch_variables_not_found',
'batch_message' => __( 'Batch operation failed: Variables not found', 'elementor' ),
'status' => self::HTTP_NOT_FOUND,
'message' => __( 'Variable not found', 'elementor' ),
],
];
$grouped_errors = [];
foreach ( $error_details as $id => $error_detail ) {
$error_code = $error_detail['code'] ?? '';
if ( isset( $error_config[ $error_code ] ) ) {
$config = $error_config[ $error_code ];
$grouped_errors[ $error_code ][ $id ] = [
'status' => $config['status'],
'message' => $config['message'],
];
} else {
$grouped_errors['unknown'][ $id ] = [
'status' => self::HTTP_SERVER_ERROR,
'message' => $error_detail['message'] ?? __( 'Unexpected error', 'elementor' ),
];
}
}
foreach ( $error_config as $error_code => $config ) {
if ( ! empty( $grouped_errors[ $error_code ] ) ) {
return [
'code' => $config['batch_code'],
'message' => $config['batch_message'],
'filtered_errors' => $grouped_errors[ $error_code ],
];
}
}
return [
'code' => 'batch_operation_failed',
'message' => __( 'Batch operation failed', 'elementor' ),
'filtered_errors' => $grouped_errors['unknown'] ?? [],
];
}
}

94
wp-content/plugins/elementor/modules/variables/classes/size-style-schema.php Normal file
View File

@@ -0,0 +1,94 @@
<?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\Size_Prop_Type;
use Elementor\Modules\AtomicWidgets\PropTypes\Union_Prop_Type;
use Elementor\Modules\Variables\PropTypes\Size_Variable_Prop_Type;
if ( ! defined( 'ABSPATH' ) ) {
exit; // Exit if accessed directly.
}
class Size_Style_Schema {
private $blacklist = [
'box-shadow',
'filter',
'backdrop-filter',
'transform',
'transition',
];
private function ignore( $css_property ): bool {
if ( in_array( $css_property, $this->blacklist, true ) ) {
return true;
}
return false;
}
public function augment( array $schema ): array {
foreach ( $schema as $css_property => $prop_type ) {
if ( $this->ignore( $css_property ) ) {
continue;
}
$schema[ $css_property ] = $this->update( $prop_type );
}
return $schema;
}
private function update( $prop_type ) {
if ( $prop_type instanceof Size_Prop_Type ) {
return $this->update_size( $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_size( Size_Prop_Type $size_prop_type ): Union_Prop_Type {
return Union_Prop_Type::create_from( $size_prop_type )
->add_prop_type( Size_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 {
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 ) {
$union_prop_type->add_prop_type( $updated_prop_type );
}
}
}
return $union_prop_type;
}
}

100
wp-content/plugins/elementor/modules/variables/classes/style-schema.php Normal file
View File

@@ -0,0 +1,100 @@
<?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 ( method_exists( $prop_type, 'get_meta' ) && method_exists( $schema[ $key ], 'meta' ) ) {
$meta = $schema[ $key ]->get_meta() ?? [];
foreach ( $meta as $meta_key => $meta_value ) {
$schema[ $key ]->meta( $meta_key, $meta_value );
}
}
}
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( $prop_type ): Union_Prop_Type {
if ( $prop_type instanceof String_Prop_Type ) {
return Union_Prop_Type::create_from( $prop_type )
->add_prop_type( Font_Variable_Prop_Type::make() );
}
if ( $prop_type instanceof Union_Prop_Type ) {
$prop_type->add_prop_type( Font_Variable_Prop_Type::make() );
}
return $prop_type;
}
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 {
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 ) {
$union_prop_type->add_prop_type( $updated_prop_type );
}
}
}
return $union_prop_type;
}
}

23
wp-content/plugins/elementor/modules/variables/classes/style-transformers.php Normal file
View File

@@ -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;
}
}

26
wp-content/plugins/elementor/modules/variables/classes/variable-types-registry.php Normal file
View File

@@ -0,0 +1,26 @@
<?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 {
$this->types[ $key ] = $prop_type;
}
public function get( $key ) {
return $this->types[ $key ] ?? null;
}
public function all(): array {
return $this->types;
}
}

22
wp-content/plugins/elementor/modules/variables/classes/variables.php Normal file
View File

@@ -0,0 +1,22 @@
<?php
namespace Elementor\Modules\Variables\Classes;
use Elementor\Modules\Variables\Services\Variables_Service;
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_Service $service ) {
self::$lookup = $service->get_variables_list();
}
public static function by_id( string $id ) {
return self::$lookup[ $id ] ?? null;
}
}

133
wp-content/plugins/elementor/modules/variables/hooks.php Normal file
View File

@@ -0,0 +1,133 @@
<?php
namespace Elementor\Modules\Variables;
use Elementor\Modules\Variables\Adapters\Prop_Type_Adapter;
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\Modules\Variables\PropTypes\Size_Variable_Prop_Type;
use Elementor\Modules\Variables\Services\Batch_Operations\Batch_Processor;
use Elementor\Modules\Variables\Services\Variables_Service;
use Elementor\Modules\Variables\Storage\Variables_Repository;
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\Classes\Style_Schema;
use Elementor\Modules\Variables\Classes\Size_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_css_renderer()
->register_packages()
->register_fonts()
->register_api_endpoints()
->filter_for_style_schema()
->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() );
$registry->register( Prop_Type_Adapter::GLOBAL_CUSTOM_SIZE_VARIABLE_KEY, new Size_Variable_Prop_Type() );
$registry->register( Size_Variable_Prop_Type::get_key(), new Size_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_service() );
( 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 );
} );
add_filter( 'elementor/atomic-widgets/styles/schema', function ( array $schema ) {
return ( new Size_Style_Schema() )->augment( $schema );
} );
return $this;
}
private function css_renderer() {
return new Variables_CSS_Renderer( $this->variables_service() );
}
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_service() );
}
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_service() );
}
private function register_api_endpoints() {
add_action( 'rest_api_init', function () {
$this->rest_api()->register_routes();
} );
return $this;
}
private function variables_service() {
$repository = new Variables_Repository(
Plugin::$instance->kits_manager->get_active_kit()
);
return new Variables_Service( $repository, new Batch_Processor() );
}
}

101
wp-content/plugins/elementor/modules/variables/module.php Normal file
View File

@@ -0,0 +1,101 @@
<?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\Modules\Variables\PropTypes\Color_Variable_Prop_Type;
use Elementor\Modules\Variables\PropTypes\Font_Variable_Prop_Type;
use Elementor\Modules\Variables\PropTypes\Size_Variable_Prop_Type;
use Elementor\Plugin;
use Elementor\Utils;
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' ] );
add_action( 'elementor/editor/before_enqueue_scripts', fn () => $this->enqueue_editor_scripts() );
}
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_ACTIVE,
'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;
}
private function get_quota_config(): array {
return [
Color_Variable_Prop_Type::get_key() => 100000,
Font_Variable_Prop_Type::get_key() => 100000,
];
}
public function enqueue_editor_scripts() {
wp_add_inline_script(
'elementor-common',
'window.ElementorVariablesQuotaConfig = ' . wp_json_encode( $this->get_quota_config() ) . ';',
'before'
);
}
}

15
wp-content/plugins/elementor/modules/variables/prop-types/color-variable-prop-type.php Normal file
View File

@@ -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';
}
}

15
wp-content/plugins/elementor/modules/variables/prop-types/font-variable-prop-type.php Normal file
View File

@@ -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';
}
}

15
wp-content/plugins/elementor/modules/variables/prop-types/size-variable-prop-type.php Normal file
View File

@@ -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 Size_Variable_Prop_Type extends String_Prop_Type {
public static function get_key(): string {
return 'global-size-variable';
}
}

46
wp-content/plugins/elementor/modules/variables/services/batch-operations/batch-error-formatter.php Normal file
View File

@@ -0,0 +1,46 @@
<?php
namespace Elementor\Modules\Variables\Services\Batch_Operations;
use Exception;
use Elementor\Modules\Variables\Storage\Exceptions\DuplicatedLabel;
use Elementor\Modules\Variables\Storage\Exceptions\RecordNotFound;
use Elementor\Modules\Variables\Storage\Exceptions\VariablesLimitReached;
class Batch_Error_Formatter {
private const ERROR_MAP = [
RecordNotFound::class => [
'code' => 'variable_not_found',
'status' => 404,
],
DuplicatedLabel::class => [
'code' => 'duplicated_label',
'status' => 400,
],
VariablesLimitReached::class => [
'code' => 'invalid_variable_limit_reached',
'status' => 400,
],
];
public function status_for( Exception $e ): int {
foreach ( self::ERROR_MAP as $class => $map ) {
if ( $e instanceof $class ) {
return $map['status'];
}
}
return 500;
}
public function error_code_for( Exception $e ): string {
foreach ( self::ERROR_MAP as $class => $map ) {
if ( $e instanceof $class ) {
return $map['code'];
}
}
return 'unexpected_server_error';
}
}

121
wp-content/plugins/elementor/modules/variables/services/batch-operations/batch-processor.php Normal file
View File

@@ -0,0 +1,121 @@
<?php
namespace Elementor\Modules\Variables\Services\Batch_Operations;
use Elementor\Modules\Variables\Storage\Entities\Variable;
use Elementor\Modules\Variables\Storage\Variables_Collection;
use Elementor\Modules\Variables\Storage\Exceptions\BatchOperationFailed;
class Batch_Processor {
private const OPERATION_MAP = [
'create' => 'op_create',
'update' => 'op_update',
'delete' => 'op_delete',
'restore' => 'op_restore',
];
/**
* @throws BatchOperationFailed Invalid operation type.
*/
public function apply_operation( Variables_Collection $collection, array $operation ): array {
$type = $operation['type'];
if ( ! isset( self::OPERATION_MAP[ $type ] ) ) {
throw new BatchOperationFailed( 'Invalid operation type: ' . esc_html( $type ), [] );
}
$method = self::OPERATION_MAP[ $type ];
return $this->$method( $collection, $operation );
}
private function op_create( Variables_Collection $collection, array $operation ): array {
$data = $operation['variable'];
$temp_id = $data['id'] ?? null;
$data['id'] = $collection->next_id();
$collection->assert_limit_not_reached();
$collection->assert_label_is_unique( $data['label'] );
if ( ! isset( $data['order'] ) ) {
$data['order'] = $collection->get_next_order();
}
$variable = Variable::create_new( $data );
$collection->add_variable( $variable );
// TODO: do we need to return all this payload maybe return what the clients want
return [
'type' => 'create',
'id' => $data['id'],
'temp_id' => $temp_id,
'variable' => $variable->to_array(),
];
}
private function op_update( Variables_Collection $collection, array $operation ): array {
$id = $operation['id'];
$data = $operation['variable'];
$variable = $collection->find_or_fail( $id );
if ( isset( $data['label'] ) ) {
$collection->assert_label_is_unique( $data['label'], $id );
}
$variable->apply_changes( $data );
return [
'type' => 'update',
'id' => $id,
'variable' => $variable->to_array(),
];
}
private function op_delete( Variables_Collection $collection, array $operation ): array {
$id = $operation['id'];
$variable = $collection->find_or_fail( $id );
$variable->soft_delete();
return [
'type' => 'delete',
'id' => $id,
'deleted' => true,
];
}
private function op_restore( Variables_Collection $collection, array $operation ): array {
$id = $operation['id'];
$variable = $collection->find_or_fail( $id );
$collection->assert_limit_not_reached();
if ( isset( $operation['label'] ) ) {
$collection->assert_label_is_unique( $operation['label'], $id );
}
$variable->apply_changes( $operation );
$variable->restore();
return [
'type' => 'restore',
'id' => $id,
'variable' => $variable->to_array(),
];
}
public function operation_id( 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}";
}
}

189
wp-content/plugins/elementor/modules/variables/services/variables-service.php Normal file
View File

@@ -0,0 +1,189 @@
<?php
namespace Elementor\Modules\Variables\Services;
use Elementor\Modules\Variables\Services\Batch_Operations\Batch_Error_Formatter;
use Elementor\Modules\Variables\Services\Batch_Operations\Batch_Processor;
use Elementor\Modules\Variables\Storage\Entities\Variable;
use Elementor\Modules\Variables\Storage\Exceptions\BatchOperationFailed;
use Elementor\Modules\Variables\Storage\Variables_Repository;
use Elementor\Modules\Variables\Storage\Exceptions\FatalError;
use Elementor\Modules\Variables\PropTypes\Size_Variable_Prop_Type;
use Elementor\Utils as ElementorUtils;
class Variables_Service {
private Variables_Repository $repo;
private Batch_Processor $batch_processor;
public function __construct( Variables_Repository $repository, Batch_Processor $batch_processor ) {
$this->repo = $repository;
$this->batch_processor = $batch_processor;
}
public function get_variables_list(): array {
return $this->load()['data'];
}
public function load() {
$collection = $this->repo->load()->serialize( true );
foreach ( $collection['data'] as $id => $variable ) {
if ( ! ElementorUtils::has_pro() && Size_Variable_Prop_Type::get_key() === $variable['type'] ) {
unset( $collection['data'][ $id ] );
}
}
return $collection;
}
/**
* @throws BatchOperationFailed Thrown when one of the operations fails.
* @throws FatalError Failed to save after batch.
*/
public function process_batch( array $operations ) {
$collection = $this->repo->load();
$results = [];
$errors = [];
$error_formatter = new Batch_Error_Formatter();
foreach ( $operations as $index => $operation ) {
try {
$results[] = $this->batch_processor->apply_operation( $collection, $operation );
} catch ( \Exception $e ) {
$errors[ $this->batch_processor->operation_id( $operation, $index ) ] = [
'status' => $error_formatter->status_for( $e ),
'code' => $error_formatter->error_code_for( $e ),
'message' => $e->getMessage(),
];
}
}
if ( ! empty( $errors ) ) {
// phpcs:ignore WordPress.Security.EscapeOutput.ExceptionNotEscaped
throw new BatchOperationFailed( 'Batch failed', $errors );
}
$watermark = $this->repo->save( $collection );
if ( false === $watermark ) {
throw new FatalError( 'Failed to save batch operations' );
}
return [
'success' => true,
'results' => $results,
'watermark' => $watermark,
];
}
/**
* @throws FatalError If variable create fails or validation errors occur.
*/
public function create( array $data ): array {
$collection = $this->repo->load();
$collection->assert_limit_not_reached();
$collection->assert_label_is_unique( $data['label'] );
$id = $collection->next_id();
$data['id'] = $id;
// TODO: we need to look into this maybe we dont need order to be sent from client. Just implemented as it was
if ( ! isset( $data['order'] ) ) {
$data['order'] = $collection->get_next_order();
}
$variable = Variable::from_array( $data );
$collection->add_variable( $variable );
$watermark = $this->repo->save( $collection );
if ( false === $watermark ) {
throw new FatalError( 'Failed to create variable' );
}
return [
'variable' => array_merge( [ 'id' => $id ], $variable->to_array() ),
'watermark' => $collection->watermark(),
];
}
/**
* @throws FatalError If variable update fails.
*/
public function update( string $id, array $data ): array {
$collection = $this->repo->load();
$variable = $collection->find_or_fail( $id );
if ( isset( $data['label'] ) ) {
$collection->assert_label_is_unique( $data['label'], $id );
}
$variable->apply_changes( $data );
$watermark = $this->repo->save( $collection );
if ( false === $watermark ) {
throw new FatalError( 'Failed to update variable' );
}
return [
'variable' => array_merge( [ 'id' => $id ], $variable->to_array() ),
'watermark' => $watermark,
];
}
/**
* @throws FatalError If variable delete fails.
*/
public function delete( string $id ) {
$collection = $this->repo->load();
$variable = $collection->find_or_fail( $id );
$variable->soft_delete();
$watermark = $this->repo->save( $collection );
if ( false === $watermark ) {
throw new FatalError( 'Failed to delete variable' );
}
return [
'watermark' => $watermark,
'variable' => array_merge( [
'id' => $id,
'deleted' => true,
], $variable->to_array() ),
];
}
/**
* @throws FatalError If variable restore fails.
*/
public function restore( string $id, $overrides = [] ) {
$collection = $this->repo->load();
$variable = $collection->find_or_fail( $id );
$collection->assert_limit_not_reached();
if ( isset( $overrides['label'] ) ) {
$collection->assert_label_is_unique( $overrides['label'], $variable->id() );
}
$variable->apply_changes( $overrides );
$variable->restore();
$watermark = $this->repo->save( $collection );
if ( false === $watermark ) {
throw new FatalError( 'Failed to delete variable' );
}
return [
'variable' => array_merge( [ 'id' => $id ], $variable->to_array() ),
'watermark' => $watermark,
];
}
}

149
wp-content/plugins/elementor/modules/variables/storage/entities/variable.php Normal file
View File

@@ -0,0 +1,149 @@
<?php
namespace Elementor\Modules\Variables\Storage\Entities;
use Elementor\Modules\Variables\Adapters\Prop_Type_Adapter;
use Elementor\Modules\Variables\PropTypes\Size_Variable_Prop_Type;
use Elementor\Modules\Variables\Storage\Exceptions\Type_Mismatch;
use InvalidArgumentException;
class Variable {
private array $data;
private function __construct( array $data ) {
$this->data = $data;
}
public static function create_new( array $data ): self {
$now = gmdate( 'Y-m-d H:i:s' );
$data['created_at'] = $now;
$data['updated_at'] = $now;
return self::from_array( $data );
}
public static function from_array( array $data ): self {
$required = [ 'id', 'type', 'label', 'value' ];
foreach ( $required as $key ) {
if ( ! array_key_exists( $key, $data ) ) {
throw new InvalidArgumentException(
sprintf(
"Missing required field '%s' in %s::from_array()",
esc_html( $key ),
self::class
)
);
}
}
return new self( $data );
}
public function soft_delete(): void {
$this->data['deleted_at'] = $this->now();
}
public function restore(): void {
unset( $this->data['deleted_at'] );
// TODO to be removed if client is no longer need this
unset( $this->data['deleted'] );
$this->data['updated_at'] = $this->now();
}
private function now() {
return gmdate( 'Y-m-d H:i:s' );
}
public function to_array(): array {
return array_diff_key( $this->data, array_flip( [ 'id' ] ) );
}
public function id(): string {
return $this->data['id'];
}
public function label(): string {
return $this->data['label'];
}
public function order(): int {
return $this->data['order'];
}
public function value() {
return $this->data['value'];
}
public function set_value( $value ) {
$this->data['value'] = $value;
}
public function type() {
return $this->data['type'];
}
public function set_type( $type ) {
$this->data['type'] = $type;
}
public function has_order(): int {
return isset( $this->data['order'] );
}
public function is_deleted(): bool {
return isset( $this->data['deleted_at'] );
}
/**
* @throws Type_Mismatch If a type that is not allowed to be changed is passed.
*/
private function maybe_apply_type( array $data ) {
if ( ! array_key_exists( 'type', $data ) ) {
return false;
}
$current_type = $this->type();
$target_type = $data['type'];
if ( $current_type === $target_type ) {
return false;
}
$custom_size_prop_type = Prop_Type_Adapter::GLOBAL_CUSTOM_SIZE_VARIABLE_KEY;
$size_prop_type = Size_Variable_Prop_Type::get_key();
$allowed_types = [ $custom_size_prop_type, $size_prop_type ];
$is_valid_transition =
in_array( $current_type, $allowed_types, true ) &&
in_array( $target_type, $allowed_types, true );
if ( ! $is_valid_transition ) {
throw new Type_Mismatch( 'Type change is forbidden' );
}
$this->set_type( $data['type'] );
return true;
}
public function apply_changes( array $data ): void {
$allowed_fields = [ 'label', 'value', 'order', 'type' ];
$has_changes = $this->maybe_apply_type( $data );
foreach ( $allowed_fields as $field ) {
if ( isset( $data[ $field ] ) ) {
$this->data[ $field ] = $data[ $field ];
$has_changes = true;
}
}
if ( $has_changes ) {
$this->data['updated_at'] = $this->now();
}
}
}

20
wp-content/plugins/elementor/modules/variables/storage/exceptions/batch-operation-failed.php Normal file
View File

@@ -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;
}
}

11
wp-content/plugins/elementor/modules/variables/storage/exceptions/duplicated-label.php Normal file
View File

@@ -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 {}

11
wp-content/plugins/elementor/modules/variables/storage/exceptions/fatal-error.php Normal file
View File

@@ -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 {}

11
wp-content/plugins/elementor/modules/variables/storage/exceptions/record-not-found.php Normal file
View File

@@ -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 {}

11
wp-content/plugins/elementor/modules/variables/storage/exceptions/type-mismatch.php Normal file
View File

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

11
wp-content/plugins/elementor/modules/variables/storage/exceptions/variables-limit-reached.php Normal file
View File

@@ -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 {}

504
wp-content/plugins/elementor/modules/variables/storage/repository.php Normal file
View File

@@ -0,0 +1,504 @@
<?php
namespace Elementor\Modules\Variables\Storage;
use Elementor\Core\Kits\Documents\Kit;
use Elementor\Modules\AtomicWidgets\Utils\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 {
// TODO: deleted this class later after this PR
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 If database connection fails or query execution errors occur.
*/
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 If variable creation fails or validation errors occur.
*/
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 If variable update fails or validation errors occur.
*/
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',
'order',
] );
if ( ! isset( $new_variable['order'] ) ) {
$new_variable['order'] = $this->get_next_order( $list_of_variables );
}
$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 If variable deletion fails or database errors occur.
* @throws FatalError If variable deletion fails or database errors occur.
*/
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',
'order',
] ) );
$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 If bulk operation fails or validation errors occur.
* @throws FatalError If bulk operation fails or validation errors occur.
*/
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 If export operation fails or data serialization errors occur.
* @throws FatalError If export operation fails or data serialization errors occur.
*/
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',
'order',
] );
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 If batch operation fails or validation errors occur.
* @throws FatalError If batch operation fails or validation errors occur.
*/
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 ),
'code' => $this->get_error_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'],
'code' => $error['code'],
'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', 'order' ] );
if ( ! isset( $new_variable['order'] ) ) {
$new_variable['order'] = $this->get_next_order( $db_record['data'] );
}
$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,
'type' => 'create',
'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 RecordNotFound( 'Variable not found' );
}
$updated_fields = $this->extract_from( $variable_data, [ 'label', 'value', 'order' ] );
$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,
'type' => 'update',
'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,
'type' => 'delete',
'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,
'type' => 'restore',
'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 get_error_code( Exception $e ): string {
if ( $e instanceof VariablesLimitReached ) {
return 'invalid_variable_limit_reached';
}
if ( $e instanceof DuplicatedLabel ) {
return 'duplicated_label';
}
if ( $e instanceof RecordNotFound ) {
return 'variable_not_found';
}
return 'unexpected_server_error';
}
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,
];
}
private function get_next_order( array $list_of_variables ): int {
$highest_order = 0;
foreach ( $list_of_variables as $variable ) {
if ( isset( $variable['deleted'] ) && $variable['deleted'] ) {
continue;
}
if ( isset( $variable['order'] ) && $variable['order'] > $highest_order ) {
$highest_order = $variable['order'];
}
}
return $highest_order + 1;
}
}

172
wp-content/plugins/elementor/modules/variables/storage/variables-collection.php Normal file
View File

@@ -0,0 +1,172 @@
<?php
namespace Elementor\Modules\Variables\Storage;
use Elementor\Core\Utils\Collection;
use Elementor\Modules\AtomicWidgets\Utils\Utils;
use Elementor\Modules\Variables\Storage\Entities\Variable;
use Elementor\Modules\Variables\Storage\Exceptions\DuplicatedLabel;
use Elementor\Modules\Variables\Storage\Exceptions\RecordNotFound;
use Elementor\Modules\Variables\Storage\Exceptions\VariablesLimitReached;
/**
* TODO: a tradeoff when you want to use collection base methods they are
* performing immutable process ( creating new instances )
* we will see if we need to extend collection as time goes on
*/
class Variables_Collection extends Collection {
const FORMAT_VERSION_V1 = 1;
const FORMAT_VERSION_V2 = 2;
const TOTAL_VARIABLES_COUNT = 100;
private int $watermark;
private int $version;
private function __construct( array $items = [], ?int $watermark = 0, ?int $version = null ) {
parent::__construct();
$this->items = $items;
$this->watermark = $watermark;
$this->version = $version ?? self::FORMAT_VERSION_V1;
}
public static function hydrate( array $record ): self {
$variables = [];
foreach ( $record['data'] ?? [] as $id => $item ) {
$data = array_merge( [ 'id' => $id ], $item );
$variables[ $id ] = Variable::from_array( $data );
}
$watermark = $record['watermark'];
$version = $record['version'] ?? null;
return new self( $variables, $watermark, $version );
}
public function serialize( bool $include_deleted_key = false ): array {
$data = [];
foreach ( $this->all() as $variable ) {
$var = $variable->to_array();
if ( $include_deleted_key && $variable->is_deleted() ) {
$var['deleted'] = true;
}
$data[ $variable->id() ] = $var;
}
return [
'data' => $data,
'watermark' => $this->watermark,
'version' => $this->version,
];
}
public function set_version( $version ): void {
$this->version = $version;
}
public static function default(): self {
return new self(
[],
0,
self::FORMAT_VERSION_V1
);
}
public function watermark(): int {
return $this->watermark;
}
private function reset_watermark() {
$this->watermark = 0;
}
public function increment_watermark() {
if ( PHP_INT_MAX === $this->watermark ) {
$this->reset_watermark();
}
++$this->watermark;
}
public function add_variable( Variable $variable ): void {
$this->items[ $variable->id() ] = $variable;
}
/**
* @throws RecordNotFound When a variable is not found.
*/
public function find_or_fail( string $id ): Variable {
$variable = $this->get( $id );
if ( ! isset( $variable ) ) {
throw new RecordNotFound( 'Variable not found' );
}
return $variable;
}
/**
* @throws DuplicatedLabel If there is a duplicate label in the database.
*/
public function assert_label_is_unique( string $label, ?string $ignore_id = null ): void {
foreach ( $this->all() as $variable ) {
if ( $variable->is_deleted() ) {
continue;
}
if ( null !== $ignore_id && $variable->id() === $ignore_id ) {
continue;
}
if ( strcasecmp( $variable->label(), $label ) === 0 ) {
throw new DuplicatedLabel( esc_html( "Variable label '$label' already exists." ) );
}
}
}
/**
* @throws VariablesLimitReached If variable limit reached.
*/
public function assert_limit_not_reached(): void {
$active_count = 0;
foreach ( $this->all() as $variable ) {
if ( ! $variable->is_deleted() ) {
++$active_count;
}
}
if ( self::TOTAL_VARIABLES_COUNT <= $active_count ) {
throw new VariablesLimitReached( 'Total variables count limit reached' );
}
}
public function next_id(): string {
return Utils::generate_id( 'e-gv-', array_keys( $this->all() ) );
}
public function get_next_order(): int {
$highest_order = 0;
foreach ( $this->all() as $variable ) {
if ( $variable->is_deleted() ) {
continue;
}
if ( $variable->has_order() && $variable->order() > $highest_order ) {
$highest_order = $variable->order();
}
}
return $highest_order + 1;
}
}

42
wp-content/plugins/elementor/modules/variables/storage/variables-repository.php Normal file
View File

@@ -0,0 +1,42 @@
<?php
namespace Elementor\Modules\Variables\Storage;
use Elementor\Core\Kits\Documents\Kit;
use Elementor\Modules\Variables\Adapters\Prop_Type_Adapter;
class Variables_Repository {
private const VARIABLES_META_KEY = '_elementor_global_variables';
private Kit $kit;
public function __construct( Kit $kit ) {
$this->kit = $kit;
}
public function load(): Variables_Collection {
$db_record = $this->kit->get_json_meta( self::VARIABLES_META_KEY );
if ( is_array( $db_record ) && ! empty( $db_record ) ) {
$collection = Variables_Collection::hydrate( $db_record );
Prop_Type_Adapter::from_storage( $collection );
return $collection;
}
return Variables_Collection::default();
}
public function save( Variables_Collection $collection ) {
$collection->increment_watermark();
$record = Prop_Type_Adapter::to_storage( $collection );
if ( $this->kit->update_json_meta( static::VARIABLES_META_KEY, $record ) ) {
return $collection->watermark();
}
return false;
}
}

32
wp-content/plugins/elementor/modules/variables/transformers/global-variable-transformer.php Normal file
View File

@@ -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})";
}
}