first commit

wp-content/plugins/elementor/modules/components/overridable-props/component-overridable-props-parser.php

@@ -0,0 +1,195 @@
+<?php
+
+namespace Elementor\Modules\Components\OverridableProps;
+
+use Elementor\Core\Utils\Api\Parse_Result;
+use Elementor\Modules\Components\Utils\Parsing_Utils;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit;
+}
+
+/**
+ * Validates and sanitizes component overridable props object.
+ *
+ * Valid input example:
+ * ```
+ * [
+ *     'props' => [
+ *         'prop1_UUID' => [
+ *             'overrideKey' => 'prop1_UUID',
+ *             'label' => 'User Name',
+ *             'elementId' => '90d25e3',
+ *             'propKey' => 'title',
+ *             'elType' => 'widget',
+ *             'widgetType' => 'e-heading',
+ *             'originValue' => [
+ *                 '$$type' => 'html',
+ *                 'value' => 'Jane Smith',
+ *             ],
+ *             'groupId' => 'group1_UUID',
+ *         ],
+ *     ],
+ *     'groups' => [
+ *         'items' => [
+ *             'group1_UUID' => [
+ *                 'id' => 'group1_UUID',
+ *                 'label' => 'User Info',
+ *                 'props' => [ 'prop1_UUID' ],
+ *             ],
+ *         ],
+ *         'order' => [ 'group1_UUID' ],
+ *     ],
+ * ];
+ * ```
+ */
+class Component_Overridable_Props_Parser {
+	private Overridable_Props_Parser $props_parser;
+	private Overridable_Groups_Parser $groups_parser;
+
+	public function __construct(
+		Overridable_Props_Parser $props_parser,
+		Overridable_Groups_Parser $groups_parser
+	) {
+		$this->props_parser = $props_parser;
+		$this->groups_parser = $groups_parser;
+	}
+
+	public static function make(): self {
+		return new static(
+			Overridable_Props_Parser::make(),
+			Overridable_Groups_Parser::make()
+		);
+	}
+
+	/**
+	 * @param array $data
+	 *
+	 * @return Parse_Result
+	 */
+	public function parse( array $data ): Parse_Result {
+		$result = Parse_Result::make();
+
+		if ( empty( $data ) ) {
+			return $result->wrap( [] );
+		}
+
+		$inner_fields_structure_result = $this->validate_inner_fields_structure( $data );
+
+		if ( ! $inner_fields_structure_result->is_valid() ) {
+			$result->errors()->merge( $inner_fields_structure_result->errors() );
+
+			return $result;
+		}
+
+		if ( empty( $data['props'] ) && empty( $data['groups'] ) ) {
+			return $result->wrap( [] );
+		}
+
+		$props_result = $this->props_parser->parse( $data['props'] );
+
+		if ( ! $props_result->is_valid() ) {
+			$result->errors()->merge( $props_result->errors() );
+
+			return $result;
+		}
+
+		$groups_result = $this->groups_parser->parse( $data['groups'] );
+
+		if ( ! $groups_result->is_valid() ) {
+			$result->errors()->merge( $groups_result->errors() );
+
+			return $result;
+		}
+
+		$parsed_props = $props_result->unwrap();
+		$parsed_groups = $groups_result->unwrap();
+
+		$validation_result = $this->validate( $parsed_props, $parsed_groups );
+
+		if ( ! $validation_result->is_valid() ) {
+			$result->errors()->merge( $validation_result->errors() );
+
+			return $result;
+		}
+
+		return $this->sanitize( $parsed_props, $parsed_groups );
+	}
+
+	private function validate_inner_fields_structure( array $data ): Parse_Result {
+		$result = Parse_Result::make();
+
+		$inner_fields = [ 'props', 'groups' ];
+
+		foreach ( $inner_fields as $inner_field ) {
+			if ( ! isset( $data[ $inner_field ] ) ) {
+				$result->errors()->add( $inner_field, 'missing' );
+
+				return $result;
+			}
+
+			if ( ! is_array( $data[ $inner_field ] ) ) {
+				$result->errors()->add( $inner_field, 'invalid_structure' );
+
+				return $result;
+			}
+		}
+
+		return $result;
+	}
+
+	private function validate( array $props, array $groups ): Parse_Result {
+		$result = Parse_Result::make();
+
+		$group_items = $groups['items'];
+
+		$props_in_groups = [];
+
+		foreach ( $group_items as $group_id => $group ) {
+			foreach ( $group['props'] as $prop_id ) {
+				if ( ! isset( $props[ $prop_id ] ) ) {
+					$result->errors()->add( "groups.items.$group_id.props.$prop_id", 'prop_not_found_in_props' );
+				} else {
+					$props_in_groups[ $prop_id ] = $group_id;
+				}
+			}
+		}
+
+		foreach ( $props as $prop_id => $prop ) {
+			if ( ! isset( $props_in_groups[ $prop_id ] ) || $prop['groupId'] !== $props_in_groups[ $prop_id ] ) {
+				$result->errors()->add( "props.$prop_id.groupId", 'mismatching_value_with_groups.items.props' );
+			}
+		}
+
+		$duplicate_labels_result = $this->check_duplicate_labels_within_groups( $group_items, $props );
+
+		if ( ! $duplicate_labels_result->is_valid() ) {
+			$result->errors()->merge( $duplicate_labels_result->errors(), 'groups.items' );
+		}
+
+		return $result;
+	}
+
+	private function sanitize( array $props, array $groups ): Parse_Result {
+		return Parse_Result::make()->wrap( [
+			'props' => $props,
+			'groups' => $groups,
+		] );
+	}
+
+	private function check_duplicate_labels_within_groups( array $groups, array $props ): Parse_Result {
+		$result = Parse_Result::make();
+
+		foreach ( $groups as $group_id => $group ) {
+			$group_props = $group['props'];
+			$labels = array_map( fn( $prop_id ) => $props[ $prop_id ]['label'], $group_props );
+			$duplicate_labels = Parsing_Utils::get_duplicates( $labels );
+
+			if ( ! empty( $duplicate_labels ) ) {
+				$result->errors()->add( "$group_id.props", 'duplicate_labels: ' . implode( ', ', $duplicate_labels ) );
+			}
+		}
+
+		return $result;
+	}
+}

