@elementor/editor-props 3.33.0-99 → 3.35.0-325

package/dist/index.js

@@ -21,6 +21,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   CLASSES_PROP_KEY: () => CLASSES_PROP_KEY,
+  DateTimePropTypeUtil: () => DateTimePropTypeUtil,
+  Schema: () => Schema,
   backdropFilterPropTypeUtil: () => backdropFilterPropTypeUtil,
   backgroundColorOverlayPropTypeUtil: () => backgroundColorOverlayPropTypeUtil,
   backgroundGradientOverlayPropTypeUtil: () => backgroundGradientOverlayPropTypeUtil,
@@ -49,7 +51,9 @@ __export(index_exports, {
   filterEmptyValues: () => filterEmptyValues,
   filterPropTypeUtil: () => filterPropTypeUtil,
   flexPropTypeUtil: () => flexPropTypeUtil,
+  getPropSchemaFromCache: () => getPropSchemaFromCache,
   gradientColorStopPropTypeUtil: () => gradientColorStopPropTypeUtil,
+  htmlPropTypeUtil: () => htmlPropTypeUtil,
   hueRotateFilterPropTypeUtil: () => hueRotateFilterPropTypeUtil,
   imageAttachmentIdPropType: () => imageAttachmentIdPropType,
   imagePropTypeUtil: () => imagePropTypeUtil,
@@ -67,6 +71,7 @@ __export(index_exports, {
   numberPropTypeUtil: () => numberPropTypeUtil,
   perspectiveOriginPropTypeUtil: () => perspectiveOriginPropTypeUtil,
   positionPropTypeUtil: () => positionPropTypeUtil,
+  queryPropTypeUtil: () => queryPropTypeUtil,
   rotateTransformPropTypeUtil: () => rotateTransformPropTypeUtil,
   scaleTransformPropTypeUtil: () => scaleTransformPropTypeUtil,
   selectionSizePropTypeUtil: () => selectionSizePropTypeUtil,
@@ -87,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),
@@ -121,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));
@@ -312,7 +323,6 @@ var linkPropTypeUtil = createPropUtils(
   "link",
   import_schema20.z.strictObject({
     destination: unknownChildrenSchema,
-    label: unknownChildrenSchema,
     isTargetBlank: unknownChildrenSchema
   })
 );
@@ -345,6 +355,7 @@ var backgroundPropTypeUtil = createPropUtils(
   "background",
   import_schema23.z.strictObject({
     color: unknownChildrenSchema,
+    clip: unknownChildrenSchema,
     "background-overlay": unknownChildrenSchema
   })
 );
@@ -401,24 +412,48 @@ var gradientColorStopPropTypeUtil = createPropUtils(
   import_schema27.z.array(colorStopPropTypeUtil.schema)
 );
 
-// src/prop-types/position.ts
+// src/prop-types/date-time.ts
 var import_schema28 = require("@elementor/schema");
+var DateTimePropTypeUtil = createPropUtils(
+  "date-time",
+  import_schema28.z.strictObject({
+    date: unknownChildrenSchema,
+    time: unknownChildrenSchema
+  })
+);
+
+// src/prop-types/position.ts
+var import_schema29 = require("@elementor/schema");
 var positionPropTypeUtil = createPropUtils(
   "object-position",
-  import_schema28.z.strictObject({
+  import_schema29.z.strictObject({
     x: unknownChildrenSchema,
     y: unknownChildrenSchema
   })
 );
 
+// src/prop-types/query.ts
+var import_schema30 = require("@elementor/schema");
+var queryPropTypeUtil = createPropUtils(
+  "query",
+  import_schema30.z.strictObject({
+    id: unknownChildrenSchema,
+    label: unknownChildrenSchema
+  })
+);
+
+// src/prop-types/html.ts
+var import_schema31 = require("@elementor/schema");
+var htmlPropTypeUtil = createPropUtils("html", import_schema31.z.string().nullable());
+
 // src/prop-types/filter-prop-types/filter.ts
-var import_schema34 = require("@elementor/schema");
+var import_schema37 = require("@elementor/schema");
 
 // src/prop-types/filter-prop-types/drop-shadow-filter.ts
-var import_schema29 = require("@elementor/schema");
+var import_schema32 = require("@elementor/schema");
 var dropShadowFilterPropTypeUtil = createPropUtils(
   "drop-shadow",
-  import_schema29.z.object({
+  import_schema32.z.object({
     xAxis: unknownChildrenSchema,
     yAxis: unknownChildrenSchema,
     blur: unknownChildrenSchema,
@@ -427,37 +462,37 @@ var dropShadowFilterPropTypeUtil = createPropUtils(
 );
 
 // src/prop-types/filter-prop-types/filter-functions/blur-filter.ts
-var import_schema30 = require("@elementor/schema");
+var import_schema33 = require("@elementor/schema");
 var blurFilterPropTypeUtil = createPropUtils(
   "blur",
-  import_schema30.z.strictObject({
+  import_schema33.z.strictObject({
     size: unknownChildrenSchema
   })
 );
 
 // src/prop-types/filter-prop-types/filter-functions/color-tone-filter.ts
-var import_schema31 = require("@elementor/schema");
+var import_schema34 = require("@elementor/schema");
 var colorToneFilterPropTypeUtil = createPropUtils(
   "color-tone",
-  import_schema31.z.strictObject({
+  import_schema34.z.strictObject({
     size: unknownChildrenSchema
   })
 );
 
 // src/prop-types/filter-prop-types/filter-functions/hue-rotate-filter.ts
-var import_schema32 = require("@elementor/schema");
+var import_schema35 = require("@elementor/schema");
 var hueRotateFilterPropTypeUtil = createPropUtils(
   "hue-rotate",
-  import_schema32.z.strictObject({
+  import_schema35.z.strictObject({
     size: unknownChildrenSchema
   })
 );
 
 // src/prop-types/filter-prop-types/filter-functions/intensity-filter.ts
-var import_schema33 = require("@elementor/schema");
+var import_schema36 = require("@elementor/schema");
 var intensityFilterPropTypeUtil = createPropUtils(
   "intensity",
-  import_schema33.z.strictObject({
+  import_schema36.z.strictObject({
     size: unknownChildrenSchema
   })
 );
@@ -465,9 +500,9 @@ var intensityFilterPropTypeUtil = createPropUtils(
 // src/prop-types/filter-prop-types/filter.ts
 var cssFilterFunctionPropUtil = createPropUtils(
   "css-filter-func",
-  import_schema34.z.object({
+  import_schema37.z.object({
     func: stringPropTypeUtil.schema,
-    args: import_schema34.z.union([
+    args: import_schema37.z.union([
       blurFilterPropTypeUtil.schema,
       intensityFilterPropTypeUtil.schema,
       colorToneFilterPropTypeUtil.schema,
@@ -476,13 +511,13 @@ var cssFilterFunctionPropUtil = createPropUtils(
     ])
   })
 );
-var filterPropTypeUtil = createPropUtils("filter", import_schema34.z.array(cssFilterFunctionPropUtil.schema));
+var filterPropTypeUtil = createPropUtils("filter", import_schema37.z.array(cssFilterFunctionPropUtil.schema));
 
 // src/prop-types/transform-prop-types/transform.ts
-var import_schema35 = require("@elementor/schema");
+var import_schema38 = require("@elementor/schema");
 var transformPropTypeUtil = createPropUtils(
   "transform",
-  import_schema35.z.strictObject({
+  import_schema38.z.strictObject({
     "transform-functions": unknownChildrenSchema,
     "transform-origin": unknownChildrenSchema,
     perspective: unknownChildrenSchema,
@@ -491,10 +526,10 @@ var transformPropTypeUtil = createPropUtils(
 );
 
 // src/prop-types/transform-prop-types/transform-functions.ts
-var import_schema40 = require("@elementor/schema");
+var import_schema43 = require("@elementor/schema");
 
 // src/prop-types/transform-prop-types/transform-functions/move-transform.ts
-var import_schema36 = require("@elementor/schema");
+var import_schema39 = require("@elementor/schema");
 
 // src/prop-types/transform-prop-types/types.ts
 var TransformFunctionKeys = {
@@ -507,7 +542,7 @@ var TransformFunctionKeys = {
 // src/prop-types/transform-prop-types/transform-functions/move-transform.ts
 var moveTransformPropTypeUtil = createPropUtils(
   TransformFunctionKeys.move,
-  import_schema36.z.strictObject({
+  import_schema39.z.strictObject({
     x: unknownChildrenSchema,
     y: unknownChildrenSchema,
     z: unknownChildrenSchema
@@ -515,10 +550,10 @@ var moveTransformPropTypeUtil = createPropUtils(
 );
 
 // src/prop-types/transform-prop-types/transform-functions/rotate-transform.ts
-var import_schema37 = require("@elementor/schema");
+var import_schema40 = require("@elementor/schema");
 var rotateTransformPropTypeUtil = createPropUtils(
   TransformFunctionKeys.rotate,
-  import_schema37.z.strictObject({
+  import_schema40.z.strictObject({
     x: unknownChildrenSchema,
     y: unknownChildrenSchema,
     z: unknownChildrenSchema
@@ -526,10 +561,10 @@ var rotateTransformPropTypeUtil = createPropUtils(
 );
 
 // src/prop-types/transform-prop-types/transform-functions/scale-transform.ts
-var import_schema38 = require("@elementor/schema");
+var import_schema41 = require("@elementor/schema");
 var scaleTransformPropTypeUtil = createPropUtils(
   TransformFunctionKeys.scale,
-  import_schema38.z.strictObject({
+  import_schema41.z.strictObject({
     x: numberPropTypeUtil.schema.nullable(),
     y: numberPropTypeUtil.schema.nullable(),
     z: numberPropTypeUtil.schema.nullable()
@@ -537,10 +572,10 @@ var scaleTransformPropTypeUtil = createPropUtils(
 );
 
 // src/prop-types/transform-prop-types/transform-functions/skew-transform.ts
-var import_schema39 = require("@elementor/schema");
+var import_schema42 = require("@elementor/schema");
 var skewTransformPropTypeUtil = createPropUtils(
   TransformFunctionKeys.skew,
-  import_schema39.z.strictObject({
+  import_schema42.z.strictObject({
     x: unknownChildrenSchema,
     y: unknownChildrenSchema
   })
@@ -548,13 +583,13 @@ var skewTransformPropTypeUtil = createPropUtils(
 
 // src/prop-types/transform-prop-types/transform-functions.ts
 var filterTypes = moveTransformPropTypeUtil.schema.or(scaleTransformPropTypeUtil.schema).or(rotateTransformPropTypeUtil.schema).or(skewTransformPropTypeUtil.schema);
-var transformFunctionsPropTypeUtil = createPropUtils("transform-functions", import_schema40.z.array(filterTypes));
+var transformFunctionsPropTypeUtil = createPropUtils("transform-functions", import_schema43.z.array(filterTypes));
 
 // src/prop-types/transform-prop-types/transform-origin.ts
-var import_schema41 = require("@elementor/schema");
+var import_schema44 = require("@elementor/schema");
 var transformOriginPropTypeUtil = createPropUtils(
   "transform-origin",
-  import_schema41.z.strictObject({
+  import_schema44.z.strictObject({
     x: unknownChildrenSchema,
     y: unknownChildrenSchema,
     z: unknownChildrenSchema
@@ -562,25 +597,345 @@ var transformOriginPropTypeUtil = createPropUtils(
 );
 
 // src/prop-types/transform-prop-types/perspective-origin.ts
-var import_schema42 = require("@elementor/schema");
+var import_schema45 = require("@elementor/schema");
 var perspectiveOriginPropTypeUtil = createPropUtils(
   "perspective-origin",
-  import_schema42.z.strictObject({
+  import_schema45.z.strictObject({
     x: unknownChildrenSchema,
     y: unknownChildrenSchema
   })
 );
 
 // src/prop-types/filter-prop-types/backdrop-filter.ts
-var import_schema43 = require("@elementor/schema");
+var import_schema46 = require("@elementor/schema");
 var backdropFilterPropTypeUtil = createPropUtils(
   "backdrop-filter",
-  import_schema43.z.array(cssFilterFunctionPropUtil.schema)
+  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 (typeof clone === "string") {
+    return stringPropTypeUtil.create(clone);
+  }
+  if (typeof clone === "number") {
+    return numberPropTypeUtil.create(clone);
+  }
+  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) {
+  const description = propType.meta?.description;
+  const schema = {};
+  if (description) {
+    schema.description = description;
+  }
+  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 };
+  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: subPropType.meta?.description,
+          $comment: `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";
+  const itemPropType = propType.item_prop_type;
+  if (itemPropType) {
+    schema.items = convertPropTypeToJsonSchema(itemPropType);
+  }
+  return schema;
+}
+function convertPropTypeToJsonSchema(propType) {
+  return propTypeToJsonSchema(propType);
+}
+var nonConfigurablePropKeys = ["_cssid", "classes", "attributes"];
+function isPropKeyConfigurable(propKey) {
+  return !nonConfigurablePropKeys.includes(propKey);
+}
+function configurableKeys(schema) {
+  return Object.keys(schema).filter(isPropKeyConfigurable);
+}
+
+// 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) {
-  const props = structuredClone(current);
+  let props = {};
+  if (!Array.isArray(current)) {
+    props = structuredClone(current);
+  }
   Object.entries(updates).forEach(([key, value]) => {
     if (value === null || value === void 0) {
       delete props[key];
@@ -591,27 +946,23 @@ function mergeProps(current, updates) {
   return props;
 }
 
-// src/utils/is-transformable.ts
-var import_schema44 = require("@elementor/schema");
-var transformableSchema = import_schema44.z.object({
-  $$type: import_schema44.z.string(),
-  value: import_schema44.z.any(),
-  disabled: import_schema44.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) {
-    return true;
+    return { isMet: true };
   }
   const { relation, terms } = dependency;
   const method = getRelationMethod(relation);
-  return terms[method](
-    (term) => isDependency(term) ? isDependencyMet(term, values) : evaluateTerm(term, extractValue(term.path, values)?.value)
-  );
+  const failingDependencies = [];
+  const isMet = terms[method]((term) => {
+    const isNestedDependency = isDependency(term);
+    const result = isNestedDependency ? isDependencyMet(term, values).isMet : evaluateTerm(term, extractValue(term.path, values)?.value);
+    if (!result && !isNestedDependency) {
+      failingDependencies.push(term);
+    }
+    return result;
+  });
+  return { isMet, failingDependencies };
 }
 function evaluateTerm(term, actualValue) {
   const { value: valueToCompare, operator } = term;
@@ -674,35 +1025,20 @@ 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,
+  isPropKeyConfigurable,
+  nonConfigurablePropKeys,
+  configurableKeys
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CLASSES_PROP_KEY,
+  DateTimePropTypeUtil,
+  Schema,
   backdropFilterPropTypeUtil,
   backgroundColorOverlayPropTypeUtil,
   backgroundGradientOverlayPropTypeUtil,
@@ -731,7 +1067,9 @@ var isNullishObject = (value) => {
   filterEmptyValues,
   filterPropTypeUtil,
   flexPropTypeUtil,
+  getPropSchemaFromCache,
   gradientColorStopPropTypeUtil,
+  htmlPropTypeUtil,
   hueRotateFilterPropTypeUtil,
   imageAttachmentIdPropType,
   imagePropTypeUtil,
@@ -749,6 +1087,7 @@ var isNullishObject = (value) => {
   numberPropTypeUtil,
   perspectiveOriginPropTypeUtil,
   positionPropTypeUtil,
+  queryPropTypeUtil,
   rotateTransformPropTypeUtil,
   scaleTransformPropTypeUtil,
   selectionSizePropTypeUtil,