@fogpipe/forma-core 0.6.0 → 0.8.0

package/dist/feel/index.d.cts

@@ -1,105 +0,0 @@
-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/index.d.cts

@@ -1,3 +0,0 @@
-export { s as CalculationError, t as CalculationResult, C as ComputedField, p as EnabledResult, E as EvaluationContext, F as FEELExpression, k as FieldDefinition, q as FieldError, j as FieldType, l as FormMeta, m as Forma, J as JSONSchema, g as JSONSchemaArray, b as JSONSchemaBase, f as JSONSchemaBoolean, i as JSONSchemaEnum, e as JSONSchemaInteger, d as JSONSchemaNumber, h as JSONSchemaObject, a as JSONSchemaProperty, c as JSONSchemaString, P as PageDefinition, o as RequiredFieldsResult, R as RequiredResult, S as SelectOption, r as ValidationResult, V as ValidationRule, n as VisibilityResult } from './types-Bs3CG9JZ.cjs';
-export { EvaluateError, EvaluateResult, EvaluationOutcome, evaluate, evaluateBoolean, evaluateBooleanBatch, evaluateNumber, evaluateString, isValidExpression, validateExpression } from './feel/index.cjs';
-export { EnabledOptions, RequiredOptions, ValidateOptions, VisibilityOptions, calculate, calculateField, calculateWithErrors, getEnabled, getFormattedValue, getPageVisibility, getRequired, getVisibility, isEnabled, isFieldVisible, isRequired, validate, validateSingleField } from './engine/index.cjs';

package/dist/types-Bs3CG9JZ.d.ts

