@elementor/editor-props 3.33.0-271 → 3.33.0-272

package/dist/index.js

@@ -22,6 +22,7 @@ var index_exports = {};
 __export(index_exports, {
   CLASSES_PROP_KEY: () => CLASSES_PROP_KEY,
   DateTimePropTypeUtil: () => DateTimePropTypeUtil,
+  Schema: () => Schema,
   backdropFilterPropTypeUtil: () => backdropFilterPropTypeUtil,
   backgroundColorOverlayPropTypeUtil: () => backgroundColorOverlayPropTypeUtil,
   backgroundGradientOverlayPropTypeUtil: () => backgroundGradientOverlayPropTypeUtil,
@@ -50,6 +51,7 @@ __export(index_exports, {
   filterEmptyValues: () => filterEmptyValues,
   filterPropTypeUtil: () => filterPropTypeUtil,
   flexPropTypeUtil: () => flexPropTypeUtil,
+  getPropSchemaFromCache: () => getPropSchemaFromCache,
   gradientColorStopPropTypeUtil: () => gradientColorStopPropTypeUtil,
   htmlPropTypeUtil: () => htmlPropTypeUtil,
   hueRotateFilterPropTypeUtil: () => hueRotateFilterPropTypeUtil,
@@ -90,6 +92,10 @@ var import_schema4 = require("@elementor/schema");
 
 // src/utils/create-prop-utils.ts
 var import_schema = require("@elementor/schema");
+var SCHEMA_CACHE = /* @__PURE__ */ new Map();
+function getPropSchemaFromCache(key) {
+  return SCHEMA_CACHE.get(key);
+}
 function createPropUtils(key, valueSchema) {
   const schema = import_schema.z.strictObject({
     $$type: import_schema.z.literal(key),
@@ -124,13 +130,15 @@ function createPropUtils(key, valueSchema) {
     }
     return prop.value;
   }
-  return {
+  const propUtil = {
     extract,
     isValid,
     create,
     schema,
     key
   };
+  SCHEMA_CACHE.set(key, propUtil);
+  return propUtil;
 }
 function createArrayPropUtils(key, valueSchema, overrideKey) {
   return createPropUtils(overrideKey || `${key}-array`, import_schema.z.array(valueSchema));
@@ -605,6 +613,314 @@ var backdropFilterPropTypeUtil = createPropUtils(
   import_schema46.z.array(cssFilterFunctionPropUtil.schema)
 );
 
+// src/utils/adjust-llm-prop-value-schema.ts
+var ensureNotNull = (v, fallback) => v === null ? fallback : v;
+var adjustLlmPropValueSchema = (value, forceKey) => {
+  const clone = structuredClone(value);
+  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
+          }
+        };
+      }
+    }
+    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
+          );
+        });
+      }
+    }
+  }
+  return clone;
+};
+
+// src/utils/llm-schema-to-props.ts
+function jsonSchemaToPropType(schema, key = schema.key) {
+  const meta = {};
+  if (schema.description) {
+    meta.description = schema.description;
+  }
+  if (schema.anyOf && Array.isArray(schema.anyOf)) {
+    return convertJsonSchemaToUnionPropType(schema, meta);
+  }
+  if (schema.type === "object" && schema.properties) {
+    return convertJsonSchemaToObjectPropType(schema, meta, key);
+  }
+  if (schema.type === "array" && schema.items) {
+    return convertJsonSchemaToArrayPropType(schema, meta, key);
+  }
+  return convertJsonSchemaToPlainPropType(schema, meta, key);
+}
+function convertJsonSchemaToPlainPropType(schema, meta, key = schema.key) {
+  const settings = {};
+  let propKey = key || "string";
+  if (schema.type === "number") {
+    propKey = "number";
+  } else if (schema.type === "boolean") {
+    propKey = "boolean";
+  } else if (schema.type === "string") {
+    propKey = "string";
+  }
+  if (Array.isArray(schema.enum)) {
+    settings.enum = schema.enum;
+  }
+  return {
+    kind: "plain",
+    key: propKey,
+    settings,
+    meta
+  };
+}
+function convertJsonSchemaToUnionPropType(schema, meta) {
+  const propTypes = {};
+  if (!schema.anyOf || !Array.isArray(schema.anyOf)) {
+    throw new Error("Invalid anyOf schema");
+  }
+  for (const variantSchema of schema.anyOf) {
+    if (variantSchema.type === "object" && variantSchema.properties && variantSchema.properties.$$type && variantSchema.properties.value) {
+      const typeProperty = variantSchema.properties.$$type;
+      let typeKey;
+      if (typeProperty.enum && Array.isArray(typeProperty.enum) && typeProperty.enum.length > 0) {
+        typeKey = typeProperty.enum[0];
+      } else {
+        continue;
+      }
+      const valuePropType = convertJsonSchemaToPropType(variantSchema.properties.value);
+      propTypes[typeKey] = valuePropType;
+    }
+  }
+  return {
+    kind: "union",
+    prop_types: propTypes,
+    settings: {},
+    meta
+  };
+}
+function convertJsonSchemaToObjectPropType(schema, meta, key = schema.key) {
+  const shape = {};
+  if (!schema.properties) {
+    return {
+      kind: "object",
+      key,
+      shape: {},
+      settings: {},
+      meta
+    };
+  }
+  const requiredFields = Array.isArray(schema.required) ? schema.required : [];
+  for (const [propKey, propSchema] of Object.entries(schema.properties)) {
+    const subPropType = convertJsonSchemaToPropType(propSchema, key);
+    if (requiredFields.includes(propKey)) {
+      subPropType.settings = {
+        ...subPropType.settings,
+        required: true
+      };
+    }
+    shape[propKey] = subPropType;
+  }
+  return {
+    kind: "object",
+    key: key || "object",
+    shape,
+    settings: {},
+    meta
+  };
+}
+function convertJsonSchemaToArrayPropType(schema, meta, key = schema.key) {
+  if (!schema.items) {
+    throw new Error("Array schema must have items property");
+  }
+  const itemPropType = convertJsonSchemaToPropType(schema.items);
+  return {
+    kind: "array",
+    key: key || "array",
+    item_prop_type: itemPropType,
+    settings: {},
+    meta
+  };
+}
+function convertJsonSchemaToPropType(schema, key) {
+  return jsonSchemaToPropType(schema, key);
+}
+
+// src/utils/props-to-llm-schema.ts
+function propTypeToJsonSchema(propType, key) {
+  const description = propType.meta?.description;
+  const schema = {};
+  if (description) {
+    schema.description = description;
+  }
+  if (key) {
+    schema.key = key;
+  }
+  switch (propType.kind) {
+    case "plain":
+      return convertPlainPropType(propType, schema);
+    case "union":
+      return convertUnionPropType(propType, schema);
+    case "object":
+      return convertObjectPropType(propType, schema);
+    case "array":
+      return convertArrayPropType(propType, schema);
+    default:
+      return convertPlainPropType(propType, schema);
+  }
+  return schema;
+}
+function convertPlainPropType(propType, baseSchema) {
+  const schema = { ...baseSchema };
+  schema.key = propType.key;
+  const key = propType.key.toLowerCase();
+  switch (key) {
+    case "number":
+      schema.type = "number";
+      break;
+    case "boolean":
+      schema.type = "boolean";
+      break;
+    default:
+      schema.type = "string";
+  }
+  if (Array.isArray(propType.settings?.enum)) {
+    schema.enum = propType.settings.enum;
+  }
+  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)) {
+    const subSchema = convertPropTypeToJsonSchema(subPropType);
+    schemas.push({
+      type: "object",
+      required: ["$$type", "value"],
+      properties: {
+        $$type: {
+          type: "string",
+          const: typeKey,
+          description: `Discriminator for union type variant: ${typeKey}`
+        },
+        value: subSchema
+      }
+    });
+  }
+  if (schemas.length > 0) {
+    schema.anyOf = schemas;
+  }
+  const propTypeDescription = propType.meta?.description;
+  if (propTypeDescription) {
+    schema.description = propTypeDescription;
+  }
+  return schema;
+}
+function convertObjectPropType(propType, baseSchema) {
+  const schema = structuredClone(baseSchema);
+  schema.type = "object";
+  schema.properties = {};
+  const required = [];
+  const shape = propType.shape || {};
+  for (const [key, subPropType] of Object.entries(shape)) {
+    const propSchema = convertPropTypeToJsonSchema(subPropType);
+    if (subPropType.settings?.required === true) {
+      required.push(key);
+    }
+    schema.properties[key] = propSchema;
+  }
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  return schema;
+}
+function convertArrayPropType(propType, baseSchema) {
+  const schema = structuredClone(baseSchema);
+  schema.type = "array";
+  schema.key = propType.key;
+  const itemPropType = propType.item_prop_type;
+  if (itemPropType) {
+    schema.items = convertPropTypeToJsonSchema(itemPropType);
+  }
+  return schema;
+}
+function convertPropTypeToJsonSchema(propType) {
+  return propTypeToJsonSchema(propType);
+}
+
+// src/utils/is-transformable.ts
+var import_schema47 = require("@elementor/schema");
+var transformableSchema = import_schema47.z.object({
+  $$type: import_schema47.z.string(),
+  value: import_schema47.z.any(),
+  disabled: import_schema47.z.boolean().optional()
+});
+var isTransformable = (value) => {
+  return transformableSchema.safeParse(value).success;
+};
+
+// src/utils/filter-empty-values.ts
+var filterEmptyValues = (value) => {
+  if (isEmpty(value)) {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    return value.map(filterEmptyValues).filter((item) => !isEmpty(item));
+  }
+  if (typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, val]) => [key, filterEmptyValues(val)]).filter(([, val]) => !isEmpty(val))
+    );
+  }
+  return value;
+};
+var isEmpty = (value) => {
+  if (value && isTransformable(value)) {
+    return isEmpty(value.value);
+  }
+  return isNullish(value) || isNullishArray(value) || isNullishObject(value);
+};
+var isNullish = (value) => value === null || value === void 0 || value === "";
+var isNullishArray = (value) => Array.isArray(value) && value.every(isEmpty);
+var isNullishObject = (value) => {
+  return typeof value === "object" && isNullishArray(Object.values(value));
+};
+
 // src/utils/merge-props.ts
 function mergeProps(current, updates) {
   let props = {};
@@ -621,17 +937,6 @@ function mergeProps(current, updates) {
   return props;
 }
 
-// src/utils/is-transformable.ts
-var import_schema47 = require("@elementor/schema");
-var transformableSchema = import_schema47.z.object({
-  $$type: import_schema47.z.string(),
-  value: import_schema47.z.any(),
-  disabled: import_schema47.z.boolean().optional()
-});
-var isTransformable = (value) => {
-  return transformableSchema.safeParse(value).success;
-};
-
 // src/utils/prop-dependency-utils.ts
 function isDependencyMet(dependency, values) {
   if (!dependency?.terms.length) {
@@ -711,36 +1016,17 @@ function isDependency(term) {
   return "relation" in term;
 }
 
-// src/utils/filter-empty-values.ts
-var filterEmptyValues = (value) => {
-  if (isEmpty(value)) {
-    return null;
-  }
-  if (Array.isArray(value)) {
-    return value.map(filterEmptyValues).filter((item) => !isEmpty(item));
-  }
-  if (typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, val]) => [key, filterEmptyValues(val)]).filter(([, val]) => !isEmpty(val))
-    );
-  }
-  return value;
-};
-var isEmpty = (value) => {
-  if (value && isTransformable(value)) {
-    return isEmpty(value.value);
-  }
-  return isNullish(value) || isNullishArray(value) || isNullishObject(value);
-};
-var isNullish = (value) => value === null || value === void 0 || value === "";
-var isNullishArray = (value) => Array.isArray(value) && value.every(isEmpty);
-var isNullishObject = (value) => {
-  return typeof value === "object" && isNullishArray(Object.values(value));
+// src/index.ts
+var Schema = {
+  jsonSchemaToPropType,
+  propTypeToJsonSchema,
+  adjustLlmPropValueSchema
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CLASSES_PROP_KEY,
   DateTimePropTypeUtil,
+  Schema,
   backdropFilterPropTypeUtil,
   backgroundColorOverlayPropTypeUtil,
   backgroundGradientOverlayPropTypeUtil,
@@ -769,6 +1055,7 @@ var isNullishObject = (value) => {
   filterEmptyValues,
   filterPropTypeUtil,
   flexPropTypeUtil,
+  getPropSchemaFromCache,
   gradientColorStopPropTypeUtil,
   htmlPropTypeUtil,
   hueRotateFilterPropTypeUtil,