wp-content/plugins/elementor/modules/components/overridable-props/overridable-groups-parser.php

@@ -0,0 +1,215 @@
+<?php
+
+namespace Elementor\Modules\Components\OverridableProps;
+
+use Elementor\Core\Utils\Api\Parse_Result;
+use Elementor\Core\Utils\Collection;
+use Elementor\Modules\Components\Utils\Parsing_Utils;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit;
+}
+
+class Overridable_Groups_Parser {
+	public static function make(): self {
+		return new static();
+	}
+
+	public function parse( array $groups ): Parse_Result {
+		$result = Parse_Result::make();
+
+		$structure_validation_result = $this->validate_structure( $groups );
+
+		if ( ! $structure_validation_result->is_valid() ) {
+			return $structure_validation_result;
+		}
+
+		$parsed_groups = $this->parse_groups_items( $groups['items'] );
+		if ( ! $parsed_groups->is_valid() ) {
+			$result->errors()->merge( $parsed_groups->errors() );
+
+			return $result;
+		}
+
+		$parsed_order = $this->parse_groups_order( $groups['order'] );
+		if ( ! $parsed_order->is_valid() ) {
+			$result->errors()->merge( $parsed_order->errors() );
+
+			return $result;
+		}
+
+		$validation_result = $this->validate( $parsed_groups->unwrap(), $parsed_order->unwrap() );
+
+		if ( ! $validation_result->is_valid() ) {
+			return $validation_result;
+		}
+
+		$sanitized_groups = $this->sanitize( $parsed_groups->unwrap(), $parsed_order->unwrap() );
+
+		return Parse_Result::make()->wrap( $sanitized_groups );
+	}
+
+	private function validate_structure( array $groups ): Parse_Result {
+		$result = Parse_Result::make();
+
+		$inner_fields = [ 'items', 'order' ];
+
+		foreach ( $inner_fields as $inner_field ) {
+			if ( ! isset( $groups[ $inner_field ] ) ) {
+				$result->errors()->add( "groups.$inner_field", 'missing' );
+
+				return $result;
+			}
+
+			if ( ! is_array( $groups[ $inner_field ] ) ) {
+				$result->errors()->add( "groups.$inner_field", 'invalid_structure' );
+
+				return $result;
+			}
+		}
+
+		foreach ( $groups['items'] as $group_id => $group ) {
+			if ( ! is_array( $group ) ) {
+				$result->errors()->add( "groups.items.$group_id", 'invalid_structure' );
+
+				continue;
+			}
+
+			$required_fields = [ 'id', 'label', 'props' ];
+
+			foreach ( $required_fields as $field ) {
+				if ( ! isset( $group[ $field ] ) ) {
+					$result->errors()->add( "groups.items.$group_id.$field", 'missing' );
+				}
+			}
+
+			if ( isset( $group['props'] ) && ! is_array( $group['props'] ) ) {
+				$result->errors()->add( "groups.items.$group_id.props", 'invalid_structure' );
+			}
+		}
+
+		return $result;
+	}
+
+	private function validate( array $items, array $order ): Parse_Result {
+		$result = Parse_Result::make();
+
+		$items_ids_collection = Collection::make( $items )->keys();
+		$order_collection = Collection::make( $order );
+
+		$excess_ids = $order_collection->diff( $items_ids_collection );
+		$missing_ids = $items_ids_collection->diff( $order_collection );
+
+		$excess_ids->each( fn( $id ) => $result->errors()->add( "groups.order.$id", 'excess' ) );
+		$missing_ids->each( fn( $id ) => $result->errors()->add( "groups.order.$id", 'missing' ) );
+
+		return $result;
+	}
+
+	private function parse_groups_items( array $items ): Parse_Result {
+		$result = Parse_Result::make();
+
+		$validate_groups_items_result = $this->validate_groups_items( $items );
+
+		if ( ! $validate_groups_items_result->is_valid() ) {
+			$result->errors()->merge( $validate_groups_items_result->errors() );
+
+			return $result;
+		}
+
+		return Parse_Result::make()->wrap( $this->sanitize_groups_items( $items ) );
+	}
+
+	private function validate_groups_items( array $items ): Parse_Result {
+		$result = Parse_Result::make();
+
+		$labels = [];
+
+		foreach ( $items as $group_id => $group ) {
+			if ( $group_id !== $group['id'] ) {
+				$result->errors()->add( "groups.items.$group_id.id", 'mismatching_value' );
+			}
+
+			$duplicate_props = Parsing_Utils::get_duplicates( $group['props'] );
+
+			if ( ! empty( $duplicate_props ) ) {
+				$result->errors()->add( "groups.items.$group_id.props", 'duplicate_props: ' . implode( ', ', $duplicate_props ) );
+			}
+
+			$labels[] = $group['label'];
+		}
+
+		$duplicate_labels = Parsing_Utils::get_duplicates( $labels );
+
+		if ( ! empty( $duplicate_labels ) ) {
+			$result->errors()->add( 'groups.items', 'duplicate_labels: ' . implode( ', ', $duplicate_labels ) );
+		}
+
+		return $result;
+	}
+
+	private function parse_groups_order( array $order ): Parse_Result {
+		$result = Parse_Result::make();
+
+		$validate_groups_order_result = $this->validate_groups_order( $order );
+
+		if ( ! $validate_groups_order_result->is_valid() ) {
+			return $validate_groups_order_result;
+		}
+
+		return Parse_Result::make()->wrap( $this->sanitize_groups_order( $order ) );
+	}
+
+	private function validate_groups_order( array $order ): Parse_Result {
+		$result = Parse_Result::make();
+
+		$order_collection = Collection::make( $order );
+		$non_string_items = $order_collection->some( fn( $item ) => ! is_string( $item ) );
+
+		if ( $non_string_items ) {
+			$result->errors()->add( 'groups.order', 'non_string_items' );
+
+			return $result;
+		}
+
+		if ( Parsing_Utils::get_duplicates( $order ) ) {
+			$result->errors()->add( 'groups.order', 'duplicate_ids' );
+
+			return $result;
+		}
+
+		return $result;
+	}
+
+	private function sanitize( array $items, array $order ): array {
+		return [
+			'items' => $items,
+			'order' => $order,
+		];
+	}
+
+	private function sanitize_groups_items( array $items ): array {
+		$sanitized_items = [];
+
+		foreach ( $items as $group_id => $group ) {
+			$sanitized_group_id = sanitize_key( $group_id );
+			$sanitized_items[ $sanitized_group_id ] = $this->sanitize_single_group( $group );
+		}
+
+		return $sanitized_items;
+	}
+
+	private function sanitize_single_group( array $group ): array {
+		return [
+			'id' => sanitize_key( $group['id'] ),
+			'label' => sanitize_text_field( $group['label'] ),
+			'props' => array_map( 'sanitize_key', $group['props'] ),
+		];
+	}
+
+	private function sanitize_groups_order( array $order ): array {
+		return Collection::make( $order )
+			->map( fn( $item ) => sanitize_key( $item ) )
+			->values();
+	}
+}

