@fogpipe/forma-core 0.6.0 → 0.7.0

package/dist/engine/calculate.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Calculation Engine
+ *
+ * Evaluates computed fields based on form data.
+ * Computed values are derived from form data using FEEL expressions.
+ */
+import type { Forma, CalculationResult } from "../types.js";
+/**
+ * Calculate all computed values from form data
+ *
+ * Evaluates each computed field's FEEL expression and returns the results.
+ * Errors are collected rather than thrown, allowing partial results.
+ *
+ * @param data - Current form data
+ * @param spec - Form specification with computed fields
+ * @returns Computed values and any calculation errors
+ *
+ * @example
+ * const spec = {
+ *   computed: {
+ *     bmi: {
+ *       expression: "weight / (height / 100) ** 2",
+ *       label: "BMI",
+ *       format: "decimal(1)"
+ *     },
+ *     isObese: {
+ *       expression: "$computed.bmi >= 30"
+ *     }
+ *   }
+ * };
+ *
+ * const result = calculate({ weight: 85, height: 175 }, spec);
+ * // => { values: { bmi: 27.76, isObese: false }, errors: [] }
+ */
+export declare function calculate(data: Record<string, unknown>, spec: Forma): Record<string, unknown>;
+/**
+ * Calculate computed values with error reporting
+ *
+ * Same as calculate() but also returns any errors that occurred.
+ *
+ * @param data - Current form data
+ * @param spec - Form specification
+ * @returns Values and errors
+ */
+export declare function calculateWithErrors(data: Record<string, unknown>, spec: Forma): CalculationResult;
+/**
+ * Get a computed value formatted according to its format specification
+ *
+ * @param fieldName - Name of the computed field
+ * @param data - Current form data
+ * @param spec - Form specification
+ * @returns Formatted string or null if not displayable
+ */
+export declare function getFormattedValue(fieldName: string, data: Record<string, unknown>, spec: Forma): string | null;
+/**
+ * Calculate a single computed field
+ *
+ * @param fieldName - Name of the computed field
+ * @param data - Current form data
+ * @param spec - Form specification
+ * @returns Computed value or null if calculation failed
+ */
+export declare function calculateField(fieldName: string, data: Record<string, unknown>, spec: Forma): unknown;
+//# sourceMappingURL=calculate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"calculate.d.ts","sourceRoot":"","sources":["../../src/engine/calculate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EACV,KAAK,EAGL,iBAAiB,EAElB,MAAM,aAAa,CAAC;AAMrB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,IAAI,EAAE,KAAK,GACV,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAGzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,IAAI,EAAE,KAAK,GACV,iBAAiB,CAsCnB;AAsKD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,IAAI,EAAE,KAAK,GACV,MAAM,GAAG,IAAI,CAcf;AAkDD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,IAAI,EAAE,KAAK,GACV,OAAO,CAGT"}

package/dist/engine/enabled.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Enabled Fields Engine
+ *
+ * Determines which fields are currently enabled (editable) based on
+ * conditional enabledWhen expressions.
+ */
+import type { Forma, EnabledResult } from "../types.js";
+export interface EnabledOptions {
+    /** Pre-calculated computed values */
+    computed?: Record<string, unknown>;
+}
+/**
+ * Determine which fields are currently enabled (editable)
+ *
+ * Returns a map of field paths to boolean enabled states.
+ * Fields without enabledWhen expressions are always enabled.
+ *
+ * @param data - Current form data
+ * @param spec - Form specification
+ * @param options - Optional pre-calculated computed values
+ * @returns Map of field paths to enabled states
+ *
+ * @example
+ * const enabled = getEnabled(
+ *   { isLocked: true },
+ *   forma
+ * );
+ * // => { isLocked: true, lockedField: false, ... }
+ */
+export declare function getEnabled(data: Record<string, unknown>, spec: Forma, options?: EnabledOptions): EnabledResult;
+/**
+ * Check if a single field is currently enabled
+ *
+ * @param fieldPath - Path to the field
+ * @param data - Current form data
+ * @param spec - Form specification
+ * @returns True if the field is enabled
+ */
+export declare function isEnabled(fieldPath: string, data: Record<string, unknown>, spec: Forma): boolean;
+//# sourceMappingURL=enabled.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"enabled.d.ts","sourceRoot":"","sources":["../../src/engine/enabled.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EACV,KAAK,EAGL,aAAa,EACd,MAAM,aAAa,CAAC;AAOrB,MAAM,WAAW,cAAc;IAC7B,qCAAqC;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,IAAI,EAAE,KAAK,EACX,OAAO,GAAE,cAAmB,GAC3B,aAAa,CA2Cf;AAsBD;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,IAAI,EAAE,KAAK,GACV,OAAO,CAkBT"}

package/dist/engine/index.d.ts

@@ -1,258 +1,15 @@
-import { m as Forma, t as CalculationResult, n as VisibilityResult, o as RequiredFieldsResult, p as EnabledResult, r as ValidationResult, q as FieldError } from '../types-Bs3CG9JZ.js';
-
 /**
- * Calculation Engine
+ * Engine module exports
  *
- * Evaluates computed fields based on form data.
- * Computed values are derived from form data using FEEL expressions.
+ * Core form logic engines for visibility, validation, calculation, etc.
  */
