@fogpipe/forma-core 0.6.0

package/dist/engine/index.d.ts

@@ -0,0 +1,258 @@
+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
+ *
+ * Evaluates computed fields based on form data.
+ * Computed values are derived from form data using FEEL expressions.
+ */
+
+/**
+ * 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 };

package/dist/engine/index.js

@@ -0,0 +1,32 @@
+import {
+  calculate,
+  calculateField,
+  calculateWithErrors,
+  getEnabled,
+  getFormattedValue,
+  getPageVisibility,
+  getRequired,
+  getVisibility,
+  isEnabled,
+  isFieldVisible,
+  isRequired,
+  validate,
+  validateSingleField
+} from "../chunk-IRLYWN3R.js";
+import "../chunk-QTLXVG6P.js";
+export {
+  calculate,
+  calculateField,
+  calculateWithErrors,
+  getEnabled,
+  getFormattedValue,
+  getPageVisibility,
+  getRequired,
+  getVisibility,
+  isEnabled,
+  isFieldVisible,
+  isRequired,
+  validate,
+  validateSingleField
+};
+//# sourceMappingURL=index.js.map

package/dist/engine/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/feel/index.cjs

@@ -0,0 +1,165 @@
+"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/feel/index.ts
+var feel_exports = {};
+__export(feel_exports, {
+  evaluate: () => evaluate,
+  evaluateBoolean: () => evaluateBoolean,
+  evaluateBooleanBatch: () => evaluateBooleanBatch,
+  evaluateNumber: () => evaluateNumber,
+  evaluateString: () => evaluateString,
+  isValidExpression: () => isValidExpression,
+  validateExpression: () => validateExpression
+});
+module.exports = __toCommonJS(feel_exports);
+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;
+}
+function evaluateNumber(expression, context) {
+  const result = evaluate(expression, context);
+  if (!result.success) {
+    console.warn(
+      `FEEL expression error: ${result.error}
+Expression: ${result.expression}`
+    );
+    return null;
+  }
+  if (typeof result.value !== "number") {
+    console.warn(
+      `FEEL expression did not return number: ${expression}
+Got: ${typeof result.value}`
+    );
+    return null;
+  }
+  return result.value;
+}
+function evaluateString(expression, context) {
+  const result = evaluate(expression, context);
+  if (!result.success) {
+    console.warn(
+      `FEEL expression error: ${result.error}
+Expression: ${result.expression}`
+    );
+    return null;
+  }
+  if (typeof result.value !== "string") {
+    console.warn(
+      `FEEL expression did not return string: ${expression}
+Got: ${typeof result.value}`
+    );
+    return null;
+  }
+  return result.value;
+}
+function evaluateBooleanBatch(expressions, context) {
+  const results = {};
+  for (const [key, expression] of Object.entries(expressions)) {
+    results[key] = evaluateBoolean(expression, context);
+  }
+  return results;
+}
+function isValidExpression(expression) {
+  try {
+    (0, import_feelin.evaluate)(expression, {});
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateExpression(expression) {
+  try {
+    (0, import_feelin.evaluate)(expression, {});
+    return null;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("parse") || message.includes("syntax")) {
+      return message;
+    }
+    return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  evaluate,
+  evaluateBoolean,
+  evaluateBooleanBatch,
+  evaluateNumber,
+  evaluateString,
+  isValidExpression,
+  validateExpression
+});
+//# sourceMappingURL=index.cjs.map

package/dist/feel/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/feel/index.ts"],"sourcesContent":["/**\n * FEEL Expression Evaluator\n *\n * Wraps the feelin library to provide FEEL expression evaluation\n * with Forma context conventions.\n *\n * Context variable conventions:\n * - `fieldName` - Direct field value access\n * - `computed.name` - Computed value access\n * - `ref.path` - Reference data lookup (external lookup tables)\n * - `item.fieldName` - Array item field access (within array context)\n * - `itemIndex` - Current array item index (0-based)\n * - `value` - Current field value (in validation expressions)\n */\n\nimport { evaluate as feelinEvaluate } from \"feelin\";\nimport type { EvaluationContext, FEELExpression } from \"../types.js\";\n\n// ============================================================================\n// Types\n// ============================================================================\n\nexport interface EvaluateResult<T = unknown> {\n  success: true;\n  value: T;\n}\n\nexport interface EvaluateError {\n  success: false;\n  error: string;\n  expression: string;\n}\n\nexport type EvaluationOutcome<T = unknown> = EvaluateResult<T> | EvaluateError;\n\n// ============================================================================\n// Context Building\n// ============================================================================\n\n/**\n * Build the FEEL evaluation context from our EvaluationContext\n *\n * Maps our context conventions to feelin context format:\n * - Form data fields are spread directly\n * - computed becomes an object (accessed as computed.fieldName)\n * - ref becomes an object for reference data (accessed as ref.path.to.data)\n * - item becomes an object for array context (accessed as item.fieldName)\n * - itemIndex is a number for array context\n * - value is the current field value\n */\nfunction buildFeelContext(ctx: EvaluationContext): Record<string, unknown> {\n  const feelContext: Record<string, unknown> = {\n    // Spread form data directly so fields are accessible by name\n    ...ctx.data,\n  };\n\n  // Add computed values under 'computed' (accessed as computed.fieldName)\n  if (ctx.computed) {\n    feelContext[\"computed\"] = ctx.computed;\n  }\n\n  // Add reference data under 'ref' (accessed as ref.path.to.data)\n  if (ctx.referenceData) {\n    feelContext[\"ref\"] = ctx.referenceData;\n  }\n\n  // Add array item context (accessed as item.fieldName)\n  if (ctx.item !== undefined) {\n    feelContext[\"item\"] = ctx.item;\n  }\n\n  // Add array index\n  if (ctx.itemIndex !== undefined) {\n    feelContext[\"itemIndex\"] = ctx.itemIndex;\n  }\n\n  // Add current field value for validation expressions\n  if (ctx.value !== undefined) {\n    feelContext[\"value\"] = ctx.value;\n  }\n\n  return feelContext;\n}\n\n// ============================================================================\n// Expression Evaluation\n// ============================================================================\n\n/**\n * Evaluate a FEEL expression and return the result\n *\n * @param expression - FEEL expression string\n * @param context - Evaluation context with form data, computed values, etc.\n * @returns Evaluation outcome with success/value or error\n *\n * @example\n * // Simple field comparison\n * evaluate(\"age >= 18\", { data: { age: 21 } })\n * // => { success: true, value: true }\n *\n * @example\n * // Computed value reference\n * evaluate(\"computed.bmi > 30\", { data: {}, computed: { bmi: 32.5 } })\n * // => { success: true, value: true }\n *\n * @example\n * // Array item context\n * evaluate(\"item.frequency = \\\"daily\\\"\", { data: {}, item: { frequency: \"daily\" } })\n * // => { success: true, value: true }\n */\nexport function evaluate<T = unknown>(\n  expression: FEELExpression,\n  context: EvaluationContext\n): EvaluationOutcome<T> {\n  try {\n    const feelContext = buildFeelContext(context);\n    const result = feelinEvaluate(expression, feelContext);\n    return {\n      success: true,\n      value: result as T,\n    };\n  } catch (error) {\n    return {\n      success: false,\n      error: error instanceof Error ? error.message : String(error),\n      expression,\n    };\n  }\n}\n\n/**\n * Evaluate a FEEL expression expecting a boolean result\n *\n * Used for visibility, required, and enabled conditions.\n * Returns false on error or non-boolean result for safety.\n *\n * @param expression - FEEL expression that should return boolean\n * @param context - Evaluation context\n * @returns Boolean result (false on error)\n */\nexport function evaluateBoolean(\n  expression: FEELExpression,\n  context: EvaluationContext\n): boolean {\n  const result = evaluate<boolean>(expression, context);\n\n  if (!result.success) {\n    console.warn(\n      `FEEL expression error: ${result.error}\\nExpression: ${result.expression}`\n    );\n    return false;\n  }\n\n  // FEEL uses three-valued logic where comparisons with null return null.\n  // For form visibility/required/enabled conditions, we treat null as false.\n  if (result.value === null || result.value === undefined) {\n    return false;\n  }\n\n  if (typeof result.value !== \"boolean\") {\n    console.warn(\n      `FEEL expression did not return boolean: ${expression}\\nGot: ${typeof result.value}`\n    );\n    return false;\n  }\n\n  return result.value;\n}\n\n/**\n * Evaluate a FEEL expression expecting a numeric result\n *\n * Used for computed values that return numbers.\n *\n * @param expression - FEEL expression that should return number\n * @param context - Evaluation context\n * @returns Numeric result or null on error\n */\nexport function evaluateNumber(\n  expression: FEELExpression,\n  context: EvaluationContext\n): number | null {\n  const result = evaluate<number>(expression, context);\n\n  if (!result.success) {\n    console.warn(\n      `FEEL expression error: ${result.error}\\nExpression: ${result.expression}`\n    );\n    return null;\n  }\n\n  if (typeof result.value !== \"number\") {\n    console.warn(\n      `FEEL expression did not return number: ${expression}\\nGot: ${typeof result.value}`\n    );\n    return null;\n  }\n\n  return result.value;\n}\n\n/**\n * Evaluate a FEEL expression expecting a string result\n *\n * @param expression - FEEL expression that should return string\n * @param context - Evaluation context\n * @returns String result or null on error\n */\nexport function evaluateString(\n  expression: FEELExpression,\n  context: EvaluationContext\n): string | null {\n  const result = evaluate<string>(expression, context);\n\n  if (!result.success) {\n    console.warn(\n      `FEEL expression error: ${result.error}\\nExpression: ${result.expression}`\n    );\n    return null;\n  }\n\n  if (typeof result.value !== \"string\") {\n    console.warn(\n      `FEEL expression did not return string: ${expression}\\nGot: ${typeof result.value}`\n    );\n    return null;\n  }\n\n  return result.value;\n}\n\n// ============================================================================\n// Batch Evaluation\n// ============================================================================\n\n/**\n * Evaluate multiple FEEL expressions at once\n *\n * Useful for evaluating all visibility conditions in a form.\n *\n * @param expressions - Map of field names to FEEL expressions\n * @param context - Evaluation context\n * @returns Map of field names to boolean results\n */\nexport function evaluateBooleanBatch(\n  expressions: Record<string, FEELExpression>,\n  context: EvaluationContext\n): Record<string, boolean> {\n  const results: Record<string, boolean> = {};\n\n  for (const [key, expression] of Object.entries(expressions)) {\n    results[key] = evaluateBoolean(expression, context);\n  }\n\n  return results;\n}\n\n// ============================================================================\n// Expression Validation\n// ============================================================================\n\n/**\n * Check if a FEEL expression is syntactically valid\n *\n * @param expression - FEEL expression to validate\n * @returns True if the expression can be parsed\n */\nexport function isValidExpression(expression: FEELExpression): boolean {\n  try {\n    // Try to evaluate with empty context - we just want to check parsing\n    feelinEvaluate(expression, {});\n    return true;\n  } catch {\n    // Expression failed to parse or evaluate\n    return false;\n  }\n}\n\n/**\n * Validate a FEEL expression and return any parsing errors\n *\n * @param expression - FEEL expression to validate\n * @returns Null if valid, error message if invalid\n */\nexport function validateExpression(expression: FEELExpression): string | null {\n  try {\n    // Evaluate with minimal context to catch parse errors\n    feelinEvaluate(expression, {});\n    return null;\n  } catch (error) {\n    // Only return actual parsing errors, not runtime errors\n    const message = error instanceof Error ? error.message : String(error);\n    if (message.includes(\"parse\") || message.includes(\"syntax\")) {\n      return message;\n    }\n    // Runtime errors (missing variables, etc.) are OK for validation\n    return null;\n  }\n}\n"],"mappings":"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","names":["feelinEvaluate"]}

