1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

<?php

namespace Elementor\Modules\AtomicWidgets\Parsers;

use Elementor\Modules\AtomicWidgets\PropTypes\Contracts\Prop_Type;

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

class Props_Parser {

    private array $schema;
    private array $errors_bag = [];

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

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

    /**
     * @param array $props
     * The key of each item represents the prop name (should match the schema),
     * and the value is the prop value to validate
     *
     * @return array{
     *     0: bool,
     *     1: array<string, mixed>,
     *     2: array<string>
     * }
     */
    public function validate( array $props ): array {
        $validated = [];

        foreach ( $this->schema as $key => $prop_type ) {
            if ( ! ( $prop_type instanceof Prop_Type ) ) {
                continue;
            }

            $value = $props[ $key ] ?? null;

            $is_valid = $prop_type->validate( $value ?? $prop_type->get_default() );

            if ( ! $is_valid ) {
                $this->errors_bag[] = $key;

                continue;
            }

            if ( ! is_null( $value ) ) {
                $validated[ $key ] = $value;
            }
        }

        $is_valid = empty( $this->errors_bag );

        return [
            $is_valid,
            $validated,
            $this->errors_bag,
        ];
    }

    /**
     * @param array $props
     * The key of each item represents the prop name (should match the schema),
     * and the value is the prop value to sanitize
     *
     * @return array<string, mixed>
     */
    public function sanitize( array $props ): array {
        $sanitized = [];

        foreach ( $this->schema as $key => $prop_type ) {
            if ( ! isset( $props[ $key ] ) ) {
                continue;
            }

            $sanitized[ $key ] = $prop_type->sanitize( $props[ $key ] );
        }

        return $sanitized;
    }

    /**
     * @param array $props
     * The key of each item represents the prop name (should match the schema),
     * and the value is the prop value to parse
     *
     * @return array{
     *      0: bool,
     *      1: array<string, mixed>,
     *      2: array<string>
     *  }
     */
    public function parse( array $props ): array {
        [ $is_valid, $validated, $errors_bag  ] = $this->validate( $props );

        return [
            $is_valid,
            $this->sanitize( $validated ),
            $errors_bag,
        ];
    }
}