@@ -1,283 +0,0 @@
-/**
- * Core Forma Type Definitions
- *
- * This module defines the complete type system for Forma specifications.
- * All conditional logic uses FEEL (Friendly Enough Expression Language).
- */
-/**
- * FEEL expression - a string that will be evaluated at runtime.
- *
- * Available context variables:
- * - `fieldName` - Any field value by name
- * - `computed.name` - Computed value by name
- * - `ref.path` - Reference data lookup (external lookup tables)
- * - `item.fieldName` - Field within current array item
- * - `itemIndex` - Current item index (0-based)
- * - `value` - Current field value (in validation expressions)
- *
- * @example
- * "age >= 18"
- * "claimType = \"Auto\" and wasDriver = true"
- * "computed.bmi > 30"
- * "item.frequency = \"daily\""
- */
-type FEELExpression = string;
-/**
- * Standard JSON Schema (subset we support)
- */
-interface JSONSchema {
-    type: "object";
-    properties: Record<string, JSONSchemaProperty>;
-    required?: string[];
-    $defs?: Record<string, JSONSchemaProperty>;
-}
-type JSONSchemaProperty = JSONSchemaString | JSONSchemaNumber | JSONSchemaInteger | JSONSchemaBoolean | JSONSchemaArray | JSONSchemaObject | JSONSchemaEnum;
-interface JSONSchemaBase {
-    description?: string;
-    title?: string;
-}
-interface JSONSchemaString extends JSONSchemaBase {
-    type: "string";
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    format?: "date" | "date-time" | "email" | "uri" | "uuid";
-    enum?: string[];
-}
-interface JSONSchemaNumber extends JSONSchemaBase {
-    type: "number";
-    minimum?: number;
-    maximum?: number;
-    exclusiveMinimum?: number;
-    exclusiveMaximum?: number;
-}
-interface JSONSchemaInteger extends JSONSchemaBase {
-    type: "integer";
-    minimum?: number;
-    maximum?: number;
-}
-interface JSONSchemaBoolean extends JSONSchemaBase {
-    type: "boolean";
-}
-interface JSONSchemaArray extends JSONSchemaBase {
-    type: "array";
-    items: JSONSchemaProperty;
-    minItems?: number;
-    maxItems?: number;
-}
-interface JSONSchemaObject extends JSONSchemaBase {
-    type: "object";
-    properties: Record<string, JSONSchemaProperty>;
-    required?: string[];
-}
-interface JSONSchemaEnum extends JSONSchemaBase {
-    type: "string";
-    enum: string[];
-}
-/**
- * Field type enumeration - maps to UI component types
- */
-type FieldType = "text" | "password" | "number" | "integer" | "boolean" | "select" | "multiselect" | "date" | "datetime" | "email" | "url" | "textarea" | "array" | "object" | "computed";
-/**
- * Validation rule with FEEL expression
- */
-interface ValidationRule {
-    /** FEEL expression that should evaluate to true for valid data */
-    rule: FEELExpression;
-    /** Error message shown when validation fails */
-    message: string;
-    /** Severity level - errors block submission, warnings are informational */
-    severity?: "error" | "warning";
-}
-/**
- * Option for select/multiselect fields
- */
-interface SelectOption {
-    /** Option value - can be string or number to match schema types */
-    value: string | number;
-    label: string;
-    /** When to show this option */
-    visibleWhen?: FEELExpression;
-}
-/**
- * Field definition with all conditional logic
- */
-interface FieldDefinition {
-    /** Display label for the field */
-    label?: string;
-    /** Help text or description */
-    description?: string;
-    /** Placeholder text for input fields */
-    placeholder?: string;
-    /** Field type override (inferred from schema if not provided) */
-    type?: FieldType;
-    /** When to show this field. If omitted, always visible. */
-    visibleWhen?: FEELExpression;
-    /** When this field is required. If omitted, uses schema required. */
-    requiredWhen?: FEELExpression;
-    /** When this field is editable. If omitted, always enabled. */
-    enabledWhen?: FEELExpression;
-    /** Custom validation rules using FEEL expressions */
-    validations?: ValidationRule[];
-    /** For array fields: field definitions for each item. Requires type: "array" */
-    itemFields?: Record<string, FieldDefinition>;
-    /** Minimum number of items (overrides schema) */
-    minItems?: number;
-    /** Maximum number of items (overrides schema) */
-    maxItems?: number;
-    /** For select fields: available options */
-    options?: SelectOption[];
-}
-/**
- * Computed field definition - derived values from form data
- */
-interface ComputedField {
-    /** FEEL expression to calculate the value */
-    expression: FEELExpression;
-    /** Display label */
-    label?: string;
-    /** Display format (e.g., "decimal(1)", "currency", "percent") */
-    format?: string;
-    /** Whether to display this value in the form */
-    display?: boolean;
-}
-/**
- * Page definition for multi-step wizard forms
- */
-interface PageDefinition {
-    /** Unique page identifier */
-    id: string;
-    /** Page title */
-    title: string;
-    /** Page description/instructions */
-    description?: string;
-    /** When to show this page */
-    visibleWhen?: FEELExpression;
-    /** Field paths to include on this page */
-    fields: string[];
-}
-/**
- * Form metadata
- */
-interface FormMeta {
-    /** Unique form identifier */
-    id: string;
-    /** Form title */
-    title: string;
-    /** Form description */
-    description?: string;
-    /** Form version */
-    version?: string;
-}
-/**
- * Complete Form Specification
- *
- * This is the root type that defines an entire form including:
- * - Data schema (JSON Schema)
- * - Computed values
- * - Reference data (lookup tables for calculations)
- * - Field-level configuration and conditional logic
- * - Field ordering
- * - Optional wizard/page structure
- */
-interface Forma {
-    /** Schema version identifier */
-    $schema?: string;
-    /** Spec version */
-    version: "1.0";
-    /** Form metadata */
-    meta: FormMeta;
-    /** JSON Schema defining the data structure */
-    schema: JSONSchema;
-    /** Computed/calculated values */
-    computed?: Record<string, ComputedField>;
-    /** Reference data for lookups (external data sources, lookup tables) */
-    referenceData?: Record<string, unknown>;
-    /** Field-level definitions and rules */
-    fields: Record<string, FieldDefinition>;
-    /** Order in which fields should be displayed */
-    fieldOrder: string[];
-    /** Optional multi-page wizard structure */
-    pages?: PageDefinition[];
-}
-/**
- * Context provided when evaluating FEEL expressions
- */
-interface EvaluationContext {
-    /** Current form data */
-    data: Record<string, unknown>;
-    /** Computed values (calculated before field evaluation) */
-    computed?: Record<string, unknown>;
-    /** Reference data for lookups (external data sources, lookup tables) */
-    referenceData?: Record<string, unknown>;
-    /** Current array item (when evaluating within array context) */
-    item?: Record<string, unknown>;
-    /** Current array item index (0-based) */
-    itemIndex?: number;
-    /** Current field value (for validation expressions) */
-    value?: unknown;
-}
-/**
- * Field visibility result - map of field path to visibility state
- */
-interface VisibilityResult {
-    [fieldPath: string]: boolean;
-}
-/**
- * Required fields result - map of field path to required state
- */
-interface RequiredResult {
-    [fieldPath: string]: boolean;
-}
-/**
- * Alias for RequiredResult (backwards compatibility)
- */
-type RequiredFieldsResult = RequiredResult;
-/**
- * Enabled fields result - map of field path to enabled state
- */
-interface EnabledResult {
-    [fieldPath: string]: boolean;
-}
-/**
- * Field validation error
- */
-interface FieldError {
-    /** Field path that has the error */
-    field: string;
-    /** Error message */
-    message: string;
-    /** Error severity */
-    severity: "error" | "warning";
-}
-/**
- * Validation result
- */
-interface ValidationResult {
-    /** Whether the form data is valid */
-    valid: boolean;
-    /** List of validation errors */
-    errors: FieldError[];
-}
-/**
- * Calculation error
- */
-interface CalculationError {
-    /** Computed field name */
-    field: string;
-    /** Error message */
-    message: string;
-    /** The expression that failed */
-    expression: string;
-}
-/**
- * Calculation result with potential errors
- */
-interface CalculationResult {
-    /** Computed values */
-    values: Record<string, unknown>;
-    /** Errors encountered during calculation */
-    errors: CalculationError[];
-}
-
-export type { ComputedField as C, EvaluationContext as E, FEELExpression as F, JSONSchema as J, PageDefinition as P, RequiredResult as R, SelectOption as S, ValidationRule as V, JSONSchemaProperty as a, JSONSchemaBase as b, JSONSchemaString as c, JSONSchemaNumber as d, JSONSchemaInteger as e, JSONSchemaBoolean as f, JSONSchemaArray as g, JSONSchemaObject as h, JSONSchemaEnum as i, FieldType as j, FieldDefinition as k, FormMeta as l, Forma as m, VisibilityResult as n, RequiredFieldsResult as o, EnabledResult as p, FieldError as q, ValidationResult as r, CalculationError as s, CalculationResult as t };