wp-content/plugins/elementor/modules/components/overridable-props/overridable-prop-parser.php

@@ -0,0 +1,141 @@
+<?php
+
+namespace Elementor\Modules\Components\OverridableProps;
+
+use Elementor\Modules\Components\PropTypes\Override_Prop_Type;
+use Elementor\Modules\Components\Utils\Parsing_Utils;
+use Elementor\Core\Utils\Api\Parse_Result;
+use Elementor\Modules\Components\PropTypes\Overridable_Prop_Type;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit;
+}
+
+class Overridable_Prop_Parser {
+	public static function make(): self {
+		return new static();
+	}
+
+	public function parse( array $prop ): Parse_Result {
+		$validation_result = $this->validate( $prop );
+
+		if ( ! $validation_result->is_valid() ) {
+			return $validation_result;
+		}
+
+		return $this->sanitize( $prop );
+	}
+
+	private function validate( array $prop ): Parse_Result {
+		$result = Parse_Result::make();
+
+		$required_fields = [
+			'overrideKey',
+			'label',
+			'elementId',
+			'elType',
+			'widgetType',
+			'propKey',
+			'groupId',
+		];
+
+		foreach ( $required_fields as $field ) {
+			if ( ! isset( $prop[ $field ] ) ) {
+				$result->errors()->add( $field, 'missing_field' );
+			}
+		}
+
+		if ( ! $result->is_valid() ) {
+			return $result;
+		}
+
+		$origin_value = $this->get_final_origin_value( $prop );
+
+		if ( ! empty( $origin_value ) ) {
+			$origin_value_prop_type = $this->get_origin_prop_type( $prop );
+
+			if ( ! $origin_value_prop_type->validate( $origin_value ) ) {
+				$result->errors()->add( 'originValue', 'invalid' );
+
+				return $result;
+			}
+		}
+
+		return $result;
+	}
+
+	private function sanitize( array $prop ): Parse_Result {
+		$result = Parse_Result::make();
+
+		$sanitized_origin_value = $this->get_sanitized_origin_value( $prop );
+
+		$sanitized_prop = [
+			'overrideKey' => sanitize_key( $prop['overrideKey'] ),
+			'label' => sanitize_text_field( $prop['label'] ),
+			'elementId' => sanitize_key( $prop['elementId'] ),
+			'propKey' => sanitize_text_field( $prop['propKey'] ),
+			'widgetType' => sanitize_text_field( $prop['widgetType'] ),
+			'elType' => sanitize_text_field( $prop['elType'] ),
+			'originValue' => $sanitized_origin_value,
+			'groupId' => sanitize_key( $prop['groupId'] ),
+			'originPropFields' => isset( $prop['originPropFields'] ) ? [
+				'elType' => sanitize_text_field( $prop['originPropFields']['elType'] ),
+				'widgetType' => sanitize_text_field( $prop['originPropFields']['widgetType'] ),
+				'propKey' => sanitize_text_field( $prop['originPropFields']['propKey'] ),
+				'elementId' => sanitize_key( $prop['originPropFields']['elementId'] ),
+			] : null,
+		];
+
+		return $result->wrap( $sanitized_prop );
+	}
+
+	private function is_with_origin_prop_fields( array $prop ): bool {
+		return ! empty( $prop['originPropFields'] );
+	}
+
+	private function get_origin_prop_type( array $prop ) {
+		if ( $this->is_with_origin_prop_fields( $prop ) ) {
+			return $this->get_origin_prop_type( $prop['originPropFields'] );
+		}
+
+		return Parsing_Utils::get_prop_type(
+			$prop['elType'],
+			$prop['widgetType'],
+			$prop['propKey'],
+		);
+	}
+
+	private function get_final_origin_value( array $prop ) {
+		if ( empty( $prop ) || empty( $prop['originValue'] ) ) {
+			return null;
+		}
+
+		if (
+			isset( $prop['originValue']['$$type'] ) &&
+			Override_Prop_Type::get_key() === $prop['originValue']['$$type']
+		) {
+			return $prop['originValue']['value']['override_value'];
+		}
+
+		return $prop['originValue'];
+	}
+
+	private function get_sanitized_origin_value( array $prop ) {
+		$origin_value = $this->get_final_origin_value( $prop );
+		$origin_prop_type = $this->get_origin_prop_type( $prop );
+
+		if ( ! empty( $origin_value ) ) {
+			$sanitized_value = $origin_prop_type->sanitize( $origin_value );
+
+			if ( Override_Prop_Type::get_key() === $prop['originValue']['$$type'] ) {
+				$raw_origin_value = $prop['originValue'];
+				$raw_origin_value['value']['override_value'] = $sanitized_value;
+				return $raw_origin_value;
+			}
+
+			return $sanitized_value;
+		}
+
+		return null;
+	}
+}

