@fogpipe/forma-core 0.6.0 → 0.8.0

package/dist/engine/required.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Required Fields Engine
+ *
+ * Determines which fields are currently required based on
+ * conditional requiredWhen expressions and schema required array.
+ */
+import type { Forma, FieldDefinition, EvaluationContext, RequiredFieldsResult } from "../types.js";
+export interface RequiredOptions {
+    /** Pre-calculated computed values */
+    computed?: Record<string, unknown>;
+}
+/**
+ * Determine which fields are currently required
+ *
+ * Returns a map of field paths to boolean required states.
+ * Evaluates requiredWhen expressions for conditional requirements.
+ *
+ * @param data - Current form data
+ * @param spec - Form specification
+ * @param options - Optional pre-calculated computed values
+ * @returns Map of field paths to required states
+ *
+ * @example
+ * const required = getRequired(
+ *   { hasInsurance: true },
+ *   forma
+ * );
+ * // => { hasInsurance: true, insuranceProvider: true, policyNumber: true }
+ */
+export declare function getRequired(data: Record<string, unknown>, spec: Forma, options?: RequiredOptions): RequiredFieldsResult;
+/**
+ * Check if a single field is required based on requiredWhen or schema
+ * @internal Exported for use by validate.ts
+ */
+export declare function isFieldRequired(fieldPath: string, fieldDef: FieldDefinition, spec: Forma, context: EvaluationContext): boolean;
+/**
+ * Check if a single field is currently required
+ *
+ * @param fieldPath - Path to the field
+ * @param data - Current form data
+ * @param spec - Form specification
+ * @returns True if the field is required
+ */
+export declare function isRequired(fieldPath: string, data: Record<string, unknown>, spec: Forma): boolean;
+//# sourceMappingURL=required.d.ts.map

package/dist/engine/required.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"required.d.ts","sourceRoot":"","sources":["../../src/engine/required.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EACV,KAAK,EACL,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACrB,MAAM,aAAa,CAAC;AAOrB,MAAM,WAAW,eAAe;IAC9B,qCAAqC;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,IAAI,EAAE,KAAK,EACX,OAAO,GAAE,eAAoB,GAC5B,oBAAoB,CAgDtB;AAMD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,eAAe,EACzB,IAAI,EAAE,KAAK,EACX,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAQT;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,IAAI,EAAE,KAAK,GACV,OAAO,CAcT"}

package/dist/engine/validate.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Validation Engine
+ *
+ * Validates form data against Forma rules including:
+ * - JSON Schema type validation
+ * - Required field validation (with conditional requiredWhen)
+ * - Custom FEEL validation rules
+ * - Array item validation
+ */
+import type { Forma, ValidationResult, FieldError } from "../types.js";
+export interface ValidateOptions {
+    /** Pre-calculated computed values */
+    computed?: Record<string, unknown>;
+    /** Pre-calculated visibility */
+    visibility?: Record<string, boolean>;
+    /** Only validate visible fields (default: true) */
+    onlyVisible?: boolean;
+}
+/**
+ * Validate form data against a Forma
+ *
+ * Performs comprehensive validation including:
+ * - Required field checks (respecting conditional requiredWhen)
+ * - JSON Schema type validation
+ * - Custom FEEL validation rules
+ * - Array min/max items validation
+ * - Array item field validation
+ *
+ * By default, only visible fields are validated.
+ *
+ * @param data - Current form data
+ * @param spec - Form specification
+ * @param options - Validation options
+ * @returns Validation result with valid flag and errors array
+ *
+ * @example
+ * const result = validate(
+ *   { name: "", age: 15 },
+ *   forma
+ * );
+ * // => {
+ * //   valid: false,
+ * //   errors: [
+ * //     { field: "name", message: "Name is required", severity: "error" },
+ * //     { field: "age", message: "Must be 18 or older", severity: "error" }
+ * //   ]
+ * // }
+ */
+export declare function validate(data: Record<string, unknown>, spec: Forma, options?: ValidateOptions): ValidationResult;
+/**
+ * Validate a single field
+ *
+ * @param fieldPath - Path to the field
+ * @param data - Current form data
+ * @param spec - Form specification
+ * @returns Array of errors for this field
+ */
+export declare function validateSingleField(fieldPath: string, data: Record<string, unknown>, spec: Forma): FieldError[];
+//# sourceMappingURL=validate.d.ts.map

