@fogpipe/forma-core 0.6.0

package/dist/engine/index.cjs

@@ -0,0 +1,885 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/engine/index.ts
+var engine_exports = {};
+__export(engine_exports, {
+  calculate: () => calculate,
+  calculateField: () => calculateField,
+  calculateWithErrors: () => calculateWithErrors,
+  getEnabled: () => getEnabled,
+  getFormattedValue: () => getFormattedValue,
+  getPageVisibility: () => getPageVisibility,
+  getRequired: () => getRequired,
+  getVisibility: () => getVisibility,
+  isEnabled: () => isEnabled,
+  isFieldVisible: () => isFieldVisible,
+  isRequired: () => isRequired,
+  validate: () => validate,
+  validateSingleField: () => validateSingleField
+});
+module.exports = __toCommonJS(engine_exports);
+
+// src/feel/index.ts
+var import_feelin = require("feelin");
+function buildFeelContext(ctx) {
+  const feelContext = {
+    // Spread form data directly so fields are accessible by name
+    ...ctx.data
+  };
+  if (ctx.computed) {
+    feelContext["computed"] = ctx.computed;
+  }
+  if (ctx.referenceData) {
+    feelContext["ref"] = ctx.referenceData;
+  }
+  if (ctx.item !== void 0) {
+    feelContext["item"] = ctx.item;
+  }
+  if (ctx.itemIndex !== void 0) {
+    feelContext["itemIndex"] = ctx.itemIndex;
+  }
+  if (ctx.value !== void 0) {
+    feelContext["value"] = ctx.value;
+  }
+  return feelContext;
+}
+function evaluate(expression, context) {
+  try {
+    const feelContext = buildFeelContext(context);
+    const result = (0, import_feelin.evaluate)(expression, feelContext);
+    return {
+      success: true,
+      value: result
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      expression
+    };
+  }
+}
+function evaluateBoolean(expression, context) {
+  const result = evaluate(expression, context);
+  if (!result.success) {
+    console.warn(
+      `FEEL expression error: ${result.error}
+Expression: ${result.expression}`
+    );
+    return false;
+  }
+  if (result.value === null || result.value === void 0) {
+    return false;
+  }
+  if (typeof result.value !== "boolean") {
+    console.warn(
+      `FEEL expression did not return boolean: ${expression}
+Got: ${typeof result.value}`
+    );
+    return false;
+  }
+  return result.value;
+}
+
+// src/engine/calculate.ts
+function calculate(data, spec) {
+  const result = calculateWithErrors(data, spec);
+  return result.values;
+}
+function calculateWithErrors(data, spec) {
+  if (!spec.computed) {
+    return { values: {}, errors: [] };
+  }
+  const values = {};
+  const errors = [];
+  const orderedFields = getComputationOrder(spec.computed);
+  for (const fieldName of orderedFields) {
+    const fieldDef = spec.computed[fieldName];
+    if (!fieldDef) continue;
+    const result = evaluateComputedField(
+      fieldName,
+      fieldDef,
+      data,
+      values,
+      // Pass already-computed values for dependencies
+      spec.referenceData
+      // Pass reference data for lookups
+    );
+    if (result.success) {
+      values[fieldName] = result.value;
+    } else {
+      errors.push({
+        field: fieldName,
+        message: result.error,
+        expression: fieldDef.expression
+      });
+      values[fieldName] = null;
+    }
+  }
+  return { values, errors };
+}
+function evaluateComputedField(_name, fieldDef, data, computedSoFar, referenceData) {
+  const referencedComputed = findComputedReferences(fieldDef.expression);
+  for (const ref of referencedComputed) {
+    if (computedSoFar[ref] === null) {
+      return {
+        success: true,
+        value: null
+      };
+    }
+  }
+  const context = {
+    data,
+    computed: computedSoFar,
+    referenceData
+  };
+  const result = evaluate(fieldDef.expression, context);
+  if (!result.success) {
+    return {
+      success: false,
+      error: result.error
+    };
+  }
+  if (typeof result.value === "number" && !Number.isFinite(result.value)) {
+    return {
+      success: true,
+      value: null
+    };
+  }
+  return {
+    success: true,
+    value: result.value
+  };
+}
+function findComputedReferences(expression) {
+  const refs = [];
+  const regex = /computed\.(\w+)/g;
+  let match;
+  while ((match = regex.exec(expression)) !== null) {
+    refs.push(match[1]);
+  }
+  return refs;
+}
+function getComputationOrder(computed) {
+  const fieldNames = Object.keys(computed);
+  const deps = /* @__PURE__ */ new Map();
+  for (const name of fieldNames) {
+    deps.set(name, findComputedDependencies(computed[name].expression, fieldNames));
+  }
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(name) {
+    if (visited.has(name)) return;
+    if (visiting.has(name)) {
+      console.warn(`Circular dependency detected in computed field: ${name}`);
+      sorted.push(name);
+      visited.add(name);
+      return;
+    }
+    visiting.add(name);
+    const fieldDeps = deps.get(name) ?? /* @__PURE__ */ new Set();
+    for (const dep of fieldDeps) {
+      visit(dep);
+    }
+    visiting.delete(name);
+    visited.add(name);
+    sorted.push(name);
+  }
+  for (const name of fieldNames) {
+    visit(name);
+  }
+  return sorted;
+}
+function findComputedDependencies(expression, availableFields) {
+  const deps = /* @__PURE__ */ new Set();
+  const regex = /computed\.(\w+)/g;
+  let match;
+  while ((match = regex.exec(expression)) !== null) {
+    const fieldName = match[1];
+    if (availableFields.includes(fieldName)) {
+      deps.add(fieldName);
+    }
+  }
+  return deps;
+}
+function getFormattedValue(fieldName, data, spec) {
+  var _a;
+  if (!((_a = spec.computed) == null ? void 0 : _a[fieldName])) {
+    return null;
+  }
+  const fieldDef = spec.computed[fieldName];
+  const computed = calculate(data, spec);
+  const value = computed[fieldName];
+  if (value === null || value === void 0) {
+    return null;
+  }
+  return formatValue(value, fieldDef.format);
+}
+function formatValue(value, format) {
+  if (!format) {
+    return String(value);
+  }
+  const decimalMatch = format.match(/^decimal\((\d+)\)$/);
+  if (decimalMatch) {
+    const decimals = parseInt(decimalMatch[1], 10);
+    return typeof value === "number" ? value.toFixed(decimals) : String(value);
+  }
+  if (format === "currency") {
+    return typeof value === "number" ? new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency: "USD"
+    }).format(value) : String(value);
+  }
+  if (format === "percent") {
+    return typeof value === "number" ? new Intl.NumberFormat("en-US", {
+      style: "percent",
+      minimumFractionDigits: 1
+    }).format(value) : String(value);
+  }
+  return String(value);
+}
+function calculateField(fieldName, data, spec) {
+  const computed = calculate(data, spec);
+  return computed[fieldName] ?? null;
+}
+
+// src/engine/visibility.ts
+function getVisibility(data, spec, options = {}) {
+  const computed = options.computed ?? calculate(data, spec);
+  const baseContext = {
+    data,
+    computed,
+    referenceData: spec.referenceData
+  };
+  const result = {};
+  for (const fieldPath of spec.fieldOrder) {
+    const fieldDef = spec.fields[fieldPath];
+    if (fieldDef) {
+      evaluateFieldVisibility(fieldPath, fieldDef, data, baseContext, result);
+    }
+  }
+  return result;
+}
+function evaluateFieldVisibility(path, fieldDef, data, context, result) {
+  if (fieldDef.visibleWhen) {
+    result[path] = evaluateBoolean(fieldDef.visibleWhen, context);
+  } else {
+    result[path] = true;
+  }
+  if (!result[path]) {
+    return;
+  }
+  if (fieldDef.itemFields) {
+    const arrayData = data[path];
+    if (Array.isArray(arrayData)) {
+      evaluateArrayItemVisibility(path, fieldDef, arrayData, context, result);
+    }
+  }
+}
+function evaluateArrayItemVisibility(arrayPath, fieldDef, arrayData, baseContext, result) {
+  if (!fieldDef.itemFields) return;
+  for (let i = 0; i < arrayData.length; i++) {
+    const item = arrayData[i];
+    const itemContext = {
+      ...baseContext,
+      item,
+      itemIndex: i
+    };
+    for (const [fieldName, itemFieldDef] of Object.entries(fieldDef.itemFields)) {
+      const itemFieldPath = `${arrayPath}[${i}].${fieldName}`;
+      if (itemFieldDef.visibleWhen) {
+        result[itemFieldPath] = evaluateBoolean(itemFieldDef.visibleWhen, itemContext);
+      } else {
+        result[itemFieldPath] = true;
+      }
+    }
+  }
+}
+function isFieldVisible(fieldPath, data, spec, options = {}) {
+  const fieldDef = spec.fields[fieldPath];
+  if (!fieldDef) {
+    return true;
+  }
+  if (!fieldDef.visibleWhen) {
+    return true;
+  }
+  const computed = options.computed ?? calculate(data, spec);
+  const context = {
+    data,
+    computed,
+    referenceData: spec.referenceData
+  };
+  return evaluateBoolean(fieldDef.visibleWhen, context);
+}
+function getPageVisibility(data, spec, options = {}) {
+  if (!spec.pages) {
+    return {};
+  }
+  const computed = options.computed ?? calculate(data, spec);
+  const context = {
+    data,
+    computed,
+    referenceData: spec.referenceData
+  };
+  const result = {};
+  for (const page of spec.pages) {
+    if (page.visibleWhen) {
+      result[page.id] = evaluateBoolean(page.visibleWhen, context);
+    } else {
+      result[page.id] = true;
+    }
+  }
+  return result;
+}
+
+// src/engine/required.ts
+function getRequired(data, spec, options = {}) {
+  const computed = options.computed ?? calculate(data, spec);
+  const context = {
+    data,
+    computed,
+    referenceData: spec.referenceData
+  };
+  const result = {};
+  for (const fieldPath of spec.fieldOrder) {
+    const fieldDef = spec.fields[fieldPath];
+    if (fieldDef) {
+      result[fieldPath] = isFieldRequired(fieldPath, fieldDef, spec, context);
+    }
+  }
+  for (const [fieldPath, fieldDef] of Object.entries(spec.fields)) {
+    if (fieldDef.itemFields) {
+      const arrayData = data[fieldPath];
+      if (Array.isArray(arrayData)) {
+        for (let i = 0; i < arrayData.length; i++) {
+          const item = arrayData[i];
+          const itemContext = {
+            data,
+            computed,
+            referenceData: spec.referenceData,
+            item,
+            itemIndex: i
+          };
+          for (const [itemFieldName, itemFieldDef] of Object.entries(fieldDef.itemFields)) {
+            const itemFieldPath = `${fieldPath}[${i}].${itemFieldName}`;
+            result[itemFieldPath] = isFieldRequired(
+              itemFieldPath,
+              itemFieldDef,
+              spec,
+              itemContext
+            );
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+function isFieldRequired(fieldPath, fieldDef, spec, context) {
+  var _a;
+  if (fieldDef.requiredWhen) {
+    return evaluateBoolean(fieldDef.requiredWhen, context);
+  }
+  return ((_a = spec.schema.required) == null ? void 0 : _a.includes(fieldPath)) ?? false;
+}
+function isRequired(fieldPath, data, spec) {
+  var _a;
+  const fieldDef = spec.fields[fieldPath];
+  if (!fieldDef) {
+    return ((_a = spec.schema.required) == null ? void 0 : _a.includes(fieldPath)) ?? false;
+  }
+  const computed = calculate(data, spec);
+  const context = {
+    data,
+    computed,
+    referenceData: spec.referenceData
+  };
+  return isFieldRequired(fieldPath, fieldDef, spec, context);
+}
+
+// src/engine/enabled.ts
+function getEnabled(data, spec, options = {}) {
+  const computed = options.computed ?? calculate(data, spec);
+  const context = {
+    data,
+    computed,
+    referenceData: spec.referenceData
+  };
+  const result = {};
+  for (const fieldPath of spec.fieldOrder) {
+    const fieldDef = spec.fields[fieldPath];
+    if (fieldDef) {
+      result[fieldPath] = isFieldEnabled(fieldDef, context);
+    }
+  }
+  for (const [fieldPath, fieldDef] of Object.entries(spec.fields)) {
+    if (fieldDef.itemFields) {
+      const arrayData = data[fieldPath];
+      if (Array.isArray(arrayData)) {
+        for (let i = 0; i < arrayData.length; i++) {
+          const item = arrayData[i];
+          const itemContext = {
+            data,
+            computed,
+            referenceData: spec.referenceData,
+            item,
+            itemIndex: i
+          };
+          for (const [itemFieldName, itemFieldDef] of Object.entries(fieldDef.itemFields)) {
+            const itemFieldPath = `${fieldPath}[${i}].${itemFieldName}`;
+            result[itemFieldPath] = isFieldEnabled(itemFieldDef, itemContext);
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+function isFieldEnabled(fieldDef, context) {
+  if (fieldDef.enabledWhen) {
+    return evaluateBoolean(fieldDef.enabledWhen, context);
+  }
+  return true;
+}
+function isEnabled(fieldPath, data, spec) {
+  const fieldDef = spec.fields[fieldPath];
+  if (!fieldDef) {
+    return true;
+  }
+  if (!fieldDef.enabledWhen) {
+    return true;
+  }
+  const computed = calculate(data, spec);
+  const context = {
+    data,
+    computed,
+    referenceData: spec.referenceData
+  };
+  return evaluateBoolean(fieldDef.enabledWhen, context);
+}
+
+// src/engine/validate.ts
+function validate(data, spec, options = {}) {
+  const { onlyVisible = true } = options;
+  const computed = options.computed ?? calculate(data, spec);
+  const visibility = options.visibility ?? getVisibility(data, spec, { computed });
+  const errors = [];
+  for (const fieldPath of spec.fieldOrder) {
+    const fieldDef = spec.fields[fieldPath];
+    if (!fieldDef) continue;
+    if (onlyVisible && visibility[fieldPath] === false) {
+      continue;
+    }
+    const schemaProperty = spec.schema.properties[fieldPath];
+    const fieldErrors = validateField(
+      fieldPath,
+      data[fieldPath],
+      fieldDef,
+      schemaProperty,
+      spec,
+      data,
+      computed,
+      visibility,
+      onlyVisible
+    );
+    errors.push(...fieldErrors);
+  }
+  return {
+    valid: errors.filter((e) => e.severity === "error").length === 0,
+    errors
+  };
+}
+function validateField(path, value, fieldDef, schemaProperty, spec, data, computed, visibility, onlyVisible) {
+  const errors = [];
+  const context = {
+    data,
+    computed,
+    referenceData: spec.referenceData,
+    value
+  };
+  const required = isFieldRequired(path, fieldDef, spec, context);
+  if (required && isEmpty(value)) {
+    errors.push({
+      field: path,
+      message: fieldDef.label ? `${fieldDef.label} is required` : "This field is required",
+      severity: "error"
+    });
+  }
+  if (!isEmpty(value) && schemaProperty) {
+    const typeError = validateType(path, value, schemaProperty, fieldDef);
+    if (typeError) {
+      errors.push(typeError);
+    }
+  }
+  if (fieldDef.validations && !isEmpty(value)) {
+    const customErrors = validateCustomRules(path, fieldDef.validations, context);
+    errors.push(...customErrors);
+  }
+  if (Array.isArray(value) && fieldDef.itemFields) {
+    const arrayErrors = validateArray(
+      path,
+      value,
+      fieldDef,
+      spec,
+      data,
+      computed,
+      visibility,
+      onlyVisible
+    );
+    errors.push(...arrayErrors);
+  }
+  return errors;
+}
+function isEmpty(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string" && value.trim() === "") return true;
+  if (Array.isArray(value) && value.length === 0) return true;
+  return false;
+}
+function validateType(path, value, schema, fieldDef) {
+  const label = fieldDef.label ?? path;
+  switch (schema.type) {
+    case "string": {
+      if (typeof value !== "string") {
+        return {
+          field: path,
+          message: `${label} must be a string`,
+          severity: "error"
+        };
+      }
+      if ("minLength" in schema && schema.minLength !== void 0) {
+        if (value.length < schema.minLength) {
+          return {
+            field: path,
+            message: `${label} must be at least ${schema.minLength} characters`,
+            severity: "error"
+          };
+        }
+      }
+      if ("maxLength" in schema && schema.maxLength !== void 0) {
+        if (value.length > schema.maxLength) {
+          return {
+            field: path,
+            message: `${label} must be no more than ${schema.maxLength} characters`,
+            severity: "error"
+          };
+        }
+      }
+      if ("pattern" in schema && schema.pattern) {
+        const regex = new RegExp(schema.pattern);
+        if (!regex.test(value)) {
+          return {
+            field: path,
+            message: `${label} format is invalid`,
+            severity: "error"
+          };
+        }
+      }
+      if ("enum" in schema && schema.enum) {
+        if (!schema.enum.includes(value)) {
+          return {
+            field: path,
+            message: `${label} must be one of: ${schema.enum.join(", ")}`,
+            severity: "error"
+          };
+        }
+      }
+      if ("format" in schema && schema.format) {
+        const formatError = validateFormat(path, value, schema.format, label);
+        if (formatError) return formatError;
+      }
+      return null;
+    }
+    case "number":
+    case "integer": {
+      if (typeof value !== "number") {
+        return {
+          field: path,
+          message: `${label} must be a number`,
+          severity: "error"
+        };
+      }
+      if (schema.type === "integer" && !Number.isInteger(value)) {
+        return {
+          field: path,
+          message: `${label} must be a whole number`,
+          severity: "error"
+        };
+      }
+      if ("minimum" in schema && schema.minimum !== void 0) {
+        if (value < schema.minimum) {
+          return {
+            field: path,
+            message: `${label} must be at least ${schema.minimum}`,
+            severity: "error"
+          };
+        }
+      }
+      if ("maximum" in schema && schema.maximum !== void 0) {
+        if (value > schema.maximum) {
+          return {
+            field: path,
+            message: `${label} must be no more than ${schema.maximum}`,
+            severity: "error"
+          };
+        }
+      }
+      if ("exclusiveMinimum" in schema && schema.exclusiveMinimum !== void 0) {
+        if (value <= schema.exclusiveMinimum) {
+          return {
+            field: path,
+            message: `${label} must be greater than ${schema.exclusiveMinimum}`,
+            severity: "error"
+          };
+        }
+      }
+      if ("exclusiveMaximum" in schema && schema.exclusiveMaximum !== void 0) {
+        if (value >= schema.exclusiveMaximum) {
+          return {
+            field: path,
+            message: `${label} must be less than ${schema.exclusiveMaximum}`,
+            severity: "error"
+          };
+        }
+      }
+      return null;
+    }
+    case "boolean": {
+      if (typeof value !== "boolean") {
+        return {
+          field: path,
+          message: `${label} must be true or false`,
+          severity: "error"
+        };
+      }
+      return null;
+    }
+    case "array": {
+      if (!Array.isArray(value)) {
+        return {
+          field: path,
+          message: `${label} must be a list`,
+          severity: "error"
+        };
+      }
+      return null;
+    }
+    case "object": {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return {
+          field: path,
+          message: `${label} must be an object`,
+          severity: "error"
+        };
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+function validateFormat(path, value, format, label) {
+  switch (format) {
+    case "email": {
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+      if (!emailRegex.test(value)) {
+        return {
+          field: path,
+          message: `${label} must be a valid email address`,
+          severity: "error"
+        };
+      }
+      return null;
+    }
+    case "date": {
+      const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
+      if (!dateRegex.test(value)) {
+        return {
+          field: path,
+          message: `${label} must be a valid date`,
+          severity: "error"
+        };
+      }
+      const parsed = /* @__PURE__ */ new Date(value + "T00:00:00Z");
+      if (isNaN(parsed.getTime()) || parsed.toISOString().slice(0, 10) !== value) {
+        return {
+          field: path,
+          message: `${label} must be a valid date`,
+          severity: "error"
+        };
+      }
+      return null;
+    }
+    case "date-time": {
+      if (isNaN(Date.parse(value))) {
+        return {
+          field: path,
+          message: `${label} must be a valid date and time`,
+          severity: "error"
+        };
+      }
+      return null;
+    }
+    case "uri": {
+      try {
+        new URL(value);
+        return null;
+      } catch {
+        return {
+          field: path,
+          message: `${label} must be a valid URL`,
+          severity: "error"
+        };
+      }
+    }
+    case "uuid": {
+      const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+      if (!uuidRegex.test(value)) {
+        return {
+          field: path,
+          message: `${label} must be a valid UUID`,
+          severity: "error"
+        };
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+function validateCustomRules(path, rules, context) {
+  const errors = [];
+  for (const rule of rules) {
+    const isValid = evaluateBoolean(rule.rule, context);
+    if (!isValid) {
+      errors.push({
+        field: path,
+        message: rule.message,
+        severity: rule.severity ?? "error"
+      });
+    }
+  }
+  return errors;
+}
+function validateArray(path, value, fieldDef, spec, data, computed, visibility, onlyVisible) {
+  const errors = [];
+  const label = fieldDef.label ?? path;
+  if (fieldDef.minItems !== void 0 && value.length < fieldDef.minItems) {
+    errors.push({
+      field: path,
+      message: `${label} must have at least ${fieldDef.minItems} items`,
+      severity: "error"
+    });
+  }
+  if (fieldDef.maxItems !== void 0 && value.length > fieldDef.maxItems) {
+    errors.push({
+      field: path,
+      message: `${label} must have no more than ${fieldDef.maxItems} items`,
+      severity: "error"
+    });
+  }
+  if (fieldDef.itemFields) {
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      const itemErrors = validateArrayItem(
+        path,
+        i,
+        item,
+        fieldDef.itemFields,
+        spec,
+        data,
+        computed,
+        visibility,
+        onlyVisible
+      );
+      errors.push(...itemErrors);
+    }
+  }
+  return errors;
+}
+function validateArrayItem(arrayPath, index, item, itemFields, spec, data, computed, visibility, onlyVisible) {
+  const errors = [];
+  for (const [fieldName, fieldDef] of Object.entries(itemFields)) {
+    const itemFieldPath = `${arrayPath}[${index}].${fieldName}`;
+    if (onlyVisible && visibility[itemFieldPath] === false) {
+      continue;
+    }
+    const value = item[fieldName];
+    const context = {
+      data,
+      computed,
+      referenceData: spec.referenceData,
+      item,
+      itemIndex: index,
+      value
+    };
+    const isRequired2 = fieldDef.requiredWhen ? evaluateBoolean(fieldDef.requiredWhen, context) : false;
+    if (isRequired2 && isEmpty(value)) {
+      errors.push({
+        field: itemFieldPath,
+        message: fieldDef.label ? `${fieldDef.label} is required` : "This field is required",
+        severity: "error"
+      });
+    }
+    if (fieldDef.validations && !isEmpty(value)) {
+      const customErrors = validateCustomRules(itemFieldPath, fieldDef.validations, context);
+      errors.push(...customErrors);
+    }
+  }
+  return errors;
+}
+function validateSingleField(fieldPath, data, spec) {
+  const fieldDef = spec.fields[fieldPath];
+  if (!fieldDef) {
+    return [];
+  }
+  const computed = calculate(data, spec);
+  const visibility = getVisibility(data, spec, { computed });
+  const schemaProperty = spec.schema.properties[fieldPath];
+  return validateField(
+    fieldPath,
+    data[fieldPath],
+    fieldDef,
+    schemaProperty,
+    spec,
+    data,
+    computed,
+    visibility,
+    true
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculate,
+  calculateField,
+  calculateWithErrors,
+  getEnabled,
+  getFormattedValue,
+  getPageVisibility,
+  getRequired,
+  getVisibility,
+  isEnabled,
+  isFieldVisible,
+  isRequired,
+  validate,
+  validateSingleField
+});
+//# sourceMappingURL=index.cjs.map