wp-content/plugins/elementor/modules/components/overridable-props/overridable-props-parser.php

@@ -0,0 +1,88 @@
+<?php
+
+namespace Elementor\Modules\Components\OverridableProps;
+
+use Elementor\Core\Utils\Api\Parse_Result;
+use Elementor\Modules\Components\Utils\Parsing_Utils;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit;
+}
+
+class Overridable_Props_Parser {
+	private Overridable_Prop_Parser $prop_parser;
+
+	public function __construct( Overridable_Prop_Parser $prop_parser ) {
+		$this->prop_parser = $prop_parser;
+	}
+
+	public static function make(): self {
+		return new static( Overridable_Prop_Parser::make() );
+	}
+
+	public function parse( array $props ): Parse_Result {
+		$parse_props_result = $this->parse_props( $props );
+
+		if ( ! $parse_props_result->is_valid() ) {
+			return $parse_props_result;
+		}
+
+		$parsed_props = $parse_props_result->unwrap();
+
+		$validation_result = $this->validate( $parsed_props );
+
+		if ( ! $validation_result->is_valid() ) {
+			return $validation_result;
+		}
+
+		return Parse_Result::make()->wrap( $parsed_props );
+	}
+
+	private function parse_props( array $props ): Parse_Result {
+		$result = Parse_Result::make();
+		$parsed_props = [];
+
+		foreach ( $props as $prop_id => $prop ) {
+			if ( ! is_array( $prop ) ) {
+				$result->errors()->add( "props.$prop_id", 'invalid_structure' );
+
+				continue;
+			}
+
+			$prop_result = $this->prop_parser->parse( $prop );
+
+			if ( ! $prop_result->is_valid() ) {
+				$result->errors()->merge( $prop_result->errors(), "props.$prop_id" );
+
+				continue;
+			}
+
+			$parsed_prop = $prop_result->unwrap();
+			$parsed_prop_id = sanitize_key( $prop_id );
+
+			if ( $parsed_prop_id != $parsed_prop['overrideKey'] ) {
+				$result->errors()->add( "props.$parsed_prop_id", 'mismatching_override_key' );
+
+				continue;
+			}
+
+			$parsed_props[ $parsed_prop_id ] = $parsed_prop;
+		}
+
+		return $result->wrap( $parsed_props );
+	}
+
+	private function validate( array $props ): Parse_Result {
+		$result = Parse_Result::make();
+
+		$duplicate_prop_keys_for_same_element = Parsing_Utils::get_duplicates( array_map( fn( $prop ) => $prop['elementId'] . '.' . $prop['propKey'], $props ) );
+
+		if ( ! empty( $duplicate_prop_keys_for_same_element ) ) {
+			$result->errors()->add( 'props', 'duplicate_prop_keys_for_same_element: ' . implode( ', ', $duplicate_prop_keys_for_same_element ) );
+
+			return $result;
+		}
+
+		return $result;
+	}
+}