@elementor/editor-props 0.16.0 → 3.32.0-20

package/dist/index.mjs

@@ -45,8 +45,8 @@ function createPropUtils(key, valueSchema) {
     key
   };
 }
-function createArrayPropUtils(key, valueSchema) {
-  return createPropUtils(`${key}-array`, z.array(valueSchema));
+function createArrayPropUtils(key, valueSchema, overrideKey) {
+  return createPropUtils(overrideKey || `${key}-array`, z.array(valueSchema));
 }
 
 // src/prop-types/shadow.ts
@@ -108,40 +108,51 @@ var classesPropTypeUtil = createPropUtils(
 import { z as z8 } from "@elementor/schema";
 var colorPropTypeUtil = createPropUtils("color", z8.string());
 
-// src/prop-types/image.ts
+// src/prop-types/flex.ts
 import { z as z9 } from "@elementor/schema";
+var flexPropTypeUtil = createPropUtils(
+  "flex",
+  z9.strictObject({
+    flexGrow: unknownChildrenSchema,
+    flexShrink: unknownChildrenSchema,
+    flexBasis: unknownChildrenSchema
+  })
+);
+
+// src/prop-types/image.ts
+import { z as z10 } from "@elementor/schema";
 var imagePropTypeUtil = createPropUtils(
   "image",
-  z9.strictObject({
+  z10.strictObject({
     src: unknownChildrenSchema,
     size: unknownChildrenSchema
   })
 );
 
 // src/prop-types/image-attachment-id.ts
-import { z as z10 } from "@elementor/schema";
-var imageAttachmentIdPropType = createPropUtils("image-attachment-id", z10.number());
+import { z as z11 } from "@elementor/schema";
+var imageAttachmentIdPropType = createPropUtils("image-attachment-id", z11.number());
 
 // src/prop-types/image-src.ts
-import { z as z11 } from "@elementor/schema";
+import { z as z12 } from "@elementor/schema";
 var imageSrcPropTypeUtil = createPropUtils(
   "image-src",
-  z11.strictObject({
+  z12.strictObject({
     id: unknownChildrenSchema,
-    url: z11.null()
+    url: z12.null()
   }).or(
-    z11.strictObject({
-      id: z11.null(),
+    z12.strictObject({
+      id: z12.null(),
       url: unknownChildrenSchema
     })
   )
 );
 
 // src/prop-types/dimensions.ts
-import { z as z12 } from "@elementor/schema";
+import { z as z13 } from "@elementor/schema";
 var dimensionsPropTypeUtil = createPropUtils(
   "dimensions",
-  z12.strictObject({
+  z13.strictObject({
     "block-start": unknownChildrenSchema,
     "block-end": unknownChildrenSchema,
     "inline-start": unknownChildrenSchema,
@@ -150,80 +161,112 @@ var dimensionsPropTypeUtil = createPropUtils(
 );
 
 // src/prop-types/number.ts
-import { z as z13 } from "@elementor/schema";
-var numberPropTypeUtil = createPropUtils("number", z13.number().nullable());
+import { z as z14 } from "@elementor/schema";
+var numberPropTypeUtil = createPropUtils("number", z14.number().nullable());
 
 // src/prop-types/size.ts
-import { z as z14 } from "@elementor/schema";
+import { z as z15 } from "@elementor/schema";
 var sizePropTypeUtil = createPropUtils(
   "size",
-  z14.strictObject({
-    unit: z14.enum(["px", "em", "rem", "%", "vw", "vh"]),
-    size: z14.number()
+  z15.strictObject({
+    unit: z15.enum(["px", "em", "rem", "%", "vw", "vh"]),
+    size: z15.number()
   }).or(
-    z14.strictObject({
-      unit: z14.literal("auto"),
-      size: z14.literal("")
+    z15.strictObject({
+      unit: z15.enum(["deg", "rad", "grad", "turn"]),
+      size: z15.number()
+    })
+  ).or(
+    z15.strictObject({
+      unit: z15.enum(["s", "ms"]),
+      size: z15.number()
+    })
+  ).or(
+    z15.strictObject({
+      unit: z15.literal("auto"),
+      size: z15.literal("")
     })
   ).or(
-    z14.strictObject({
-      unit: z14.literal("custom"),
-      size: z14.string()
+    z15.strictObject({
+      unit: z15.literal("custom"),
+      size: z15.string()
     })
   )
 );
 
 // src/prop-types/string.ts
-import { z as z15 } from "@elementor/schema";
-var stringPropTypeUtil = createPropUtils("string", z15.string().nullable());
+import { z as z16 } from "@elementor/schema";
+var stringPropTypeUtil = createPropUtils("string", z16.string().nullable());
 
 // src/prop-types/stroke.ts
-import { z as z16 } from "@elementor/schema";
+import { z as z17 } from "@elementor/schema";
 var strokePropTypeUtil = createPropUtils(
   "stroke",
-  z16.strictObject({
+  z17.strictObject({
     color: unknownChildrenSchema,
     width: unknownChildrenSchema
   })
 );
 
 // src/prop-types/url.ts
-import { z as z17 } from "@elementor/schema";
-var urlPropTypeUtil = createPropUtils("url", z17.string().nullable());
+import { z as z18 } from "@elementor/schema";
+var urlPropTypeUtil = createPropUtils("url", z18.string().nullable());
 
 // src/prop-types/layout-direction.ts
-import { z as z18 } from "@elementor/schema";
+import { z as z19 } from "@elementor/schema";
 var layoutDirectionPropTypeUtil = createPropUtils(
   "layout-direction",
-  z18.object({
-    row: z18.any(),
-    column: z18.any()
+  z19.object({
+    row: z19.any(),
+    column: z19.any()
   })
 );
 
 // src/prop-types/link.ts
-import { z as z19 } from "@elementor/schema";
+import { z as z20 } from "@elementor/schema";
 var linkPropTypeUtil = createPropUtils(
   "link",
-  z19.strictObject({
+  z20.strictObject({
     destination: unknownChildrenSchema,
     label: unknownChildrenSchema,
     isTargetBlank: unknownChildrenSchema
   })
 );
 
+// src/prop-types/selection-size.ts
+import { z as z22 } from "@elementor/schema";
+
+// src/prop-types/key-value.ts
+import { z as z21 } from "@elementor/schema";
+var keyValuePropTypeUtil = createPropUtils(
+  "key-value",
+  z21.strictObject({
+    key: unknownChildrenSchema,
+    value: unknownChildrenSchema
+  })
+);
+
+// src/prop-types/selection-size.ts
+var selectionSizePropTypeUtil = createPropUtils(
+  "selection-size",
+  z22.strictObject({
+    selection: z22.union([keyValuePropTypeUtil.schema, stringPropTypeUtil.schema]),
+    size: sizePropTypeUtil.schema
+  })
+);
+
 // src/prop-types/background-prop-types/background.ts
-import { z as z20 } from "@elementor/schema";
+import { z as z23 } from "@elementor/schema";
 var backgroundPropTypeUtil = createPropUtils(
   "background",
-  z20.strictObject({
+  z23.strictObject({
     color: unknownChildrenSchema,
     "background-overlay": unknownChildrenSchema
   })
 );
 
 // src/prop-types/background-prop-types/background-overlay.ts
-import { z as z21 } from "@elementor/schema";
+import { z as z24 } from "@elementor/schema";
 
 // src/prop-types/background-prop-types/background-color-overlay.ts
 var backgroundColorOverlayPropTypeUtil = createPropUtils("background-color-overlay", unknownChildrenSchema);
@@ -239,7 +282,7 @@ var backgroundImageOverlayPropTypeUtil = createPropUtils("background-image-overl
 
 // src/prop-types/background-prop-types/background-overlay.ts
 var backgroundOverlayItem = backgroundColorOverlayPropTypeUtil.schema.or(backgroundGradientOverlayPropTypeUtil.schema).or(backgroundImageOverlayPropTypeUtil.schema);
-var backgroundOverlayPropTypeUtil = createPropUtils("background-overlay", z21.array(backgroundOverlayItem));
+var backgroundOverlayPropTypeUtil = createPropUtils("background-overlay", z24.array(backgroundOverlayItem));
 
 // src/prop-types/background-prop-types/background-image-position-offset.ts
 var backgroundImagePositionOffsetPropTypeUtil = createPropUtils(
@@ -254,87 +297,132 @@ var backgroundImageSizeScalePropTypeUtil = createPropUtils(
 );
 
 // src/prop-types/boolean.ts
-import { z as z22 } from "@elementor/schema";
-var booleanPropTypeUtil = createPropUtils("boolean", z22.boolean().nullable());
+import { z as z25 } from "@elementor/schema";
+var booleanPropTypeUtil = createPropUtils("boolean", z25.boolean().nullable());
 
 // src/prop-types/color-stop.ts
-import { z as z23 } from "@elementor/schema";
+import { z as z26 } from "@elementor/schema";
 var colorStopPropTypeUtil = createPropUtils(
   "color-stop",
-  z23.strictObject({
+  z26.strictObject({
     color: unknownChildrenSchema,
     offset: unknownChildrenSchema
   })
 );
 
 // src/prop-types/gradient-color-stop.ts
-import { z as z24 } from "@elementor/schema";
+import { z as z27 } from "@elementor/schema";
 var gradientColorStopPropTypeUtil = createPropUtils(
   "gradient-color-stop",
-  z24.array(colorStopPropTypeUtil.schema)
-);
-
-// src/prop-types/key-value.ts
-import { z as z25 } from "@elementor/schema";
-var keyValuePropTypeUtil = createPropUtils(
-  "key-value",
-  z25.strictObject({
-    key: unknownChildrenSchema,
-    value: unknownChildrenSchema
-  })
+  z27.array(colorStopPropTypeUtil.schema)
 );
 
 // src/prop-types/position.ts
-import { z as z26 } from "@elementor/schema";
+import { z as z28 } from "@elementor/schema";
 var positionPropTypeUtil = createPropUtils(
   "object-position",
-  z26.strictObject({
+  z28.strictObject({
     x: sizePropTypeUtil.schema.nullable(),
     y: sizePropTypeUtil.schema.nullable()
   })
 );
 
 // src/prop-types/filter-prop-types/filter.ts
-import { z as z27 } from "@elementor/schema";
-
-// src/prop-types/filter-prop-types/blur-filter.ts
-var blurFilterPropTypeUtil = createPropUtils("blur", unknownChildrenSchema);
+import { z as z30 } from "@elementor/schema";
 
-// src/prop-types/filter-prop-types/brightness-filter.ts
-var brightnessFilterPropTypeUtil = createPropUtils("brightness", unknownChildrenSchema);
+// src/prop-types/filter-prop-types/drop-shadow-filter.ts
+import { z as z29 } from "@elementor/schema";
+var dropShadowFilterPropTypeUtil = createPropUtils(
+  "drop-shadow",
+  z29.object({
+    xAxis: sizePropTypeUtil.schema,
+    yAxis: sizePropTypeUtil.schema,
+    blur: sizePropTypeUtil.schema,
+    color: unknownChildrenSchema
+  })
+);
 
 // src/prop-types/filter-prop-types/filter.ts
-var filterTypes = blurFilterPropTypeUtil.schema.or(brightnessFilterPropTypeUtil.schema);
-var filterPropTypeUtil = createPropUtils("filter", z27.array(filterTypes));
+var cssFilterFunctionPropUtil = createPropUtils(
+  "css-filter-func",
+  z30.object({
+    func: stringPropTypeUtil.schema,
+    args: z30.union([sizePropTypeUtil.schema, dropShadowFilterPropTypeUtil.schema])
+  })
+);
+var filterPropTypeUtil = createPropUtils("filter", z30.array(cssFilterFunctionPropUtil.schema));
 
 // src/prop-types/transform-prop-types/transform.ts
-import { z as z30 } from "@elementor/schema";
+import { z as z35 } from "@elementor/schema";
+
+// src/prop-types/transform-prop-types/move-transform.ts
+import { z as z31 } from "@elementor/schema";
+
+// src/prop-types/transform-prop-types/types.ts
+var TransformFunctionKeys = {
+  move: "transform-move",
+  scale: "transform-scale",
+  rotate: "transform-rotate",
+  skew: "transform-skew"
+};
 
 // src/prop-types/transform-prop-types/move-transform.ts
-import { z as z28 } from "@elementor/schema";
 var moveTransformPropTypeUtil = createPropUtils(
-  "transform-move",
-  z28.strictObject({
+  TransformFunctionKeys.move,
+  z31.strictObject({
     x: sizePropTypeUtil.schema.nullable(),
     y: sizePropTypeUtil.schema.nullable(),
     z: sizePropTypeUtil.schema.nullable()
   })
 );
 
-// src/prop-types/transform-prop-types/scale-transform.ts
-import { z as z29 } from "@elementor/schema";
-var scaleTransformPropTypeUtil = createPropUtils(
-  "scale",
-  z29.strictObject({
+// src/prop-types/transform-prop-types/rotate-transform.ts
+import { z as z32 } from "@elementor/schema";
+var rotateTransformPropTypeUtil = createPropUtils(
+  TransformFunctionKeys.rotate,
+  z32.strictObject({
     x: sizePropTypeUtil.schema.nullable(),
     y: sizePropTypeUtil.schema.nullable(),
     z: sizePropTypeUtil.schema.nullable()
   })
 );
 
+// src/prop-types/transform-prop-types/scale-transform.ts
+import { z as z33 } from "@elementor/schema";
+var scaleTransformPropTypeUtil = createPropUtils(
+  TransformFunctionKeys.scale,
+  z33.strictObject({
+    x: numberPropTypeUtil.schema.nullable(),
+    y: numberPropTypeUtil.schema.nullable(),
+    z: numberPropTypeUtil.schema.nullable()
+  })
+);
+
+// src/prop-types/transform-prop-types/skew-transform.ts
+import { z as z34 } from "@elementor/schema";
+var skewTransformPropTypeUtil = createPropUtils(
+  TransformFunctionKeys.skew,
+  z34.strictObject({
+    x: sizePropTypeUtil.schema.nullable(),
+    y: sizePropTypeUtil.schema.nullable()
+  })
+);
+
 // src/prop-types/transform-prop-types/transform.ts
-var filterTypes2 = moveTransformPropTypeUtil.schema.or(scaleTransformPropTypeUtil.schema);
-var transformPropTypeUtil = createPropUtils("transform", z30.array(filterTypes2));
+var filterTypes = z35.union([
+  moveTransformPropTypeUtil.schema,
+  scaleTransformPropTypeUtil.schema,
+  rotateTransformPropTypeUtil.schema,
+  skewTransformPropTypeUtil.schema
+]);
+var transformPropTypeUtil = createPropUtils("transform", z35.array(filterTypes));
+
+// src/prop-types/filter-prop-types/backdrop-filter.ts
+import { z as z36 } from "@elementor/schema";
+var backdropFilterPropTypeUtil = createPropUtils(
+  "backdrop-filter",
+  z36.array(cssFilterFunctionPropUtil.schema)
+);
 
 // src/utils/merge-props.ts
 function mergeProps(current, updates) {
@@ -349,14 +437,26 @@ function mergeProps(current, updates) {
   return props;
 }
 
+// src/utils/is-transformable.ts
+import { z as z37 } from "@elementor/schema";
+var transformableSchema = z37.object({
+  $$type: z37.string(),
+  value: z37.any(),
+  disabled: z37.boolean().optional()
+});
+var isTransformable = (value) => {
+  return transformableSchema.safeParse(value).success;
+};
+
 // src/utils/prop-dependency-utils.ts
-function shouldApplyEffect({ relation, terms }, values) {
-  if (!terms.length) {
-    return false;
+function isDependencyMet(dependency, values) {
+  if (!dependency?.terms.length) {
+    return true;
   }
+  const { relation, terms } = dependency;
   const method = getRelationMethod(relation);
   return terms[method](
-    (term) => isDependency(term) ? shouldApplyEffect(term, values) : evaluateTerm(term, getValue(term.path, values))
+    (term) => isDependency(term) ? isDependencyMet(term, values) : evaluateTerm(term, extractValue(term.path, values)?.value)
   );
 }
 function evaluateTerm(term, actualValue) {
@@ -367,28 +467,26 @@ function evaluateTerm(term, actualValue) {
       return actualValue === valueToCompare === ("eq" === operator);
     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);
     case "contains":
     case "ncontains":
       if (("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);
     case "exists":
@@ -396,9 +494,12 @@ function evaluateTerm(term, actualValue) {
       const evaluation = !!actualValue || 0 === actualValue || false === actualValue;
       return "exists" === operator === evaluation;
     default:
-      return false;
+      return true;
   }
 }
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value);
+}
 function getRelationMethod(relation) {
   switch (relation) {
     case "or":
@@ -409,26 +510,16 @@ function getRelationMethod(relation) {
       throw new Error(`Relation not supported ${relation}`);
   }
 }
-function getValue(path, elementValues) {
-  return path.reduce((acc, key) => {
-    return "object" === typeof acc && acc !== null && key in acc ? acc[key]?.value : null;
+function extractValue(path, elementValues) {
+  return path.reduce((acc, key, index) => {
+    const value = acc?.[key];
+    return index !== path.length - 1 && isTransformable(value) ? value.value ?? null : value;
   }, elementValues);
 }
 function isDependency(term) {
   return "relation" in term;
 }
 
-// src/utils/is-transformable.ts
-import { z as z31 } from "@elementor/schema";
-var transformableSchema = z31.object({
-  $$type: z31.string(),
-  value: z31.any(),
-  disabled: z31.boolean().optional()
-});
-var isTransformable = (value) => {
-  return transformableSchema.safeParse(value).success;
-};
-
 // src/utils/filter-empty-values.ts
 var filterEmptyValues = (value) => {
   if (isEmpty(value)) {
@@ -457,6 +548,7 @@ var isNullishObject = (value) => {
 };
 export {
   CLASSES_PROP_KEY,
+  backdropFilterPropTypeUtil,
   backgroundColorOverlayPropTypeUtil,
   backgroundGradientOverlayPropTypeUtil,
   backgroundImageOverlayPropTypeUtil,
@@ -464,25 +556,29 @@ export {
   backgroundImageSizeScalePropTypeUtil,
   backgroundOverlayPropTypeUtil,
   backgroundPropTypeUtil,
-  blurFilterPropTypeUtil,
   booleanPropTypeUtil,
   borderRadiusPropTypeUtil,
   borderWidthPropTypeUtil,
   boxShadowPropTypeUtil,
-  brightnessFilterPropTypeUtil,
   classesPropTypeUtil,
   colorPropTypeUtil,
   colorStopPropTypeUtil,
   createArrayPropUtils,
   createPropUtils,
+  cssFilterFunctionPropUtil,
   dimensionsPropTypeUtil,
+  dropShadowFilterPropTypeUtil,
   evaluateTerm,
+  extractValue,
   filterEmptyValues,
   filterPropTypeUtil,
+  flexPropTypeUtil,
   gradientColorStopPropTypeUtil,
   imageAttachmentIdPropType,
   imagePropTypeUtil,
   imageSrcPropTypeUtil,
+  isDependency,
+  isDependencyMet,
   isEmpty,
   isTransformable,
   keyValuePropTypeUtil,
@@ -492,9 +588,12 @@ export {
   moveTransformPropTypeUtil,
   numberPropTypeUtil,
   positionPropTypeUtil,
+  rotateTransformPropTypeUtil,
+  scaleTransformPropTypeUtil,
+  selectionSizePropTypeUtil,
   shadowPropTypeUtil,
-  shouldApplyEffect,
   sizePropTypeUtil,
+  skewTransformPropTypeUtil,
   stringPropTypeUtil,
   strokePropTypeUtil,
   transformPropTypeUtil,