package/dist/engine/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/engine/validate.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EACV,KAAK,EAIL,gBAAgB,EAChB,UAAU,EAEX,MAAM,aAAa,CAAC;AASrB,MAAM,WAAW,eAAe;IAC9B,qCAAqC;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,gCAAgC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,mDAAmD;IACnD,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,IAAI,EAAE,KAAK,EACX,OAAO,GAAE,eAAoB,GAC5B,gBAAgB,CA6ClB;AA2fD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,IAAI,EAAE,KAAK,GACV,UAAU,EAAE,CAqBd"}

package/dist/engine/visibility.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Visibility Engine
+ *
+ * Determines which fields should be visible based on form data
+ * and Forma visibility rules.
+ */
+import type { Forma, VisibilityResult } from "../types.js";
+export interface VisibilityOptions {
+    /** Pre-calculated computed values (avoids recalculation) */
+    computed?: Record<string, unknown>;
+}
+/**
+ * Determine visibility for all fields in a form
+ *
+ * Returns a map of field paths to boolean visibility states.
+ * Fields without visibleWhen expressions are always visible.
+ *
+ * @param data - Current form data
+ * @param spec - Form specification
+ * @param options - Optional pre-calculated computed values
+ * @returns Map of field paths to visibility states
+ *
+ * @example
+ * const visibility = getVisibility(
+ *   { age: 21, hasLicense: true },
+ *   forma
+ * );
+ * // => { age: true, hasLicense: true, vehicleType: true, ... }
+ */
+export declare function getVisibility(data: Record<string, unknown>, spec: Forma, options?: VisibilityOptions): VisibilityResult;
+/**
+ * Check if a single field is visible
+ *
+ * Useful for checking visibility of one field without computing all.
+ *
+ * @param fieldPath - Field path to check
+ * @param data - Current form data
+ * @param spec - Form specification
+ * @param options - Optional pre-calculated computed values
+ * @returns True if the field is visible
+ */
+export declare function isFieldVisible(fieldPath: string, data: Record<string, unknown>, spec: Forma, options?: VisibilityOptions): boolean;
+/**
+ * Determine which pages are visible in a wizard form
+ *
+ * @param data - Current form data
+ * @param spec - Form specification with pages
+ * @param options - Optional pre-calculated computed values
+ * @returns Map of page IDs to visibility states
+ */
+export declare function getPageVisibility(data: Record<string, unknown>, spec: Forma, options?: VisibilityOptions): Record<string, boolean>;
+//# sourceMappingURL=visibility.d.ts.map

package/dist/engine/visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visibility.d.ts","sourceRoot":"","sources":["../../src/engine/visibility.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EACV,KAAK,EAGL,gBAAgB,EACjB,MAAM,aAAa,CAAC;AAOrB,MAAM,WAAW,iBAAiB;IAChC,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,IAAI,EAAE,KAAK,EACX,OAAO,GAAE,iBAAsB,GAC9B,gBAAgB,CAsBlB;AA+ED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,IAAI,EAAE,KAAK,EACX,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAkBT;AAMD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,IAAI,EAAE,KAAK,EACX,OAAO,GAAE,iBAAsB,GAC9B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAuBzB"}

package/dist/feel/index.d.ts

@@ -1,5 +1,3 @@
-import { F as FEELExpression, E as EvaluationContext } from '../types-Bs3CG9JZ.js';
-
 /**
  * FEEL Expression Evaluator
  *
@@ -14,17 +12,17 @@ import { F as FEELExpression, E as EvaluationContext } from '../types-Bs3CG9JZ.j
  * - `itemIndex` - Current array item index (0-based)
  * - `value` - Current field value (in validation expressions)
  */