-
-/**
- * Calculate all computed values from form data
- *
- * Evaluates each computed field's FEEL expression and returns the results.
- * Errors are collected rather than thrown, allowing partial results.
- *
- * @param data - Current form data
- * @param spec - Form specification with computed fields
- * @returns Computed values and any calculation errors
- *
- * @example
- * const spec = {
- *   computed: {
- *     bmi: {
- *       expression: "weight / (height / 100) ** 2",
- *       label: "BMI",
- *       format: "decimal(1)"
- *     },
- *     isObese: {
- *       expression: "$computed.bmi >= 30"
- *     }
- *   }
- * };
- *
- * const result = calculate({ weight: 85, height: 175 }, spec);
- * // => { values: { bmi: 27.76, isObese: false }, errors: [] }
- */
-declare function calculate(data: Record<string, unknown>, spec: Forma): Record<string, unknown>;
-/**
- * Calculate computed values with error reporting
- *
- * Same as calculate() but also returns any errors that occurred.
- *
- * @param data - Current form data
- * @param spec - Form specification
- * @returns Values and errors
- */
-declare function calculateWithErrors(data: Record<string, unknown>, spec: Forma): CalculationResult;
-/**
- * Get a computed value formatted according to its format specification
- *
- * @param fieldName - Name of the computed field
- * @param data - Current form data
- * @param spec - Form specification
- * @returns Formatted string or null if not displayable
- */
-declare function getFormattedValue(fieldName: string, data: Record<string, unknown>, spec: Forma): string | null;
-/**
- * Calculate a single computed field
- *
- * @param fieldName - Name of the computed field
- * @param data - Current form data
- * @param spec - Form specification
- * @returns Computed value or null if calculation failed
- */
-declare function calculateField(fieldName: string, data: Record<string, unknown>, spec: Forma): unknown;
-
-/**
- * Visibility Engine
- *
- * Determines which fields should be visible based on form data
- * and Forma visibility rules.
- */
-
-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, ... }
- */
-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
- */
-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
- */
-declare function getPageVisibility(data: Record<string, unknown>, spec: Forma, options?: VisibilityOptions): Record<string, boolean>;
-
-/**
- * Required Fields Engine
- *
- * Determines which fields are currently required based on
- * conditional requiredWhen expressions and schema required array.
- */
-
-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 }
- */
-declare function getRequired(data: Record<string, unknown>, spec: Forma, options?: RequiredOptions): RequiredFieldsResult;
-/**
- * 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
- */
-declare function isRequired(fieldPath: string, data: Record<string, unknown>, spec: Forma): boolean;
-
-/**
- * Enabled Fields Engine
- *
- * Determines which fields are currently enabled (editable) based on
- * conditional enabledWhen expressions.
- */
-
-interface EnabledOptions {
-    /** Pre-calculated computed values */
-    computed?: Record<string, unknown>;
-}
-/**
- * Determine which fields are currently enabled (editable)
- *
- * Returns a map of field paths to boolean enabled states.
- * Fields without enabledWhen expressions are always enabled.
- *
- * @param data - Current form data
- * @param spec - Form specification
- * @param options - Optional pre-calculated computed values
- * @returns Map of field paths to enabled states
- *
- * @example
- * const enabled = getEnabled(
- *   { isLocked: true },
- *   forma
- * );
- * // => { isLocked: true, lockedField: false, ... }
- */
-declare function getEnabled(data: Record<string, unknown>, spec: Forma, options?: EnabledOptions): EnabledResult;
-/**
- * Check if a single field is currently enabled
- *
- * @param fieldPath - Path to the field
- * @param data - Current form data
- * @param spec - Form specification
- * @returns True if the field is enabled
- */
-declare function isEnabled(fieldPath: string, data: Record<string, unknown>, spec: Forma): boolean;
-
-/**
- * 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
- */
-
-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" }
- * //   ]
- * // }
- */
-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
- */
-declare function validateSingleField(fieldPath: string, data: Record<string, unknown>, spec: Forma): FieldError[];
-
-export { type EnabledOptions, type RequiredOptions, type ValidateOptions, type VisibilityOptions, calculate, calculateField, calculateWithErrors, getEnabled, getFormattedValue, getPageVisibility, getRequired, getVisibility, isEnabled, isFieldVisible, isRequired, validate, validateSingleField };
+export { calculate, calculateWithErrors, calculateField, getFormattedValue, } from "./calculate.js";
+export { getVisibility, isFieldVisible, getPageVisibility, } from "./visibility.js";
+export type { VisibilityOptions, } from "./visibility.js";
+export { getRequired, isRequired, } from "./required.js";
+export type { RequiredOptions, } from "./required.js";
+export { getEnabled, isEnabled, } from "./enabled.js";
+export type { EnabledOptions, } from "./enabled.js";
+export { validate, validateSingleField, } from "./validate.js";
+export type { ValidateOptions, } from "./validate.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/engine/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,SAAS,EACT,mBAAmB,EACnB,cAAc,EACd,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,aAAa,EACb,cAAc,EACd,iBAAiB,GAClB,MAAM,iBAAiB,CAAC;AAEzB,YAAY,EACV,iBAAiB,GAClB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,WAAW,EACX,UAAU,GACX,MAAM,eAAe,CAAC;AAEvB,YAAY,EACV,eAAe,GAChB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,UAAU,EACV,SAAS,GACV,MAAM,cAAc,CAAC;AAEtB,YAAY,EACV,cAAc,GACf,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,QAAQ,EACR,mBAAmB,GACpB,MAAM,eAAe,CAAC;AAEvB,YAAY,EACV,eAAe,GAChB,MAAM,eAAe,CAAC"}

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;AA6eD;;;;;;;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"}