@petrarca/sonnet-core 0.5.0 → 0.6.0

package/dist/schema/index.js

@@ -96,6 +96,48 @@ function hasProperties(schema) {
   return Object.keys(schema.properties || {}).length > 0;
 }
 
+// src/schema/variant.ts
+function isOneOf(property) {
+  return Array.isArray(property.oneOf) && property.oneOf.length > 0;
+}
+function getDiscriminator(property) {
+  const explicit = property.discriminator?.propertyName;
+  if (typeof explicit === "string" && explicit) return explicit;
+  const branches = property.oneOf;
+  if (!Array.isArray(branches) || branches.length === 0) return void 0;
+  const first = branches[0].properties ?? {};
+  const candidates = Object.keys(first).filter(
+    (k) => first[k]?.const !== void 0
+  );
+  return candidates.find(
+    (key) => branches.every((b) => b.properties?.[key]?.const !== void 0)
+  );
+}
+function getBranchValue(branch, discriminator) {
+  const c = branch.properties?.[discriminator]?.const;
+  if (typeof c === "string" || typeof c === "number" || typeof c === "boolean") {
+    return c;
+  }
+  return void 0;
+}
+function getBranchLabel(branch, discriminator, index) {
+  if (branch.title) return branch.title;
+  if (discriminator) {
+    const v = getBranchValue(branch, discriminator);
+    if (v !== void 0) return String(v);
+  }
+  return `Option ${index + 1}`;
+}
+function findActiveBranch(property, data, discriminator) {
+  const branches = property.oneOf;
+  if (!Array.isArray(branches) || !discriminator || !data) return -1;
+  const current = data[discriminator];
+  if (current === void 0) return -1;
+  return branches.findIndex(
+    (b) => getBranchValue(b, discriminator) === current
+  );
+}
+
 // src/schema/schemaResolver.ts
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
@@ -112,9 +154,29 @@ function resolveSchema(schema, formData) {
     return schema;
   }
   let resolvedSchema = resolveAllOf(schema, formData);
+  resolvedSchema = resolveAnyOfConditionals(resolvedSchema, formData);
   resolvedSchema = resolveConditionals(resolvedSchema, formData);
   return resolvedSchema;
 }
