@elementor/editor-props 3.35.0-340 → 3.35.0-342

package/dist/index.mjs

@@ -175,7 +175,7 @@ import { z as z15 } from "@elementor/schema";
 var sizePropTypeUtil = createPropUtils(
   "size",
   z15.strictObject({
-    unit: z15.enum(["px", "em", "rem", "%", "vw", "vh"]),
+    unit: z15.enum(["px", "em", "rem", "%", "vw", "vh", "ch"]),
     size: z15.number()
   }).or(
     z15.strictObject({
@@ -527,63 +527,55 @@ var backdropFilterPropTypeUtil = createPropUtils(
 
 // src/utils/adjust-llm-prop-value-schema.ts
 var ensureNotNull = (v, fallback) => v === null ? fallback : v;
-var adjustLlmPropValueSchema = (value, forceKey) => {
+var defaultOptions = {
+  transformers: {}
+};
+var adjustLlmPropValueSchema = (value, { transformers = {}, forceKey = void 0 } = defaultOptions) => {
   const clone = structuredClone(value);
-  if (typeof clone === "string") {
-    return stringPropTypeUtil.create(clone);
+  if (typeof clone !== "object" || clone === null) {
+    return null;
   }
-  if (typeof clone === "number") {
-    return numberPropTypeUtil.create(clone);
+  if (Array.isArray(clone)) {
+    return clone.map((item) => adjustLlmPropValueSchema(item, { forceKey, transformers }));
   }
-  if (clone && typeof clone === "object") {
-    if (Array.isArray(clone)) {
-      return clone.map((item) => adjustLlmPropValueSchema(item, forceKey));
-    }
-    const transformablePropValue = clone;
-    if (forceKey) {
-      transformablePropValue.$$type = forceKey;
-    }
-    if (!transformablePropValue.$$type) {
-      throw new Error("Missing $$type in property: " + JSON.stringify(transformablePropValue));
-    }
-    if (!("value" in transformablePropValue)) {
-      throw new Error("Missing value property in PropValue: " + JSON.stringify(transformablePropValue));
-    }
-    switch (transformablePropValue.$$type) {
-      case "size": {
-        const { value: rawSizePropValue } = transformablePropValue;
-        const unit = typeof rawSizePropValue.unit === "string" ? rawSizePropValue.unit : ensureNotNull(stringPropTypeUtil.extract(rawSizePropValue.unit), "px");
-        const size = typeof rawSizePropValue.size === "string" || typeof rawSizePropValue.size === "number" ? rawSizePropValue.size : ensureNotNull(
-          stringPropTypeUtil.extract(rawSizePropValue.size),
-          numberPropTypeUtil.extract(rawSizePropValue.size)
-        );
-        return {
-          $$type: "size",
-          value: {
-            unit,
-            size
-          }
-        };
-      }
+  const transformablePropValue = clone;
+  if (forceKey) {
+    transformablePropValue.$$type = forceKey;
+  }
+  switch (transformablePropValue.$$type) {
+    case "size": {
+      const { value: rawSizePropValue } = transformablePropValue;
+      const unit = typeof rawSizePropValue.unit === "string" ? rawSizePropValue.unit : ensureNotNull(stringPropTypeUtil.extract(rawSizePropValue.unit), "px");
+      const size = typeof rawSizePropValue.size === "string" || typeof rawSizePropValue.size === "number" ? rawSizePropValue.size : ensureNotNull(
+        stringPropTypeUtil.extract(rawSizePropValue.size),
+        numberPropTypeUtil.extract(rawSizePropValue.size)
+      );
+      return {
+        $$type: "size",
+        value: {
+          unit,
+          size
+        }
+      };
     }
-    if (typeof transformablePropValue.value === "object") {
-      if (Array.isArray(transformablePropValue.value)) {
-        transformablePropValue.value = adjustLlmPropValueSchema(
-          transformablePropValue.value,
-          void 0
-        );
-      } else {
-        const { value: objectValue } = transformablePropValue;
-        const clonedObject = clone;
-        clonedObject.value = {};
-        Object.keys(objectValue).forEach((key) => {
-          const childProp = objectValue[key];
-          clonedObject.value[key] = adjustLlmPropValueSchema(
-            childProp,
-            void 0
-          );
-        });
+    default:
+      const transformer = transformers?.[transformablePropValue.$$type];
+      if (transformer) {
+        return transformer(transformablePropValue.value);
       }
+  }
+  if (typeof transformablePropValue.value === "object") {
+    if (Array.isArray(transformablePropValue.value)) {
+      transformablePropValue.value = adjustLlmPropValueSchema(transformablePropValue.value, {
+        transformers
+      });
+    } else {
+      const { value: objectValue } = transformablePropValue;
+      const clonedObject = clone;
+      clonedObject.value = {};
+      Object.entries(objectValue).forEach(([key, childProp]) => {
+        clonedObject.value[key] = adjustLlmPropValueSchema(childProp, { transformers });
+      });
     }
   }
   return clone;
@@ -705,9 +697,10 @@ function propTypeToJsonSchema(propType) {
   if (description) {
     schema.description = description;
   }
+  if (propType.initial_value !== null && propType.initial_value !== void 0) {
+    schema.examples = [propType.initial_value];
+  }
   switch (propType.kind) {
-    case "plain":
-      return convertPlainPropType(propType, schema);
     case "union":
       return convertUnionPropType(propType, schema);
     case "object":
@@ -717,45 +710,53 @@ function propTypeToJsonSchema(propType) {
     default:
       return convertPlainPropType(propType, schema);
   }
-  return schema;
 }
 function convertPlainPropType(propType, baseSchema) {
   const schema = { ...baseSchema };
-  const key = propType.key.toLowerCase();
-  switch (key) {
+  if (!Object.hasOwn(propType, "kind")) {
+    throw new Error(`PropType kind is undefined for propType with key: ${propType.key ?? "[unknown key]"}`);
+  }
+  const enumValues = propType.settings?.enum || [];
+  switch (propType.kind) {
+    case "string":
     case "number":
-      schema.type = "number";
-      break;
     case "boolean":
-      schema.type = "boolean";
-      break;
+      return {
+        ...schema,
+        type: "object",
+        properties: {
+          $$type: {
+            type: "string",
+            const: propType.key ?? propType.kind
+          },
+          value: {
+            type: propType.kind,
+            ...enumValues.length > 0 ? { enum: enumValues } : {}
+          }
+        },
+        required: ["$$type", "value"]
+      };
     default:
-      schema.type = "string";
-  }
-  if (Array.isArray(propType.settings?.enum)) {
-    schema.enum = propType.settings.enum;
+      return {
+        ...schema,
+        type: "object",
+        $$type: propType.kind,
+        value: {
+          type: propType.kind
+        }
+      };
   }
-  return schema;
 }
 function convertUnionPropType(propType, baseSchema) {
   const schema = structuredClone(baseSchema);
   const propTypes = propType.prop_types || {};
   const schemas = [];
   for (const [typeKey, subPropType] of Object.entries(propTypes)) {
+    if (typeKey === "dynamic" || typeKey === "overridable") {
+      continue;
+    }
     const subSchema = convertPropTypeToJsonSchema(subPropType);
-    schemas.push({
-      type: "object",
-      required: ["$$type", "value"],
-      properties: {
-        $$type: {
-          type: "string",
-          const: typeKey,
-          description: subPropType.meta?.description,
-          $comment: `Discriminator for union type variant: ${typeKey}`
-        },
-        value: subSchema
-      }
-    });
+    schemas.push(subSchema);
   }
   if (schemas.length > 0) {
     schema.anyOf = schemas;
@@ -769,28 +770,58 @@ function convertUnionPropType(propType, baseSchema) {
 function convertObjectPropType(propType, baseSchema) {
   const schema = structuredClone(baseSchema);
   schema.type = "object";
-  schema.properties = {};
-  const required = [];
+  const internalStructure = {
+    properties: {
+      $$type: {
+        type: "string",
+        const: propType.key
+      },
+      value: {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      }
+    }
+  };
+  const required = ["$$type", "value"];
+  const valueRequired = [];
   const shape = propType.shape || {};
   for (const [key, subPropType] of Object.entries(shape)) {
-    const propSchema = convertPropTypeToJsonSchema(subPropType);
+    const propSchema = propTypeToJsonSchema(subPropType);
     if (subPropType.settings?.required === true) {
-      required.push(key);
+      valueRequired.push(key);
+    }
+    if (internalStructure.properties.value.properties) {
+      internalStructure.properties.value.properties[key] = propSchema;
     }
-    schema.properties[key] = propSchema;
   }
-  if (required.length > 0) {
-    schema.required = required;
+  schema.required = required;
+  if (valueRequired.length > 0) {
+    internalStructure.properties.value.required = valueRequired;
   }
-  return schema;
+  return {
+    ...schema,
+    ...internalStructure
+  };
 }
 function convertArrayPropType(propType, baseSchema) {
   const schema = structuredClone(baseSchema);
-  schema.type = "array";
+  schema.type = "object";
+  let items;
   const itemPropType = propType.item_prop_type;
   if (itemPropType) {
-    schema.items = convertPropTypeToJsonSchema(itemPropType);
+    items = convertPropTypeToJsonSchema(itemPropType);
   }
+  schema.properties = {
+    $$type: {
+      type: "string",
+      const: propType.key
+    },
+    value: {
+      type: "array",
+      ...items ? { items } : {}
+    }
+  };
   return schema;
 }
 function convertPropTypeToJsonSchema(propType) {
@@ -804,6 +835,73 @@ function configurableKeys(schema) {
   return Object.keys(schema).filter(isPropKeyConfigurable);
 }
 
+// src/utils/validate-prop-value.ts
+import { validate } from "jsonschema";
+function processValidationError(error) {
+  const detailed = {
+    path: error.path,
+    message: error.message,
+    schema: error.schema,
+    instance: error.instance,
+    name: error.name
+  };
+  if (error.name === "anyOf" && error.schema && typeof error.schema === "object" && "anyOf" in error.schema) {
+    const anyOfSchema = error.schema;
+    const variants = (anyOfSchema.anyOf || []).map((variantSchema, idx) => {
+      const variantResult = validate(error.instance, variantSchema);
+      let discriminator = `variant-${idx}`;
+      if (variantSchema && typeof variantSchema === "object" && "properties" in variantSchema && variantSchema.properties && typeof variantSchema.properties === "object" && "$$type" in variantSchema.properties) {
+        const typeProperty = variantSchema.properties.$$type;
+        if (typeProperty && typeof typeProperty === "object" && "const" in typeProperty && typeof typeProperty.const === "string") {
+          discriminator = typeProperty.const;
+        }
+      }
+      return {
+        discriminator,
+        errors: variantResult.errors.map(processValidationError)
+      };
+    });
+    detailed.variants = variants;
+  }
+  return detailed;
+}
+function formatDetailedErrors(errors, indent = "") {
+  const lines = [];
+  for (const error of errors) {
+    const pathStr = error.path.length > 0 ? error.path.join(".") : "root";
+    lines.push(`${indent}Error at ${pathStr}: ${error.message}`);
+    if (error.variants && error.variants.length > 0) {
+      lines.push(`${indent}  Tried ${error.variants.length} variant(s):`);
+      for (const variant of error.variants) {
+        lines.push(`${indent}    - ${variant.discriminator}:`);
+        if (variant.errors.length === 0) {
+          lines.push(`${indent}        (no errors - this variant matched!)`);
+        } else {
+          for (const nestedError of variant.errors) {
+            const nestedPathStr = nestedError.path.length > 0 ? nestedError.path.join(".") : "root";
+            lines.push(`${indent}        ${nestedPathStr}: ${nestedError.message}`);
+            if (nestedError.variants && nestedError.variants.length > 0) {
+              lines.push(formatDetailedErrors([nestedError], `${indent}        `));
+            }
+          }
+        }
+      }
+    }
+  }
+  return lines.join("\n");
+}
+var validatePropValue = (schema, value) => {
+  const jsonSchema = propTypeToJsonSchema(schema);
+  const result = validate(value, jsonSchema);
+  const detailedErrors = result.errors.map(processValidationError);
+  return {
+    valid: result.valid,
+    errors: result.errors,
+    errorMessages: formatDetailedErrors(detailedErrors),
+    jsonSchema: JSON.stringify(jsonSchema)
+  };
+};
+
 // src/utils/is-transformable.ts
 import { z as z47 } from "@elementor/schema";
 var transformableSchema = z47.object({
@@ -999,7 +1097,8 @@ var Schema = {
   adjustLlmPropValueSchema,
   isPropKeyConfigurable,
   nonConfigurablePropKeys,
-  configurableKeys
+  configurableKeys,
+  validatePropValue
 };
 export {
   CLASSES_PROP_KEY,