zZzzZ. — /home2/zrzvbdry/public_html/wp-content/plugins/elementor/modules/atomic-widgets/parsers

Editing: style-parser.php

<?php

namespace Elementor\Modules\AtomicWidgets\Parsers;

if ( ! defined( 'ABSPATH' ) ) {
	exit; // Exit if accessed directly.
}

use Elementor\Modules\AtomicWidgets\OptIn\Opt_In;
use Elementor\Plugin;
use Elementor\Utils;
use Elementor\Core\Utils\Api\Parse_Result;
use Elementor\Modules\AtomicWidgets\Styles\Style_States;

class Style_Parser {
	const VALID_TYPES = [
		'class',
	];

private array $schema;

public function __construct( array $schema ) {
		$this->schema = $schema;
	}

public static function make( array $schema ): self {
		return new static( $schema );
	}

/**
	 * @param array $style
	 * the style object to validate
	 */
	private function validate( array $style ): Parse_Result {
		$validated_style = $style;
		$result = Parse_Result::make();

if ( ! isset( $style['id'] ) || ! is_string( $style['id'] ) ) {
			$result->errors()->add( 'id', 'missing_or_invalid' );
		}

if ( ! isset( $style['type'] ) || ! in_array( $style['type'], self::VALID_TYPES, true ) ) {
			$result->errors()->add( 'type', 'missing_or_invalid' );
		}

if ( ! isset( $style['label'] ) || ! is_string( $style['label'] ) ) {
			$result->errors()->add( 'label', 'missing_or_invalid' );
		} elseif ( Plugin::$instance->experiments->is_feature_active( Opt_In::EXPERIMENT_NAME ) ) {
			$label_validation = $this->validate_style_label( $style['label'] );

if ( ! $label_validation['is_valid'] ) {
				$result->errors()->add( 'label', $label_validation['error_message'] );
			}
		}

if ( ! isset( $style['variants'] ) || ! is_array( $style['variants'] ) ) {
			$result->errors()->add( 'variants', 'missing_or_invalid' );

unset( $validated_style['variants'] );

return $result->wrap( $validated_style );
		}

$props_parser = Props_Parser::make( $this->schema );

foreach ( $style['variants'] as $variant_index => $variant ) {
			if ( ! isset( $variant['meta'] ) ) {
				$result->errors()->add( 'meta', 'missing' );

continue;
			}

$meta_result = $this->validate_meta( $variant['meta'] );
			$custom_css_result = $this->validate_custom_css( $variant );

$result->errors()->merge( $meta_result->errors(), 'meta' );
			$result->errors()->merge( $custom_css_result->errors(), 'custom_css' );

if ( $meta_result->is_valid() ) {
				$variant_result = $props_parser->validate( $variant['props'] );

$result->errors()->merge( $variant_result->errors(), "variants[$variant_index]" );

$validated_style['variants'][ $variant_index ]['props'] = $variant_result->unwrap();
			} else {
				unset( $validated_style['variants'][ $variant_index ] );
			}
		}

return $result->wrap( $validated_style );
	}

private function validate_style_label( string $label ): array {
		$label = strtolower( $label );

$reserved_class_names = [ 'container' ];

if ( strlen( $label ) > 50 ) {
			return [
				'is_valid' => false,
				'error_message' => 'class_name_too_long',
			];
		}

if ( strlen( $label ) < 2 ) {
			return [
				'is_valid' => false,
				'error_message' => 'class_name_too_short',
			];
		}

if ( in_array( $label, $reserved_class_names, true ) ) {
			return [
				'is_valid' => false,
				'error_message' => 'reserved_class_name',
			];
		}

$regexes = [
			[
				'pattern' => '/^(|[^0-9].*)$/',
				'message' => 'class_name_starts_with_digit',
			],
			[
				'pattern' => '/^\S*$/',
				'message' => 'class_name_contains_spaces',
			],
			[
				'pattern' => '/^(|[a-zA-Z0-9_-]+)$/',
				'message' => 'class_name_invalid_chars',
			],
			[
				'pattern' => '/^(?!--).*/',
				'message' => 'class_name_double_hyphen',
			],
			[
				'pattern' => '/^(?!-[0-9])/',
				'message' => 'class_name_starts_with_hyphen_digit',
			],
		];

foreach ( $regexes as $rule ) {
			if ( ! preg_match( $rule['pattern'], $label ) ) {
				return [
					'is_valid' => false,
					'error_message' => $rule['message'],
				];
			}
		}
		return [
			'is_valid' => true,
			'error_message' => null,
		];
	}

private function validate_meta( $meta ): Parse_Result {
		$result = Parse_Result::make();

if ( ! is_array( $meta ) ) {
			$result->errors()->add( 'meta', 'invalid_type' );

return $result;
		}

if ( ! array_key_exists( 'state', $meta ) || ! Style_States::is_valid_state( $meta['state'] ) ) {
			$result->errors()->add( 'state', 'missing_or_invalid_value' );

return $result;
		}

// TODO: Validate breakpoint based on the existing breakpoints in the system [EDS-528]
		if ( ! isset( $meta['breakpoint'] ) || ! is_string( $meta['breakpoint'] ) ) {
			$result->errors()->add( 'breakpoint', 'missing_or_invalid_value' );

return $result;
		}

return $result;
	}

private function validate_custom_css( array $variant ): Parse_Result {
		$result = Parse_Result::make();

if ( ! empty( $variant['custom_css']['raw'] ) && (
				! is_string( $variant['custom_css']['raw'] ) ||
				null === Utils::decode_string( $variant['custom_css']['raw'], null )
			)
		) {
			$result->errors()->add( 'custom_css', 'invalid_type' );
		}

return $result;
	}

private function sanitize_meta( $meta ) {
		if ( ! is_array( $meta ) ) {
			return [];
		}

if ( isset( $meta['breakpoint'] ) ) {
			$meta['breakpoint'] = sanitize_key( $meta['breakpoint'] );
		}

return $meta;
	}

private function sanitize_custom_css( array $variant ) {
		if ( empty( $variant['custom_css']['raw'] ) ) {
			return null;
		}

$custom_css = Utils::decode_string( $variant['custom_css']['raw'] );
		$custom_css = sanitize_textarea_field( $custom_css );
		$custom_css = [ 'raw' => Utils::encode_string( $custom_css ) ];

return empty( $custom_css['raw'] ) ? null : $custom_css;
	}

/**
	 * @param array $style
	 * the style object to sanitize
	 */
	private function sanitize( array $style ): Parse_Result {
		$props_parser = Props_Parser::make( $this->schema );

if ( isset( $style['label'] ) ) {
			$style['label'] = sanitize_text_field( $style['label'] );
		}

if ( isset( $style['id'] ) ) {
			$style['id'] = sanitize_key( $style['id'] );
		}

if ( isset( $style['sync_to_v3'] ) ) {
			$style['sync_to_v3'] = (bool) $style['sync_to_v3'];
		}

if ( ! empty( $style['variants'] ) ) {
			foreach ( $style['variants'] as $variant_index => $variant ) {
				$style['variants'][ $variant_index ]['props'] = $props_parser->sanitize( $variant['props'] )->unwrap();
				$style['variants'][ $variant_index ]['meta'] = $this->sanitize_meta( $variant['meta'] );
				$style['variants'][ $variant_index ]['custom_css'] = $this->sanitize_custom_css( $variant );
			}
		}

return Parse_Result::make()->wrap( $style );
	}

/**
	 * @param array $style
	 * the style object to parse
	 */
	public function parse( array $style ): Parse_Result {
		$validate_result = $this->validate( $style );

$sanitize_result = $this->sanitize( $validate_result->unwrap() );

$sanitize_result->errors()->merge( $validate_result->errors() );

return $sanitize_result;
	}
}