@elementor/editor-props 0.16.0 → 3.32.0-20

package/src/utils/prop-dependency-utils.ts

@@ -1,22 +1,32 @@
-import { type Dependency, type DependencyTerm, type PropValue, type TransformablePropValue } from '../types';
+import {
+	type Dependency,
+	type DependencyTerm,
+	type PropKey,
+	type PropValue,
+	type TransformablePropValue,
+} from '../types';
+import { isTransformable } from './is-transformable';
 
 type ParsedTerm = DependencyTerm;
 
 type Relation = Dependency[ 'relation' ];
 
-export function shouldApplyEffect( { relation, terms }: Dependency, values: PropValue ): boolean {
-	if ( ! terms.length ) {
-		return false;
+export function isDependencyMet( dependency: Dependency | undefined, values: PropValue ): boolean {
+	if ( ! dependency?.terms.length ) {
+		return true;
 	}
 
+	const { relation, terms } = dependency;
 	const method = getRelationMethod( relation );
 
 	return terms[ method ]( ( term: ParsedTerm | Dependency ) =>
-		isDependency( term ) ? shouldApplyEffect( term, values ) : evaluateTerm( term, getValue( term.path, values ) )
+		isDependency( term )
+			? isDependencyMet( term, values )
+			: evaluateTerm( term, extractValue( term.path, values )?.value )
 	);
 }
 
-export function evaluateTerm( term: DependencyTerm, actualValue: PropValue ) {
+export function evaluateTerm( term: DependencyTerm, actualValue: unknown ) {
 	const { value: valueToCompare, operator } = term;
 
 	switch ( operator ) {
@@ -26,27 +36,26 @@ export function evaluateTerm( term: DependencyTerm, actualValue: PropValue ) {
 
 		case 'gt':
 		case 'lte':
-			if ( isNaN( Number( actualValue ) ) || isNaN( Number( valueToCompare ) ) ) {
-				throw new Error( 'Mathematical comparison requires numeric values.' );
+			if ( ! isNumber( actualValue ) || ! isNumber( valueToCompare ) ) {
+				return false;
 			}
 
 			return Number( actualValue ) > Number( valueToCompare ) === ( 'gt' === operator );
 
 		case 'lt':
 		case 'gte':
-			if ( isNaN( Number( actualValue ) ) || isNaN( Number( valueToCompare ) ) ) {
-				throw new Error( 'Mathematical comparison requires numeric values.' );
+			if ( ! isNumber( actualValue ) || ! isNumber( valueToCompare ) ) {
+				return false;
 			}
 
 			return Number( actualValue ) < Number( valueToCompare ) === ( 'lt' === operator );
-
 		case 'in':
 		case 'nin':
 			if ( ! Array.isArray( valueToCompare ) ) {
-				throw new Error( 'The "in" and "nin" operators require an array for comparison.' );
+				return false;
 			}
 
-			return valueToCompare.includes( actualValue ) === ( 'in' === operator );
+			return valueToCompare.includes( actualValue as never ) === ( 'in' === operator );
 
 		case 'contains':
 		case 'ncontains':
@@ -54,9 +63,7 @@ export function evaluateTerm( term: DependencyTerm, actualValue: PropValue ) {
 				( 'string' !== typeof actualValue || 'string' !== typeof valueToCompare ) &&
 				! Array.isArray( actualValue )
 			) {
-				throw new Error(
-					'The "contains" and "ncontains" operators require a string or an array for comparison.'
-				);
+				return false;
 			}
 
 			return ( 'contains' === operator ) === actualValue.includes( valueToCompare as never );
@@ -68,10 +75,14 @@ export function evaluateTerm( term: DependencyTerm, actualValue: PropValue ) {
 			return ( 'exists' === operator ) === evaluation;
 
 		default:
-			return false;
+			return true;
 	}
 }
 
+function isNumber( value: unknown ): value is number {
+	return typeof value === 'number' && ! isNaN( value );
+}
+
 function getRelationMethod( relation: Relation ) {
 	switch ( relation ) {
 		case 'or':
@@ -85,14 +96,14 @@ function getRelationMethod( relation: Relation ) {
 	}
 }
 
-function getValue( path: string[], elementValues: PropValue ): PropValue | null {
-	return path.reduce( ( acc, key ) => {
-		return 'object' === typeof acc && acc !== null && key in acc
-			? ( ( acc[ key as keyof typeof acc ] as TransformablePropValue< string > )?.value as PropValue )
-			: null;
-	}, elementValues );
+export function extractValue( path: string[], elementValues: PropValue ): TransformablePropValue< PropKey > | null {
+	return path.reduce( ( acc, key, index ) => {
+		const value = acc?.[ key as keyof typeof acc ] as PropValue | null;
+
+		return index !== path.length - 1 && isTransformable( value ) ? value.value ?? null : value;
+	}, elementValues ) as TransformablePropValue< PropKey >;
 }
 
-function isDependency( term: DependencyTerm | Dependency ): term is Dependency {
+export function isDependency( term: DependencyTerm | Dependency ): term is Dependency {
 	return 'relation' in term;
 }

package/src/prop-types/filter-prop-types/blur-filter.ts

@@ -1,8 +0,0 @@
-import { type z } from '@elementor/schema';
-
-import { createPropUtils } from '../../utils/create-prop-utils';
-import { unknownChildrenSchema } from '../utils';
-
-export const blurFilterPropTypeUtil = createPropUtils( 'blur', unknownChildrenSchema );
-
-export type BlurFilterPropValue = z.infer< typeof blurFilterPropTypeUtil.schema >;

package/src/prop-types/filter-prop-types/brightness-filter.ts

@@ -1,8 +0,0 @@
-import { type z } from '@elementor/schema';
-
-import { createPropUtils } from '../../utils/create-prop-utils';
-import { unknownChildrenSchema } from '../utils';
-
-export const brightnessFilterPropTypeUtil = createPropUtils( 'brightness', unknownChildrenSchema );
-
-export type BrightnessFilterPropValue = z.infer< typeof brightnessFilterPropTypeUtil.schema >;