package/dist/feel/index.d.cts

@@ -0,0 +1,105 @@
+import { F as FEELExpression, E as EvaluationContext } from '../types-Bs3CG9JZ.cjs';
+
+/**
+ * FEEL Expression Evaluator
+ *
+ * Wraps the feelin library to provide FEEL expression evaluation
+ * with Forma context conventions.
+ *
+ * Context variable conventions:
+ * - `fieldName` - Direct field value access
+ * - `computed.name` - Computed value access
+ * - `ref.path` - Reference data lookup (external lookup tables)
+ * - `item.fieldName` - Array item field access (within array context)
+ * - `itemIndex` - Current array item index (0-based)
+ * - `value` - Current field value (in validation expressions)
+ */
+
+interface EvaluateResult<T = unknown> {
+    success: true;
+    value: T;
+}
+interface EvaluateError {
+    success: false;
+    error: string;
+    expression: string;
+}
+type EvaluationOutcome<T = unknown> = EvaluateResult<T> | EvaluateError;
+/**
+ * Evaluate a FEEL expression and return the result
+ *
+ * @param expression - FEEL expression string
+ * @param context - Evaluation context with form data, computed values, etc.
+ * @returns Evaluation outcome with success/value or error
+ *
+ * @example
+ * // Simple field comparison
+ * evaluate("age >= 18", { data: { age: 21 } })
+ * // => { success: true, value: true }
+ *
+ * @example
+ * // Computed value reference
+ * evaluate("computed.bmi > 30", { data: {}, computed: { bmi: 32.5 } })
+ * // => { success: true, value: true }
+ *
+ * @example
+ * // Array item context
+ * evaluate("item.frequency = \"daily\"", { data: {}, item: { frequency: "daily" } })
+ * // => { success: true, value: true }
+ */
+declare function evaluate<T = unknown>(expression: FEELExpression, context: EvaluationContext): EvaluationOutcome<T>;
+/**
+ * Evaluate a FEEL expression expecting a boolean result
+ *
+ * Used for visibility, required, and enabled conditions.
+ * Returns false on error or non-boolean result for safety.
+ *
+ * @param expression - FEEL expression that should return boolean
+ * @param context - Evaluation context
+ * @returns Boolean result (false on error)
+ */
+declare function evaluateBoolean(expression: FEELExpression, context: EvaluationContext): boolean;
+/**
+ * Evaluate a FEEL expression expecting a numeric result
+ *
+ * Used for computed values that return numbers.
+ *
+ * @param expression - FEEL expression that should return number
+ * @param context - Evaluation context
+ * @returns Numeric result or null on error
+ */
+declare function evaluateNumber(expression: FEELExpression, context: EvaluationContext): number | null;
+/**
+ * Evaluate a FEEL expression expecting a string result
+ *
+ * @param expression - FEEL expression that should return string
+ * @param context - Evaluation context
+ * @returns String result or null on error
+ */
+declare function evaluateString(expression: FEELExpression, context: EvaluationContext): string | null;
+/**
+ * Evaluate multiple FEEL expressions at once
+ *
+ * Useful for evaluating all visibility conditions in a form.
+ *
+ * @param expressions - Map of field names to FEEL expressions
+ * @param context - Evaluation context
+ * @returns Map of field names to boolean results
+ */
+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;
+/**
+ * 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 };

package/dist/feel/index.d.ts

@@ -0,0 +1,105 @@
+import { F as FEELExpression, E as EvaluationContext } from '../types-Bs3CG9JZ.js';
+
+/**
+ * FEEL Expression Evaluator
+ *
+ * Wraps the feelin library to provide FEEL expression evaluation
+ * with Forma context conventions.
+ *
+ * Context variable conventions:
+ * - `fieldName` - Direct field value access
+ * - `computed.name` - Computed value access
+ * - `ref.path` - Reference data lookup (external lookup tables)
+ * - `item.fieldName` - Array item field access (within array context)
+ * - `itemIndex` - Current array item index (0-based)
+ * - `value` - Current field value (in validation expressions)
+ */
+
+interface EvaluateResult<T = unknown> {
+    success: true;
+    value: T;
+}
+interface EvaluateError {
+    success: false;
+    error: string;
+    expression: string;
+}
+type EvaluationOutcome<T = unknown> = EvaluateResult<T> | EvaluateError;
+/**
+ * Evaluate a FEEL expression and return the result
+ *
+ * @param expression - FEEL expression string
+ * @param context - Evaluation context with form data, computed values, etc.
+ * @returns Evaluation outcome with success/value or error
+ *
+ * @example
+ * // Simple field comparison
+ * evaluate("age >= 18", { data: { age: 21 } })
+ * // => { success: true, value: true }
+ *
+ * @example
+ * // Computed value reference
+ * evaluate("computed.bmi > 30", { data: {}, computed: { bmi: 32.5 } })
+ * // => { success: true, value: true }
+ *
+ * @example
+ * // Array item context
+ * evaluate("item.frequency = \"daily\"", { data: {}, item: { frequency: "daily" } })
+ * // => { success: true, value: true }
+ */
+declare function evaluate<T = unknown>(expression: FEELExpression, context: EvaluationContext): EvaluationOutcome<T>;
+/**
+ * Evaluate a FEEL expression expecting a boolean result
+ *
+ * Used for visibility, required, and enabled conditions.
+ * Returns false on error or non-boolean result for safety.
+ *
+ * @param expression - FEEL expression that should return boolean
+ * @param context - Evaluation context
+ * @returns Boolean result (false on error)
+ */
+declare function evaluateBoolean(expression: FEELExpression, context: EvaluationContext): boolean;
+/**
+ * Evaluate a FEEL expression expecting a numeric result
+ *
+ * Used for computed values that return numbers.
+ *
+ * @param expression - FEEL expression that should return number
+ * @param context - Evaluation context
+ * @returns Numeric result or null on error
+ */
+declare function evaluateNumber(expression: FEELExpression, context: EvaluationContext): number | null;
+/**
+ * Evaluate a FEEL expression expecting a string result
+ *
+ * @param expression - FEEL expression that should return string
+ * @param context - Evaluation context
+ * @returns String result or null on error
+ */
+declare function evaluateString(expression: FEELExpression, context: EvaluationContext): string | null;
+/**
+ * Evaluate multiple FEEL expressions at once
+ *
+ * Useful for evaluating all visibility conditions in a form.
+ *
+ * @param expressions - Map of field names to FEEL expressions
+ * @param context - Evaluation context
+ * @returns Map of field names to boolean results
+ */
+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;
+/**
+ * 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 };