+function resolveAnyOfConditionals(schema, formData) {
+  if (!schema.anyOf || !Array.isArray(schema.anyOf)) return schema;
+  const conditionalMembers = schema.anyOf.filter(
+    (m) => typeof m === "object" && m !== null && "if" in m
+  );
+  if (conditionalMembers.length === 0) return schema;
+  const nonConditionalMembers = schema.anyOf.filter(
+    (m) => !(typeof m === "object" && m !== null && "if" in m)
+  );
+  const { anyOf: _anyOf, ...baseSchema } = schema;
+  let result = nonConditionalMembers.length > 0 ? { ...baseSchema, anyOf: nonConditionalMembers } : baseSchema;
+  for (const member of conditionalMembers) {
+    const resolved = resolveConditionals(member, formData);
+    if (resolved !== member && typeof resolved === "object") {
+      result = mergeSchemas(result, resolved);
+    }
+  }
+  return result;
+}
 function resolveConditionals(schema, formData) {
   if (!schema.if) {
     return schema;
@@ -212,6 +274,65 @@ function hasConditionals(schema) {
   return !!(schema.if || schema.allOf || schema.anyOf || schema.oneOf);
 }
 
+// src/schema/uiRule.ts
+var validatorCache = /* @__PURE__ */ new Map();
+function getValidator(schema) {
+  const key = JSON.stringify(schema);
+  let validator = validatorCache.get(key);
+  if (!validator) {
+    validator = ajv.compile(schema);
+    validatorCache.set(key, validator);
+  }
+  return validator;
+}
+var VISIBLE_ENABLED = { visible: true, enabled: true };
+function unescapeToken(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function getAtPointer(data, pointer) {
+  if (pointer === "") return data;
+  if (!pointer.startsWith("/")) return void 0;
+  const tokens = pointer.slice(1).split("/").map(unescapeToken);
+  let current = data;
+  for (const token of tokens) {
+    if (current == null || typeof current !== "object") return void 0;
+    if (Array.isArray(current)) {
+      const idx = Number(token);
+      if (!Number.isInteger(idx) || idx < 0 || idx >= current.length)
+        return void 0;
+      current = current[idx];
+    } else {
+      current = current[token];
+    }
+  }
+  return current;
+}
+function conditionHolds(rule, formData) {
+  const { scope, schema } = rule.condition;
+  const value = getAtPointer(formData, scope);
+  try {
+    const validator = getValidator(schema);
+    return !!validator(value);
+  } catch (error) {
+    warnLog("Error evaluating x-ui-rule condition:", error);
+    return false;
+  }
+}
+function evaluateUiRule(rule, formData) {
+  if (!rule) return VISIBLE_ENABLED;
+  const holds = conditionHolds(rule, formData);
+  switch (rule.effect) {
+    case "show":
+      return { visible: holds, enabled: true };
+    case "hide":
+      return { visible: !holds, enabled: true };
+    case "enable":
+      return { visible: true, enabled: holds };
+    case "disable":
+      return { visible: true, enabled: !holds };
+  }
+}
+
 // src/schema/schemaUtils.ts
 function applySchemaDefaults(data, schema) {
   const result = { ...data };
@@ -269,51 +390,56 @@ function extractDefName(ref) {
   const match = ref.match(/^#\/(\$defs|definitions)\/(.+)$/);
   return match ? match[2] : null;
 }
-function resolveRef(node, defs, seen) {
+function inDocumentResolver(defs) {
+  return (ref) => {
+    const name = extractDefName(ref);
+    return name ? defs[name] : void 0;
+  };
+}
+function resolveRef(node, resolve, seen) {
   const ref = node.$ref;
-  const name = extractDefName(ref);
-  if (!name || !defs[name]) return node;
+  const resolved = resolve(ref);
+  if (!resolved) return node;
   if (seen.has(ref)) return node;
   seen.add(ref);
-  const resolved = defs[name];
   const overrides = Object.fromEntries(
     Object.entries(node).filter(([k]) => k !== "$ref")
   );
   const merged = Object.keys(overrides).length > 0 ? { ...resolved, ...overrides } : resolved;
-  const result = resolveNode(merged, defs, seen);
+  const result = resolveNode(merged, resolve, seen);
   seen.delete(ref);
   return result;
 }
-function resolveList(list, defs, seen) {
-  const resolved = list.map((s) => resolveNode(s, defs, seen));
+function resolveList(list, resolve, seen) {
+  const resolved = list.map((s) => resolveNode(s, resolve, seen));
   return resolved.some((s, i) => s !== list[i]) ? resolved : null;
 }
-function resolveProperties(props, defs, seen) {
+function resolveProperties(props, resolve, seen) {
   const entries = Object.entries(props);
   const resolved = entries.map(
-    ([k, v]) => [k, resolveNode(v, defs, seen)]
+    ([k, v]) => [k, resolveNode(v, resolve, seen)]
   );
   return resolved.some(([, v], i) => v !== entries[i][1]) ? Object.fromEntries(resolved) : null;
 }
-function resolveItems(items, defs, seen) {
-  const r = resolveNode(items, defs, seen);
+function resolveItems(items, resolve, seen) {
+  const r = resolveNode(items, resolve, seen);
   return r !== items ? r : null;
 }
-function resolveChildren(node, defs, seen) {
+function resolveChildren(node, resolve, seen) {
   const overrides = {};
   let changed = false;
-  const props = node.properties ? resolveProperties(node.properties, defs, seen) : null;
+  const props = node.properties ? resolveProperties(node.properties, resolve, seen) : null;
   if (props) {
     overrides.properties = props;
     changed = true;
   }
-  const items = node.items ? resolveItems(node.items, defs, seen) : null;
+  const items = node.items ? resolveItems(node.items, resolve, seen) : null;
   if (items) {
     overrides.items = items;
     changed = true;
   }
   for (const key of ["allOf", "anyOf", "oneOf"]) {
-    const list = node[key] ? resolveList(node[key], defs, seen) : null;
+    const list = node[key] ? resolveList(node[key], resolve, seen) : null;
     if (list) {
       overrides[key] = list;
       changed = true;
@@ -321,39 +447,60 @@ function resolveChildren(node, defs, seen) {
   }
   return changed ? overrides : null;
 }
-function resolveNode(node, defs, seen) {
-  if (node.$ref) return resolveRef(node, defs, seen);
-  const overrides = resolveChildren(node, defs, seen);
+function resolveNode(node, resolve, seen) {
+  if (node.$ref) return resolveRef(node, resolve, seen);
+  const overrides = resolveChildren(node, resolve, seen);
   return overrides ? { ...node, ...overrides } : node;
 }
-function resolveRefs(schema) {
+function resolveRefs(schema, resolve) {
   const defs = schema.$defs ?? schema.definitions ?? {};
-  if (Object.keys(defs).length === 0) return schema;
+  if (!resolve && Object.keys(defs).length === 0) return schema;
+  const fallback = inDocumentResolver(defs);
+  const resolver = resolve ? (ref) => resolve(ref) ?? fallback(ref) : fallback;
   const seen = /* @__PURE__ */ new Set();
   const resolved = resolveNode(
     schema,
-    defs,
+    resolver,
     seen
   );
   return resolved;
 }
 
 // src/schema/validateFormData.ts
+function escapePointerToken(token) {
+  return token.replace(/~/g, "~0").replace(/\//g, "~1");
+}
 function isEmpty(value) {
   return value === void 0 || value === null || value === "";
 }
-function fieldLabel(path, fieldName, property) {
-  return path ? `${path} > ${getFieldTitle(fieldName, property)}` : getFieldTitle(fieldName, property);
-}
 function isPlainObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function validateArray(property, value, label, errors) {
+function childContext(parent, fieldName, property) {
+  const title = getFieldTitle(fieldName, property);
+  return {
+    label: parent.label ? `${parent.label} > ${title}` : title,
+    pointer: `${parent.pointer}/${escapePointerToken(fieldName)}`
+  };
+}
+function itemContext(parent, index) {
+  return {
+    label: `${parent.label}[${index + 1}]`,
+    pointer: `${parent.pointer}/${index}`
+  };
+}
+function validateArray(property, value, ctx, out) {
   if (property.minItems !== void 0 && value.length < property.minItems) {
-    errors.push(`${label} requires at least ${property.minItems} item(s)`);
+    out.push({
+      pointer: ctx.pointer,
+      message: `${ctx.label} requires at least ${property.minItems} item(s)`
+    });
   }
   if (property.maxItems !== void 0 && value.length > property.maxItems) {
-    errors.push(`${label} allows at most ${property.maxItems} item(s)`);
+    out.push({
+      pointer: ctx.pointer,
+      message: `${ctx.label} allows at most ${property.maxItems} item(s)`
+    });
   }
   if (!property.items?.properties) return;
   const itemProperties = property.items.properties;
@@ -364,8 +511,8 @@ function validateArray(property, value, label, errors) {
         itemProperties,
         itemSchema,
         value[i],
-        `${label}[${i + 1}]`,
-        errors
+        itemContext(ctx, i),
+        out
       );
     }
   }
@@ -373,32 +520,47 @@ function validateArray(property, value, label, errors) {
 function isNestedObject(property, value) {
   return property.type === "object" && !!property.properties && isPlainObject(value);
 }
-function validateField(property, value, required, label, errors) {
+function validateField(property, value, required, ctx, out) {
   if (required && isEmpty(value)) {
-    errors.push(`${label} is required`);
+    out.push({ pointer: ctx.pointer, message: `${ctx.label} is required` });
     return;
   }
   if (isNestedObject(property, value)) {
-    validateObject(property.properties, property, value, label, errors);
+    validateObject(property.properties, property, value, ctx, out);
     return;
   }
   if (property.type === "array" && Array.isArray(value)) {
-    validateArray(property, value, label, errors);
+    validateArray(property, value, ctx, out);
   }
 }
-function validateObject(properties, schema, data, path, errors) {
+function validateObject(properties, schema, data, ctx, out) {
   for (const fieldName of Object.keys(properties)) {
     const property = properties[fieldName];
     const required = schema.required?.includes(fieldName) ?? false;
-    const label = fieldLabel(path, fieldName, property);
-    validateField(property, data[fieldName], required, label, errors);
+    validateField(
+      property,
+      data[fieldName],
+      required,
+      childContext(ctx, fieldName, property),
+      out
+    );
   }
 }
 function validateFormData(schema, data) {
-  const errors = [];
+  const fieldErrors = [];
   const properties = getSchemaProperties(schema);
-  validateObject(properties, schema, data, "", errors);
-  return { errors, isValid: errors.length === 0 };
+  validateObject(
+    properties,
+    schema,
+    data,
+    { label: "", pointer: "" },
+    fieldErrors
+  );
+  return {
+    errors: fieldErrors.map((e) => e.message),
+    fieldErrors,
+    isValid: fieldErrors.length === 0
+  };
 }
 
 // src/schema/diffFormData.ts
@@ -545,11 +707,18 @@ function diffFormData(original, updated) {
 }
 export {
   WIDTH_TOKEN_REMS,
+  ajv,
   applySchemaDefaults,
   diffFormData,
+  evaluateUiRule,
   extractEnumValues,
   extractSchemaDefaults,
+  findActiveBranch,
   generateJsonSchemaFromVariables,
+  getAtPointer,
+  getBranchLabel,
+  getBranchValue,
+  getDiscriminator,
   getFieldConstraints,
   getFieldDefault,
   getFieldHelpText,
@@ -565,6 +734,7 @@ export {
   isFieldOptional,
   isFieldRequired,
   isNullableBoolean,
+  isOneOf,
   matchesConst,
   resolveRefs,
   resolveSchema,