-
-interface EvaluateResult<T = unknown> {
+import type { EvaluationContext, FEELExpression } from "../types.js";
+export interface EvaluateResult<T = unknown> {
     success: true;
     value: T;
 }
-interface EvaluateError {
+export interface EvaluateError {
     success: false;
     error: string;
     expression: string;
 }
-type EvaluationOutcome<T = unknown> = EvaluateResult<T> | EvaluateError;
+export type EvaluationOutcome<T = unknown> = EvaluateResult<T> | EvaluateError;
 /**
  * Evaluate a FEEL expression and return the result
  *
@@ -47,7 +45,7 @@ type EvaluationOutcome<T = unknown> = EvaluateResult<T> | EvaluateError;
  * evaluate("item.frequency = \"daily\"", { data: {}, item: { frequency: "daily" } })
  * // => { success: true, value: true }
  */
-declare function evaluate<T = unknown>(expression: FEELExpression, context: EvaluationContext): EvaluationOutcome<T>;
+export declare function evaluate<T = unknown>(expression: FEELExpression, context: EvaluationContext): EvaluationOutcome<T>;
 /**
  * Evaluate a FEEL expression expecting a boolean result
  *
@@ -58,7 +56,7 @@ declare function evaluate<T = unknown>(expression: FEELExpression, context: Eval
  * @param context - Evaluation context
  * @returns Boolean result (false on error)
  */
-declare function evaluateBoolean(expression: FEELExpression, context: EvaluationContext): boolean;
+export declare function evaluateBoolean(expression: FEELExpression, context: EvaluationContext): boolean;
 /**
  * Evaluate a FEEL expression expecting a numeric result
  *
@@ -68,7 +66,7 @@ declare function evaluateBoolean(expression: FEELExpression, context: Evaluation
  * @param context - Evaluation context
  * @returns Numeric result or null on error
  */
-declare function evaluateNumber(expression: FEELExpression, context: EvaluationContext): number | null;
+export declare function evaluateNumber(expression: FEELExpression, context: EvaluationContext): number | null;
 /**
  * Evaluate a FEEL expression expecting a string result
  *
@@ -76,7 +74,7 @@ declare function evaluateNumber(expression: FEELExpression, context: EvaluationC
  * @param context - Evaluation context
  * @returns String result or null on error
  */
-declare function evaluateString(expression: FEELExpression, context: EvaluationContext): string | null;
+export declare function evaluateString(expression: FEELExpression, context: EvaluationContext): string | null;
 /**
  * Evaluate multiple FEEL expressions at once
  *
@@ -86,20 +84,19 @@ declare function evaluateString(expression: FEELExpression, context: EvaluationC
  * @param context - Evaluation context
  * @returns Map of field names to boolean results
  */
-declare function evaluateBooleanBatch(expressions: Record<string, FEELExpression>, context: EvaluationContext): Record<string, boolean>;
+export declare function evaluateBooleanBatch(expressions: Record<string, FEELExpression>, context: EvaluationContext): Record<string, boolean>;
 /**
  * Check if a FEEL expression is syntactically valid
  *
  * @param expression - FEEL expression to validate
  * @returns True if the expression can be parsed
  */
-declare function isValidExpression(expression: FEELExpression): boolean;
+export declare function isValidExpression(expression: FEELExpression): boolean;
 /**
  * Validate a FEEL expression and return any parsing errors
  *
  * @param expression - FEEL expression to validate
  * @returns Null if valid, error message if invalid
  */
-declare function validateExpression(expression: FEELExpression): string | null;
-
-export { type EvaluateError, type EvaluateResult, type EvaluationOutcome, evaluate, evaluateBoolean, evaluateBooleanBatch, evaluateNumber, evaluateString, isValidExpression, validateExpression };
+export declare function validateExpression(expression: FEELExpression): string | null;
+//# sourceMappingURL=index.d.ts.map

package/dist/feel/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/feel/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAMrE,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,OAAO;IACzC,OAAO,EAAE,IAAI,CAAC;IACd,KAAK,EAAE,CAAC,CAAC;CACV;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,KAAK,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,iBAAiB,CAAC,CAAC,GAAG,OAAO,IAAI,cAAc,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC;AAuD/E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,GAAG,OAAO,EAClC,UAAU,EAAE,cAAc,EAC1B,OAAO,EAAE,iBAAiB,GACzB,iBAAiB,CAAC,CAAC,CAAC,CAetB;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,cAAc,EAC1B,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAwBT;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,cAAc,EAC1B,OAAO,EAAE,iBAAiB,GACzB,MAAM,GAAG,IAAI,CAkBf;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,cAAc,EAC1B,OAAO,EAAE,iBAAiB,GACzB,MAAM,GAAG,IAAI,CAkBf;AAMD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,EAC3C,OAAO,EAAE,iBAAiB,GACzB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAQzB;AAMD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,cAAc,GAAG,OAAO,CASrE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,cAAc,GAAG,MAAM,GAAG,IAAI,CAc5E"}

package/dist/index.cjs

@@ -730,6 +730,18 @@ function validateType(path, value, schema, fieldDef) {
           };
         }
       }
+      if ("multipleOf" in schema && schema.multipleOf !== void 0) {
+        const multipleOf = schema.multipleOf;
+        const remainder = Math.abs(value % multipleOf);
+        const isValid = remainder < 1e-10 || Math.abs(remainder - multipleOf) < 1e-10;
+        if (!isValid) {
+          return {
+            field: path,
+            message: `${label} must be a multiple of ${multipleOf}`,
+            severity: "error"
+          };
+        }
+      }
       return null;
     }
     case "boolean": {