@sonata-innovations/fiber-shared 1.0.0

package/dist/condition-visibility.d.ts

@@ -0,0 +1,10 @@
+import type { FlowConditionConfig } from "@sonata-innovations/fiber-types";
+/**
+ * Determine if a target is hidden based on its condition config and result.
+ *
+ * - action = "show" → hidden when condition is NOT met
+ * - action = "hide" → hidden when condition IS met
+ * - No config → always visible
+ */
+export declare const isHiddenByCondition: (config: FlowConditionConfig | undefined, conditionMet: boolean | undefined) => boolean;
+//# sourceMappingURL=condition-visibility.d.ts.map

package/dist/condition-visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"condition-visibility.d.ts","sourceRoot":"","sources":["../src/condition-visibility.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAE3E;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAC9B,QAAQ,mBAAmB,GAAG,SAAS,EACvC,cAAc,OAAO,GAAG,SAAS,KAChC,OASF,CAAC"}

package/dist/condition-visibility.js

@@ -0,0 +1,20 @@
+/* ==========================================================================
+   Condition-visibility — shared "is hidden" check
+   ========================================================================== */
+/**
+ * Determine if a target is hidden based on its condition config and result.
+ *
+ * - action = "show" → hidden when condition is NOT met
+ * - action = "hide" → hidden when condition IS met
+ * - No config → always visible
+ */
+export const isHiddenByCondition = (config, conditionMet) => {
+    if (!config)
+        return false;
+    const met = conditionMet ?? false;
+    if (config.action === "show")
+        return !met;
+    if (config.action === "hide")
+        return met;
+    return false;
+};

package/dist/conditions.d.ts

@@ -0,0 +1,26 @@
+import type { ConditionOperator, ConditionRule, FlowConditionConfig } from "@sonata-innovations/fiber-types";
+/**
+ * An operator function receives the live component value and the rule's
+ * comparison value. Returns true when the condition is satisfied.
+ */
+type OperatorFn = (componentValue: any, ruleValue: ConditionRule["value"]) => boolean;
+export declare const toStr: (v: any) => string;
+export declare const toNum: (v: any) => number;
+/** Normalise a component value to a string array (handles multi-selects). */
+export declare const toArray: (v: any) => string[];
+/** Normalise a rule value to a string array. */
+export declare const ruleToArray: (v: ConditionRule["value"]) => string[];
+export declare const operators: Record<ConditionOperator, OperatorFn>;
+/**
+ * Evaluate a single operator against a component value.
+ */
+export declare const evaluateOperator: (operator: ConditionOperator, componentValue: any, ruleValue: ConditionRule["value"]) => boolean;
+/**
+ * Evaluate a full condition config using a generic value resolver.
+ * The resolver takes a component UUID (and optionally the full rule)
+ * and returns its current value.
+ * Returns true when the condition group is satisfied.
+ */
+export declare const evaluateConditionConfig: (config: FlowConditionConfig, resolveValue: (uuid: string, rule?: ConditionRule) => any) => boolean;
+export {};
+//# sourceMappingURL=conditions.d.ts.map

package/dist/conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../src/conditions.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,iBAAiB,EACjB,aAAa,EACb,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AAEzC;;;GAGG;AACH,KAAK,UAAU,GAAG,CAChB,cAAc,EAAE,GAAG,EACnB,SAAS,EAAE,aAAa,CAAC,OAAO,CAAC,KAC9B,OAAO,CAAC;AAIb,eAAO,MAAM,KAAK,GAAI,GAAG,GAAG,KAAG,MAAsC,CAAC;AACtE,eAAO,MAAM,KAAK,GAAI,GAAG,GAAG,KAAG,MAAmB,CAAC;AAEnD,6EAA6E;AAC7E,eAAO,MAAM,OAAO,GAAI,GAAG,GAAG,KAAG,MAAM,EAMtC,CAAC;AAEF,gDAAgD;AAChD,eAAO,MAAM,WAAW,GAAI,GAAG,aAAa,CAAC,OAAO,CAAC,KAAG,MAAM,EAI7D,CAAC;AAIF,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,iBAAiB,EAAE,UAAU,CA4C3D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,GAC3B,UAAU,iBAAiB,EAC3B,gBAAgB,GAAG,EACnB,WAAW,aAAa,CAAC,OAAO,CAAC,KAChC,OAIF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,GAClC,QAAQ,mBAAmB,EAC3B,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,aAAa,KAAK,GAAG,KACxD,OAiBF,CAAC"}

package/dist/conditions.js

@@ -0,0 +1,93 @@
+/* ==========================================================================
+   Condition engine — shared between FBRE and server
+   ========================================================================== */
+/* -- helpers -------------------------------------------------------------- */
+export const toStr = (v) => (v == null ? "" : String(v));
+export const toNum = (v) => Number(v);
+/** Normalise a component value to a string array (handles multi-selects). */
+export const toArray = (v) => {
+    if (Array.isArray(v))
+        return v.map(String);
+    if (typeof v === "string" && v.includes(","))
+        return v.split(",").map((s) => s.trim());
+    if (v == null || v === "")
+        return [];
+    return [String(v)];
+};
+/** Normalise a rule value to a string array. */
+export const ruleToArray = (v) => {
+    if (Array.isArray(v))
+        return v.map(String);
+    if (v == null)
+        return [];
+    return [String(v)];
+};
+/* -- operator map --------------------------------------------------------- */
+export const operators = {
+    // Equality
+    equals: (cv, rv) => toStr(cv) === toStr(rv),
+    notEquals: (cv, rv) => toStr(cv) !== toStr(rv),
+    // String
+    contains: (cv, rv) => toStr(cv).includes(toStr(rv)),
+    notContains: (cv, rv) => !toStr(cv).includes(toStr(rv)),
+    startsWith: (cv, rv) => toStr(cv).startsWith(toStr(rv)),
+    endsWith: (cv, rv) => toStr(cv).endsWith(toStr(rv)),
+    // Presence
+    isEmpty: (cv) => cv == null || cv === "" || (Array.isArray(cv) && cv.length === 0),
+    isNotEmpty: (cv) => cv != null && cv !== "" && !(Array.isArray(cv) && cv.length === 0),
+    // Numeric
+    greaterThan: (cv, rv) => toNum(cv) > toNum(rv),
+    greaterThanOrEqual: (cv, rv) => toNum(cv) >= toNum(rv),
+    lessThan: (cv, rv) => toNum(cv) < toNum(rv),
+    lessThanOrEqual: (cv, rv) => toNum(cv) <= toNum(rv),
+    // Set membership (single-value source checked against a list)
+    isOneOf: (cv, rv) => ruleToArray(rv).includes(toStr(cv)),
+    isNotOneOf: (cv, rv) => !ruleToArray(rv).includes(toStr(cv)),
+    // Set membership (multi-value source checked against a list)
+    includesAny: (cv, rv) => {
+        const vals = toArray(cv);
+        return ruleToArray(rv).some((r) => vals.includes(r));
+    },
+    includesAll: (cv, rv) => {
+        const vals = toArray(cv);
+        return ruleToArray(rv).every((r) => vals.includes(r));
+    },
+    includesNone: (cv, rv) => {
+        const vals = toArray(cv);
+        return !ruleToArray(rv).some((r) => vals.includes(r));
+    },
+    // Boolean
+    isTrue: (cv) => cv === true || cv === "true",
+    isFalse: (cv) => cv === false || cv === "false" || cv == null || cv === "",
+};
+/**
+ * Evaluate a single operator against a component value.
+ */
+export const evaluateOperator = (operator, componentValue, ruleValue) => {
+    const fn = operators[operator];
+    if (!fn)
+        return false;
+    return fn(componentValue, ruleValue);
+};
+/**
+ * Evaluate a full condition config using a generic value resolver.
+ * The resolver takes a component UUID (and optionally the full rule)
+ * and returns its current value.
+ * Returns true when the condition group is satisfied.
+ */
+export const evaluateConditionConfig = (config, resolveValue) => {
+    const { logic, rules } = config.when;
+    if (rules.length === 0)
+        return false;
+    if (logic === "and") {
+        return rules.every((rule) => {
+            const cv = resolveValue(rule.source, rule);
+            return evaluateOperator(rule.operator, cv, rule.value);
+        });
+    }
+    // "or"
+    return rules.some((rule) => {
+        const cv = resolveValue(rule.source, rule);
+        return evaluateOperator(rule.operator, cv, rule.value);
+    });
+};

package/dist/formula.d.ts

@@ -0,0 +1,25 @@
+export type FormulaResolver = {
+    /** Resolve a component or calculation value by UUID. */
+    resolveValue: (uuid: string) => number | null;
+    /** Resolve a selected option's metadata value. */
+    resolveOptionMetadata: (uuid: string, metadataKey: string) => number | null;
+    /** Aggregate over repeater iterations: returns array of values for the template child UUID. */
+    resolveRepeaterValues: (uuid: string) => number[] | null;
+};
+/**
+ * Evaluate a formula string using the provided resolver.
+ * Returns the numeric result, or null if the formula is invalid/empty,
+ * has a syntax error, or divides by zero. Unfilled field references
+ * default to 0 (spreadsheet-style).
+ */
+export declare function evaluateFormula(formula: string, resolver: FormulaResolver): number | null;
+/**
+ * Extract all UUIDs referenced in a formula (both direct and inside aggregation functions).
+ * Used for building dependency indexes.
+ */
+export declare function extractFormulaReferences(formula: string): string[];
+/**
+ * Format a calculation result for display.
+ */
+export declare function formatCalculationResult(value: number | null, format?: string, decimalPlaces?: number, currencySymbol?: string): string;
+//# sourceMappingURL=formula.d.ts.map

package/dist/formula.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formula.d.ts","sourceRoot":"","sources":["../src/formula.ts"],"names":[],"mappings":"AAiBA,MAAM,MAAM,eAAe,GAAG;IAC5B,wDAAwD;IACxD,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IAC9C,kDAAkD;IAClD,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IAC5E,+FAA+F;IAC/F,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EAAE,GAAG,IAAI,CAAC;CAC1D,CAAC;AA+WF;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,eAAe,GACxB,MAAM,GAAG,IAAI,CAef;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAYlE;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,GAAG,IAAI,EACpB,MAAM,CAAC,EAAE,MAAM,EACf,aAAa,CAAC,EAAE,MAAM,EACtB,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,CAaR"}

package/dist/formula.js

@@ -0,0 +1,389 @@
+/* ==========================================================================
+   Formula engine — parse and evaluate calculation formulas.
+
+   Syntax:
+     {uuid}                                → component value
+     {uuid}.selectedOption.metadata.key    → option metadata value
+     SUM({uuid})  COUNT({uuid})  AVG({uuid}) → repeater aggregation
+     MIN({uuid})  MAX({uuid})              → repeater min/max aggregation
+     MIN(expr, expr, ...)  MAX(expr, ...)  → scalar min/max of N expressions
+     IF(cond, then, else)                  → conditional (cond != 0 → then)
+     + - * / ( )                           → arithmetic
+     > < >= <= == !=                       → comparison (returns 1 or 0)
+     numeric literals                      → constants
+   ========================================================================== */
+const FN_NAMES = new Set(["SUM", "COUNT", "AVG", "MIN", "MAX", "IF"]);
+function tokenize(formula) {
+    const tokens = [];
+    let i = 0;
+    const len = formula.length;
+    while (i < len) {
+        const ch = formula[i];
+        // Skip whitespace and zero-width spaces (inserted by contentEditable chip editing)
+        if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r" || ch === "\u200B") {
+            i++;
+            continue;
+        }
+        // Number literal
+        if ((ch >= "0" && ch <= "9") || (ch === "." && i + 1 < len && formula[i + 1] >= "0" && formula[i + 1] <= "9")) {
+            let num = "";
+            while (i < len && ((formula[i] >= "0" && formula[i] <= "9") || formula[i] === ".")) {
+                num += formula[i++];
+            }
+            const parsed = parseFloat(num);
+            if (isNaN(parsed))
+                return null;
+            tokens.push({ type: "number", value: num, numValue: parsed });
+            continue;
+        }
+        // Reference: {uuid} or {uuid}.selectedOption.metadata.key
+        if (ch === "{") {
+            const close = formula.indexOf("}", i);
+            if (close === -1)
+                return null;
+            const uuid = formula.substring(i + 1, close).trim();
+            if (!uuid)
+                return null;
+            i = close + 1;
+            // Check for .selectedOption.metadata.key suffix
+            const metaPrefix = ".selectedOption.metadata.";
+            if (formula.substring(i, i + metaPrefix.length) === metaPrefix) {
+                i += metaPrefix.length;
+                let key = "";
+                while (i < len && formula[i] !== " " && formula[i] !== ")" && formula[i] !== "+" && formula[i] !== "-" && formula[i] !== "*" && formula[i] !== "/" && formula[i] !== "," && formula[i] !== ">" && formula[i] !== "<" && formula[i] !== "=" && formula[i] !== "!") {
+                    key += formula[i++];
+                }
+                if (!key)
+                    return null;
+                tokens.push({ type: "metaRef", value: `{${uuid}}.selectedOption.metadata.${key}`, uuid, metaKey: key });
+            }
+            else {
+                tokens.push({ type: "ref", value: `{${uuid}}`, uuid });
+            }
+            continue;
+        }
+        // Function names (SUM, COUNT, AVG)
+        if (ch >= "A" && ch <= "Z") {
+            let name = "";
+            while (i < len && formula[i] >= "A" && formula[i] <= "Z") {
+                name += formula[i++];
+            }
+            if (FN_NAMES.has(name)) {
+                tokens.push({ type: "fn", value: name, fn: name });
+            }
+            else {
+                return null; // Unknown identifier
+            }
+            continue;
+        }
+        // Comma
+        if (ch === ",") {
+            tokens.push({ type: "comma", value: "," });
+            i++;
+            continue;
+        }
+        // Comparison operators (multi-char first: >=, <=, ==, !=)
+        if (ch === ">" || ch === "<" || ch === "=" || ch === "!") {
+            if (i + 1 < len && formula[i + 1] === "=") {
+                tokens.push({ type: "comp", value: ch + "=" });
+                i += 2;
+                continue;
+            }
+            if (ch === ">" || ch === "<") {
+                tokens.push({ type: "comp", value: ch });
+                i++;
+                continue;
+            }
+            // Lone '=' or '!' without '=' following is invalid
+            return null;
+        }
+        // Arithmetic operators
+        if (ch === "+" || ch === "-" || ch === "*" || ch === "/") {
+            tokens.push({ type: "op", value: ch });
+            i++;
+            continue;
+        }
+        // Parentheses
+        if (ch === "(") {
+            tokens.push({ type: "lparen", value: "(" });
+            i++;
+            continue;
+        }
+        if (ch === ")") {
+            tokens.push({ type: "rparen", value: ")" });
+            i++;
+            continue;
+        }
+        // Unknown character
+        return null;
+    }
+    return tokens;
+}
+function peek(ctx) {
+    return ctx.pos < ctx.tokens.length ? ctx.tokens[ctx.pos] : null;
+}
+function consume(ctx) {
+    return ctx.pos < ctx.tokens.length ? ctx.tokens[ctx.pos++] : null;
+}
+// Evaluate aggregation function over repeater values
+function evaluateAggregation(fn, uuid, resolver) {
+    const values = resolver.resolveRepeaterValues(uuid) ?? [];
+    if (values.length === 0) {
+        return fn === "AVG" ? null : 0;
+    }
+    switch (fn) {
+        case "SUM":
+            return values.reduce((a, b) => a + b, 0);
+        case "COUNT":
+            return values.length;
+        case "AVG":
+            return values.reduce((a, b) => a + b, 0) / values.length;
+        case "MIN":
+            return Math.min(...values);
+        case "MAX":
+            return Math.max(...values);
+        default:
+            return null;
+    }
+}
+// Parse comma-separated argument list: expr (',' expr)* ')'
+// Assumes lparen already consumed; consumes the closing rparen.
+function parseArgList(ctx) {
+    const args = [];
+    // First argument
+    const first = parseExpression(ctx);
+    if (first === null)
+        return null;
+    args.push(first);
+    while (true) {
+        const t = peek(ctx);
+        if (!t)
+            return null;
+        if (t.type === "rparen") {
+            consume(ctx);
+            return args;
+        }
+        if (t.type !== "comma")
+            return null;
+        consume(ctx); // consume comma
+        const arg = parseExpression(ctx);
+        if (arg === null)
+            return null;
+        args.push(arg);
+    }
+}
+// Expression = Comparison
+function parseExpression(ctx) {
+    return parseComparison(ctx);
+}
+// Comparison = Additive (CompOp Additive)?
+function parseComparison(ctx) {
+    let left = parseAdditive(ctx);
+    if (left === null)
+        return null;
+    const t = peek(ctx);
+    if (t && t.type === "comp") {
+        consume(ctx);
+        const right = parseAdditive(ctx);
+        if (right === null)
+            return null;
+        switch (t.value) {
+            case ">": return left > right ? 1 : 0;
+            case "<": return left < right ? 1 : 0;
+            case ">=": return left >= right ? 1 : 0;
+            case "<=": return left <= right ? 1 : 0;
+            case "==": return left === right ? 1 : 0;
+            case "!=": return left !== right ? 1 : 0;
+            default: return null;
+        }
+    }
+    return left;
+}
+// Additive = Term (('+' | '-') Term)*
+function parseAdditive(ctx) {
+    let left = parseTerm(ctx);
+    if (left === null)
+        return null;
+    while (true) {
+        const t = peek(ctx);
+        if (!t || t.type !== "op" || (t.value !== "+" && t.value !== "-"))
+            break;
+        consume(ctx);
+        const right = parseTerm(ctx);
+        if (right === null)
+            return null;
+        left = t.value === "+" ? left + right : left - right;
+    }
+    return left;
+}
+// Term = Unary (('*' | '/') Unary)*
+function parseTerm(ctx) {
+    let left = parseUnary(ctx);
+    if (left === null)
+        return null;
+    while (true) {
+        const t = peek(ctx);
+        if (!t || t.type !== "op" || (t.value !== "*" && t.value !== "/"))
+            break;
+        consume(ctx);
+        const right = parseUnary(ctx);
+        if (right === null)
+            return null;
+        if (t.value === "*") {
+            left = left * right;
+        }
+        else {
+            if (right === 0)
+                return null; // Division by zero → null
+            left = left / right;
+        }
+    }
+    return left;
+}
+// Unary = ('-')? Primary
+function parseUnary(ctx) {
+    const t = peek(ctx);
+    if (t && t.type === "op" && t.value === "-") {
+        consume(ctx);
+        const val = parsePrimary(ctx);
+        return val === null ? null : -val;
+    }
+    return parsePrimary(ctx);
+}
+// Primary = Number | Ref | MetaRef | FnCall | '(' Expression ')'
+function parsePrimary(ctx) {
+    const t = peek(ctx);
+    if (!t)
+        return null;
+    // Number literal
+    if (t.type === "number") {
+        consume(ctx);
+        return t.numValue;
+    }
+    // Field reference
+    if (t.type === "ref") {
+        consume(ctx);
+        return ctx.resolver.resolveValue(t.uuid) ?? 0;
+    }
+    // Metadata reference
+    if (t.type === "metaRef") {
+        consume(ctx);
+        return ctx.resolver.resolveOptionMetadata(t.uuid, t.metaKey) ?? 0;
+    }
+    // Function call
+    if (t.type === "fn") {
+        consume(ctx);
+        const lp = consume(ctx);
+        if (!lp || lp.type !== "lparen")
+            return null;
+        const fn = t.fn;
+        // Aggregation-only functions: SUM, COUNT, AVG — always single ref
+        if (fn === "SUM" || fn === "COUNT" || fn === "AVG") {
+            const arg = consume(ctx);
+            if (!arg || arg.type !== "ref")
+                return null;
+            const rp = consume(ctx);
+            if (!rp || rp.type !== "rparen")
+                return null;
+            return evaluateAggregation(fn, arg.uuid, ctx.resolver);
+        }
+        // MIN/MAX — detect mode: single ref aggregation vs multi-arg scalar
+        if (fn === "MIN" || fn === "MAX") {
+            // Peek: if next is a ref followed by rparen → aggregation mode
+            const next = peek(ctx);
+            if (next && next.type === "ref") {
+                const saved = ctx.pos;
+                consume(ctx); // consume the ref
+                const after = peek(ctx);
+                if (after && after.type === "rparen") {
+                    consume(ctx); // consume rparen
+                    return evaluateAggregation(fn, next.uuid, ctx.resolver);
+                }
+                // Not aggregation — backtrack and parse as multi-arg
+                ctx.pos = saved;
+            }
+            // Multi-arg scalar: MIN(expr, expr, ...) / MAX(expr, expr, ...)
+            const args = parseArgList(ctx);
+            if (args === null || args.length === 0)
+                return null;
+            return fn === "MIN" ? Math.min(...args) : Math.max(...args);
+        }
+        // IF(condition, thenExpr, elseExpr)
+        if (fn === "IF") {
+            const args = parseArgList(ctx);
+            if (args === null || args.length !== 3)
+                return null;
+            return args[0] !== 0 ? args[1] : args[2];
+        }
+        return null;
+    }
+    // Parenthesized expression
+    if (t.type === "lparen") {
+        consume(ctx);
+        const val = parseExpression(ctx);
+        const rp = consume(ctx);
+        if (!rp || rp.type !== "rparen")
+            return null;
+        return val;
+    }
+    return null;
+}
+/* ---------- Public API ---------- */
+/**
+ * Evaluate a formula string using the provided resolver.
+ * Returns the numeric result, or null if the formula is invalid/empty,
+ * has a syntax error, or divides by zero. Unfilled field references
+ * default to 0 (spreadsheet-style).
+ */
+export function evaluateFormula(formula, resolver) {
+    if (!formula || !formula.trim())
+        return null;
+    // Strip zero-width spaces that may leak from contentEditable chip editing
+    const clean = formula.replace(/\u200B/g, "");
+    if (!clean.trim())
+        return null;
+    const tokens = tokenize(clean);
+    if (!tokens || tokens.length === 0)
+        return null;
+    const ctx = { tokens, pos: 0, resolver };
+    const result = parseExpression(ctx);
+    // Ensure all tokens were consumed
+    if (ctx.pos !== ctx.tokens.length)
+        return null;
+    return result;
+}
+/**
+ * Extract all UUIDs referenced in a formula (both direct and inside aggregation functions).
+ * Used for building dependency indexes.
+ */
+export function extractFormulaReferences(formula) {
+    if (!formula)
+        return [];
+    const uuids = [];
+    const refPattern = /\{([^}]+)\}/g;
+    let match;
+    while ((match = refPattern.exec(formula)) !== null) {
+        const uuid = match[1].trim();
+        if (uuid && !uuids.includes(uuid)) {
+            uuids.push(uuid);
+        }
+    }
+    return uuids;
+}
+/**
+ * Format a calculation result for display.
+ */
+export function formatCalculationResult(value, format, decimalPlaces, currencySymbol) {
+    if (value === null)
+        return "";
+    const dp = decimalPlaces ?? 2;
+    const formatted = value.toFixed(dp);
+    switch (format) {
+        case "currency":
+            return `${currencySymbol ?? "$"}${formatted}`;
+        case "percentage":
+            return `${formatted}%`;
+        default:
+            return formatted;
+    }
+}

package/dist/formula.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=formula.test.d.ts.map

package/dist/formula.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formula.test.d.ts","sourceRoot":"","sources":["../src/formula.test.ts"],"names":[],"mappings":""}

package/dist/formula.test.js

@@ -0,0 +1,312 @@
+import { describe, it, expect } from "vitest";
+import { evaluateFormula, extractFormulaReferences, formatCalculationResult } from "./formula";
+/* ---------- Test helpers ---------- */
+function makeResolver(values = {}, repeaterValues = {}, metaValues = {}) {
+    return {
+        resolveValue: (uuid) => values[uuid] ?? null,
+        resolveOptionMetadata: (uuid, key) => metaValues[uuid]?.[key] ?? null,
+        resolveRepeaterValues: (uuid) => repeaterValues[uuid] ?? null,
+    };
+}
+const empty = makeResolver();
+/* ==========================================================================
+   Tokenizer / basic parsing
+   ========================================================================== */
+describe("basic expressions", () => {
+    it("evaluates number literals", () => {
+        expect(evaluateFormula("42", empty)).toBe(42);
+        expect(evaluateFormula("3.14", empty)).toBe(3.14);
+    });
+    it("evaluates addition and subtraction", () => {
+        expect(evaluateFormula("1 + 2", empty)).toBe(3);
+        expect(evaluateFormula("10 - 3", empty)).toBe(7);
+        expect(evaluateFormula("1 + 2 + 3", empty)).toBe(6);
+    });
+    it("evaluates multiplication and division", () => {
+        expect(evaluateFormula("2 * 3", empty)).toBe(6);
+        expect(evaluateFormula("10 / 4", empty)).toBe(2.5);
+    });
+    it("respects operator precedence", () => {
+        expect(evaluateFormula("1 + 2 * 3", empty)).toBe(7);
+        expect(evaluateFormula("10 - 4 / 2", empty)).toBe(8);
+    });
+    it("respects parentheses", () => {
+        expect(evaluateFormula("(1 + 2) * 3", empty)).toBe(9);
+        expect(evaluateFormula("(10 - 4) / 2", empty)).toBe(3);
+    });
+    it("handles unary negation", () => {
+        expect(evaluateFormula("-5", empty)).toBe(-5);
+        expect(evaluateFormula("-5 + 3", empty)).toBe(-2);
+        expect(evaluateFormula("-(5 + 3)", empty)).toBe(-8);
+    });
+    it("returns null for division by zero", () => {
+        expect(evaluateFormula("1 / 0", empty)).toBe(null);
+    });
+    it("returns null for empty/whitespace", () => {
+        expect(evaluateFormula("", empty)).toBe(null);
+        expect(evaluateFormula("   ", empty)).toBe(null);
+    });
+    it("returns null for invalid syntax", () => {
+        expect(evaluateFormula("1 +", empty)).toBe(null);
+        expect(evaluateFormula("+ 1", empty)).toBe(null);
+        expect(evaluateFormula("1 2", empty)).toBe(null);
+        expect(evaluateFormula("(1 + 2", empty)).toBe(null);
+    });
+});
+/* ==========================================================================
+   Field references
+   ========================================================================== */
+describe("field references", () => {
+    it("resolves a field value", () => {
+        const r = makeResolver({ "abc-123": 10 });
+        expect(evaluateFormula("{abc-123}", r)).toBe(10);
+    });
+    it("defaults null references to 0", () => {
+        expect(evaluateFormula("{missing}", empty)).toBe(0);
+    });
+    it("uses refs in arithmetic", () => {
+        const r = makeResolver({ a: 5, b: 3 });
+        expect(evaluateFormula("{a} + {b}", r)).toBe(8);
+        expect(evaluateFormula("{a} * {b}", r)).toBe(15);
+    });
+});
+/* ==========================================================================
+   Aggregation functions: SUM, COUNT, AVG
+   ========================================================================== */
+describe("SUM / COUNT / AVG", () => {
+    const r = makeResolver({}, { items: [10, 20, 30] });
+    it("SUM", () => {
+        expect(evaluateFormula("SUM({items})", r)).toBe(60);
+    });
+    it("COUNT", () => {
+        expect(evaluateFormula("COUNT({items})", r)).toBe(3);
+    });
+    it("AVG", () => {
+        expect(evaluateFormula("AVG({items})", r)).toBe(20);
+    });
+    it("SUM of empty repeater returns 0", () => {
+        const r2 = makeResolver({}, { items: [] });
+        expect(evaluateFormula("SUM({items})", r2)).toBe(0);
+    });
+    it("AVG of empty repeater returns null", () => {
+        const r2 = makeResolver({}, { items: [] });
+        expect(evaluateFormula("AVG({items})", r2)).toBe(null);
+    });
+    it("COUNT of empty repeater returns 0", () => {
+        const r2 = makeResolver({}, { items: [] });
+        expect(evaluateFormula("COUNT({items})", r2)).toBe(0);
+    });
+    it("SUM in expression", () => {
+        expect(evaluateFormula("SUM({items}) * 2", r)).toBe(120);
+    });
+});
+/* ==========================================================================
+   MIN / MAX — aggregation mode
+   ========================================================================== */
+describe("MIN / MAX aggregation", () => {
+    const r = makeResolver({}, { prices: [50, 10, 30, 80] });
+    it("MIN({ref}) returns smallest repeater value", () => {
+        expect(evaluateFormula("MIN({prices})", r)).toBe(10);
+    });
+    it("MAX({ref}) returns largest repeater value", () => {
+        expect(evaluateFormula("MAX({prices})", r)).toBe(80);
+    });
+    it("MIN of empty repeater returns 0", () => {
+        const r2 = makeResolver({}, { prices: [] });
+        expect(evaluateFormula("MIN({prices})", r2)).toBe(0);
+    });
+    it("MAX of empty repeater returns 0", () => {
+        const r2 = makeResolver({}, { prices: [] });
+        expect(evaluateFormula("MAX({prices})", r2)).toBe(0);
+    });
+    it("MIN in expression", () => {
+        expect(evaluateFormula("MIN({prices}) + 5", r)).toBe(15);
+    });
+});
+/* ==========================================================================
+   MIN / MAX — scalar (multi-arg) mode
+   ========================================================================== */
+describe("MIN / MAX scalar", () => {
+    it("MIN(a, b) returns smaller", () => {
+        const r = makeResolver({ a: 10, b: 25 });
+        expect(evaluateFormula("MIN({a}, {b})", r)).toBe(10);
+    });
+    it("MAX(a, b) returns larger", () => {
+        const r = makeResolver({ a: 10, b: 25 });
+        expect(evaluateFormula("MAX({a}, {b})", r)).toBe(25);
+    });
+    it("MIN with 3 args", () => {
+        const r = makeResolver({ a: 5, b: 3, c: 9 });
+        expect(evaluateFormula("MIN({a}, {b}, {c})", r)).toBe(3);
+    });
+    it("MAX with literals", () => {
+        expect(evaluateFormula("MAX(10, 20, 5)", empty)).toBe(20);
+    });
+    it("MIN with expressions", () => {
+        const r = makeResolver({ x: 15 });
+        expect(evaluateFormula("MIN({x}, 25)", r)).toBe(15);
+        expect(evaluateFormula("MIN({x}, 10)", r)).toBe(10);
+    });
+    it("MAX for discount capping: MIN({discount}, 25)", () => {
+        const r = makeResolver({ discount: 30 });
+        expect(evaluateFormula("MIN({discount}, 25)", r)).toBe(25);
+    });
+    it("MAX for minimum charge: MAX({total}, 500)", () => {
+        const r = makeResolver({ total: 300 });
+        expect(evaluateFormula("MAX({total}, 500)", r)).toBe(500);
+        const r2 = makeResolver({ total: 700 });
+        expect(evaluateFormula("MAX({total}, 500)", r2)).toBe(700);
+    });
+});
+/* ==========================================================================
+   Comparison operators
+   ========================================================================== */
+describe("comparison operators", () => {
+    it("greater than", () => {
+        expect(evaluateFormula("5 > 3", empty)).toBe(1);
+        expect(evaluateFormula("3 > 5", empty)).toBe(0);
+        expect(evaluateFormula("3 > 3", empty)).toBe(0);
+    });
+    it("less than", () => {
+        expect(evaluateFormula("3 < 5", empty)).toBe(1);
+        expect(evaluateFormula("5 < 3", empty)).toBe(0);
+    });
+    it("greater than or equal", () => {
+        expect(evaluateFormula("5 >= 5", empty)).toBe(1);
+        expect(evaluateFormula("6 >= 5", empty)).toBe(1);
+        expect(evaluateFormula("4 >= 5", empty)).toBe(0);
+    });
+    it("less than or equal", () => {
+        expect(evaluateFormula("5 <= 5", empty)).toBe(1);
+        expect(evaluateFormula("4 <= 5", empty)).toBe(1);
+        expect(evaluateFormula("6 <= 5", empty)).toBe(0);
+    });
+    it("equal", () => {
+        expect(evaluateFormula("5 == 5", empty)).toBe(1);
+        expect(evaluateFormula("5 == 6", empty)).toBe(0);
+    });
+    it("not equal", () => {
+        expect(evaluateFormula("5 != 6", empty)).toBe(1);
+        expect(evaluateFormula("5 != 5", empty)).toBe(0);
+    });
+    it("comparison with field refs", () => {
+        const r = makeResolver({ qty: 15 });
+        expect(evaluateFormula("{qty} > 10", r)).toBe(1);
+        expect(evaluateFormula("{qty} > 20", r)).toBe(0);
+    });
+    it("comparison with arithmetic", () => {
+        expect(evaluateFormula("2 + 3 > 4", empty)).toBe(1);
+        expect(evaluateFormula("2 * 3 <= 5", empty)).toBe(0);
+    });
+    it("rejects lone = or !", () => {
+        expect(evaluateFormula("5 = 5", empty)).toBe(null);
+        expect(evaluateFormula("!5", empty)).toBe(null);
+    });
+});
+/* ==========================================================================
+   IF function
+   ========================================================================== */
+describe("IF function", () => {
+    it("basic IF true branch", () => {
+        expect(evaluateFormula("IF(1, 10, 20)", empty)).toBe(10);
+    });
+    it("basic IF false branch", () => {
+        expect(evaluateFormula("IF(0, 10, 20)", empty)).toBe(20);
+    });
+    it("IF with comparison condition", () => {
+        const r = makeResolver({ qty: 15 });
+        expect(evaluateFormula("IF({qty} > 10, {qty} * 0.9, {qty})", r)).toBe(13.5);
+    });
+    it("IF with comparison condition (false)", () => {
+        const r = makeResolver({ qty: 5 });
+        expect(evaluateFormula("IF({qty} > 10, {qty} * 0.9, {qty})", r)).toBe(5);
+    });
+    it("nested IF", () => {
+        const r = makeResolver({ qty: 25 });
+        // IF(qty > 20, price * 0.8, IF(qty > 10, price * 0.9, price))
+        expect(evaluateFormula("IF({qty} > 20, 100 * 0.8, IF({qty} > 10, 100 * 0.9, 100))", r)).toBe(80);
+    });
+    it("nested IF middle tier", () => {
+        const r = makeResolver({ qty: 15 });
+        expect(evaluateFormula("IF({qty} > 20, 100 * 0.8, IF({qty} > 10, 100 * 0.9, 100))", r)).toBe(90);
+    });
+    it("nested IF lowest tier", () => {
+        const r = makeResolver({ qty: 5 });
+        expect(evaluateFormula("IF({qty} > 20, 100 * 0.8, IF({qty} > 10, 100 * 0.9, 100))", r)).toBe(100);
+    });
+    it("IF with wrong arity returns null", () => {
+        expect(evaluateFormula("IF(1, 2)", empty)).toBe(null);
+        expect(evaluateFormula("IF(1, 2, 3, 4)", empty)).toBe(null);
+    });
+    it("IF evaluates both branches (not lazy)", () => {
+        // This should not error even though the else branch divides by zero
+        // Because IF is not lazy - both evaluate, and div-by-zero returns null
+        // which makes the whole IF null
+        expect(evaluateFormula("IF(1, 10, 1 / 0)", empty)).toBe(null);
+    });
+    it("tiered pricing formula", () => {
+        const r = makeResolver({ qty: 12, price: 50 });
+        // IF(qty > 10, price * 0.9, price)
+        expect(evaluateFormula("IF({qty} > 10, {price} * 0.9, {price})", r)).toBe(45);
+    });
+});
+/* ==========================================================================
+   Combined scenarios
+   ========================================================================== */
+describe("combined scenarios", () => {
+    it("MIN/MAX with IF", () => {
+        const r = makeResolver({ discount: 30 });
+        // Clamp discount: MIN(MAX({discount}, 0), 25) → clamp 0..25
+        expect(evaluateFormula("MIN(MAX({discount}, 0), 25)", r)).toBe(25);
+    });
+    it("IF with aggregation", () => {
+        const r = makeResolver({}, { items: [10, 20, 30] });
+        // IF(COUNT({items}) > 2, SUM({items}), 0)
+        // But COUNT and SUM are aggregation-only, so we need to test differently:
+        // The IF args would be separate expressions
+        // Actually this won't work directly since IF needs comma-separated expressions
+        // and SUM({items}) followed by comma would be parsed correctly
+        expect(evaluateFormula("SUM({items}) + MAX({items})", r)).toBe(90);
+    });
+    it("metadata reference with arithmetic", () => {
+        const r = makeResolver({}, {}, { sel: { price: 25 } });
+        expect(evaluateFormula("{sel}.selectedOption.metadata.price * 2", r)).toBe(50);
+    });
+});
+/* ==========================================================================
+   extractFormulaReferences
+   ========================================================================== */
+describe("extractFormulaReferences", () => {
+    it("extracts single ref", () => {
+        expect(extractFormulaReferences("{abc}")).toEqual(["abc"]);
+    });
+    it("extracts multiple refs", () => {
+        expect(extractFormulaReferences("{a} + {b}")).toEqual(["a", "b"]);
+    });
+    it("extracts refs from functions", () => {
+        expect(extractFormulaReferences("SUM({items})")).toEqual(["items"]);
+    });
+    it("deduplicates", () => {
+        expect(extractFormulaReferences("{a} + {a}")).toEqual(["a"]);
+    });
+    it("returns empty for no formula", () => {
+        expect(extractFormulaReferences("")).toEqual([]);
+    });
+});
+/* ==========================================================================
+   formatCalculationResult
+   ========================================================================== */
+describe("formatCalculationResult", () => {
+    it("formats currency", () => {
+        expect(formatCalculationResult(1234.5, "currency", 2, "$")).toBe("$1234.50");
+    });
+    it("formats percentage", () => {
+        expect(formatCalculationResult(75.123, "percentage", 1)).toBe("75.1%");
+    });
+    it("formats number (default)", () => {
+        expect(formatCalculationResult(42, undefined, 0)).toBe("42");
+    });
+    it("returns empty for null", () => {
+        expect(formatCalculationResult(null)).toBe("");
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { operators, evaluateOperator, evaluateConditionConfig, toStr, toNum, toArray, ruleToArray, } from "./conditions";
+export { isHiddenByCondition } from "./condition-visibility";
+export { validateValue, getDefaultMessage, formatBytes, isEmpty, } from "./validation";
+export { evaluateFormula, extractFormulaReferences, formatCalculationResult, type FormulaResolver, } from "./formula";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,SAAS,EACT,gBAAgB,EAChB,uBAAuB,EACvB,KAAK,EACL,KAAK,EACL,OAAO,EACP,WAAW,GACZ,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAE7D,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,OAAO,GACR,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,uBAAuB,EACvB,KAAK,eAAe,GACrB,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+// @sonata-innovations/fiber-shared — condition engine, validation engine, visibility helpers, formula engine
+export { operators, evaluateOperator, evaluateConditionConfig, toStr, toNum, toArray, ruleToArray, } from "./conditions";
+export { isHiddenByCondition } from "./condition-visibility";
+export { validateValue, getDefaultMessage, formatBytes, isEmpty, } from "./validation";
+export { evaluateFormula, extractFormulaReferences, formatCalculationResult, } from "./formula";

package/dist/validation.d.ts

@@ -0,0 +1,14 @@
+import type { ValidationRule, FlowValidationConfig } from "@sonata-innovations/fiber-types";
+export declare function formatBytes(bytes: number): string;
+export declare const getDefaultMessage: (rule: ValidationRule) => string;
+export declare const isEmpty: (value: any) => boolean;
+/**
+ * Validate a single value against a validation config.
+ * Returns an array of error messages (empty = valid).
+ *
+ * @param value The component's current value
+ * @param config The validation config (rules array)
+ * @param resolveFieldValue Optional callback to resolve another field's value (for matchesField)
+ */
+export declare const validateValue: (value: any, config: FlowValidationConfig, resolveFieldValue?: (fieldUUID: string) => any) => string[];
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,cAAc,EACd,oBAAoB,EACrB,MAAM,iCAAiC,CAAC;AA+BzC,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIjD;AAED,eAAO,MAAM,iBAAiB,GAAI,MAAM,cAAc,KAAG,MAkCxD,CAAC;AAIF,eAAO,MAAM,OAAO,GAAI,OAAO,GAAG,KAAG,OAKpC,CAAC;AAiIF;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,GACxB,OAAO,GAAG,EACV,QAAQ,oBAAoB,EAC5B,oBAAoB,CAAC,SAAS,EAAE,MAAM,KAAK,GAAG,KAC7C,MAAM,EA+BR,CAAC"}

package/dist/validation.js

@@ -0,0 +1,232 @@
+/* ==========================================================================
+   Validation engine — shared between FBRE and server
+   ========================================================================== */
+/* ---------- Default messages ---------- */
+const DEFAULT_MESSAGES = {
+    "validation.required": "This field is required",
+    "validation.email": "Please enter a valid email address",
+    "validation.phone": "Please enter a valid phone number",
+    "validation.url": "Please enter a valid URL",
+    "validation.minLength": (min) => `Must be at least ${min} characters`,
+    "validation.maxLength": (max) => `Must be no more than ${max} characters`,
+    "validation.exactLength": (len) => `Must be exactly ${len} characters`,
+    "validation.minValue": (min) => `Must be at least ${min}`,
+    "validation.maxValue": (max) => `Must be no more than ${max}`,
+    "validation.pattern": "Value does not match the required format",
+    "validation.minSelected": (min) => `Select at least ${min} option${min !== 1 ? "s" : ""}`,
+    "validation.maxSelected": (max) => `Select no more than ${max} option${max !== 1 ? "s" : ""}`,
+    "validation.fileType": "File type is not allowed",
+    "validation.fileSize": (max) => `File must be smaller than ${formatBytes(max)}`,
+    "validation.contains": (text) => `Must contain "${text}"`,
+    "validation.excludes": (text) => `Must not contain "${text}"`,
+    "validation.matchesField": "Fields must match",
+};
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+export const getDefaultMessage = (rule) => {
+    const key = `validation.${rule.type}`;
+    const template = DEFAULT_MESSAGES[key];
+    if (!template)
+        return "Invalid value";
+    if (typeof template === "function") {
+        const p = rule.params ?? {};
+        switch (rule.type) {
+            case "minLength":
+                return template(p.min ?? 0);
+            case "maxLength":
+                return template(p.max ?? 0);
+            case "exactLength":
+                return template(p.length ?? 0);
+            case "minValue":
+                return template(p.min ?? 0);
+            case "maxValue":
+                return template(p.max ?? 0);
+            case "minSelected":
+                return template(p.min ?? 0);
+            case "maxSelected":
+                return template(p.max ?? 0);
+            case "fileSize":
+                return template(p.max ?? 0);
+            case "contains":
+                return template(p.text ?? "");
+            case "excludes":
+                return template(p.text ?? "");
+            default:
+                return template();
+        }
+    }
+    return template;
+};
+/* ---------- Emptiness check ---------- */
+export const isEmpty = (value) => {
+    if (value === null || value === undefined)
+        return true;
+    if (typeof value === "string" && value.length === 0)
+        return true;
+    if (Array.isArray(value) && value.length === 0)
+        return true;
+    return false;
+};
+/* ---------- Email / phone / URL patterns ---------- */
+// RFC 5322-ish: local@domain.tld — covers 99%+ of real addresses
+const EMAIL_RE = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*\.[a-zA-Z]{2,}$/;
+// International phone: optional +, digits/spaces/dashes/parens/dots, 7-15 digit core
+const PHONE_RE = /^\+?[\d]{1,4}?[\s.\-()]?(?:[\d][\s.\-()]?){6,14}[\d]$/;
+// URL: http(s) with domain, optional port/path/query/fragment
+const URL_RE = /^https?:\/\/(?:[\w-]+\.)+[a-zA-Z]{2,}(?::\d{1,5})?(?:[/?#]\S*)?$/i;
+const VALIDATORS = {
+    required: (value) => !isEmpty(value),
+    email: (value) => {
+        if (isEmpty(value))
+            return true;
+        return EMAIL_RE.test(String(value));
+    },
+    phone: (value) => {
+        if (isEmpty(value))
+            return true;
+        return PHONE_RE.test(String(value));
+    },
+    url: (value) => {
+        if (isEmpty(value))
+            return true;
+        return URL_RE.test(String(value));
+    },
+    minLength: (value, params) => {
+        if (isEmpty(value))
+            return true;
+        return String(value).length >= (params.min ?? 0);
+    },
+    maxLength: (value, params) => {
+        if (isEmpty(value))
+            return true;
+        return String(value).length <= (params.max ?? Infinity);
+    },
+    exactLength: (value, params) => {
+        if (isEmpty(value))
+            return true;
+        return String(value).length === (params.length ?? 0);
+    },
+    minValue: (value, params) => {
+        if (isEmpty(value))
+            return true;
+        return Number(value) >= (params.min ?? -Infinity);
+    },
+    maxValue: (value, params) => {
+        if (isEmpty(value))
+            return true;
+        return Number(value) <= (params.max ?? Infinity);
+    },
+    pattern: (value, params) => {
+        if (isEmpty(value))
+            return true;
+        try {
+            return new RegExp(params.regex ?? "").test(String(value));
+        }
+        catch {
+            // Invalid regex — fail-safe (reject value so misconfiguration is visible)
+            return false;
+        }
+    },
+    minSelected: (value, params) => {
+        if (isEmpty(value))
+            return true;
+        if (!Array.isArray(value))
+            return true;
+        return value.length >= (params.min ?? 0);
+    },
+    maxSelected: (value, params) => {
+        if (isEmpty(value))
+            return true;
+        if (!Array.isArray(value))
+            return true;
+        return value.length <= (params.max ?? Infinity);
+    },
+    fileType: (value, params) => {
+        if (isEmpty(value))
+            return true;
+        const allowed = params.types;
+        if (!allowed || allowed.length === 0)
+            return true;
+        const fileName = value?.name ?? "";
+        const fileType = value?.type ?? "";
+        return allowed.some((t) => {
+            const lower = t.toLowerCase().trim();
+            if (lower.startsWith(".")) {
+                return fileName.toLowerCase().endsWith(lower);
+            }
+            return fileType.toLowerCase() === lower;
+        });
+    },
+    fileSize: (value, params) => {
+        if (isEmpty(value))
+            return true;
+        const maxSize = params.max ?? Infinity;
+        return (value?.size ?? 0) <= maxSize;
+    },
+    contains: (value, params) => {
+        if (isEmpty(value))
+            return true;
+        const text = params.text ?? "";
+        if (!text)
+            return true;
+        return String(value).includes(text);
+    },
+    excludes: (value, params) => {
+        if (isEmpty(value))
+            return true;
+        const text = params.text ?? "";
+        if (!text)
+            return true;
+        return !String(value).includes(text);
+    },
+    // matchesField is handled externally via resolveFieldValue callback
+    matchesField: (value, params) => {
+        // This validator requires external resolution; always passes here.
+        // Use validateValue() with resolveFieldValue callback for matchesField support.
+        return true;
+    },
+};
+/* ---------- Public API ---------- */
+/**
+ * Validate a single value against a validation config.
+ * Returns an array of error messages (empty = valid).
+ *
+ * @param value The component's current value
+ * @param config The validation config (rules array)
+ * @param resolveFieldValue Optional callback to resolve another field's value (for matchesField)
+ */
+export const validateValue = (value, config, resolveFieldValue) => {
+    if (!config || !config.rules || config.rules.length === 0)
+        return [];
+    const errors = [];
+    for (const rule of config.rules) {
+        if (rule.type === "matchesField") {
+            // Special handling: needs external field resolution
+            if (isEmpty(value))
+                continue;
+            const fieldUUID = rule.params?.field ?? "";
+            if (!fieldUUID)
+                continue;
+            if (resolveFieldValue) {
+                const otherValue = resolveFieldValue(fieldUUID);
+                if (String(value) !== String(otherValue ?? "")) {
+                    errors.push(rule.message ?? getDefaultMessage(rule));
+                }
+            }
+            continue;
+        }
+        const validator = VALIDATORS[rule.type];
+        if (!validator)
+            continue;
+        const passed = validator(value, rule.params ?? {});
+        if (!passed) {
+            errors.push(rule.message ?? getDefaultMessage(rule));
+        }
+    }
+    return errors;
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+	"name": "@sonata-innovations/fiber-shared",
+	"version": "1.0.0",
+	"description": "Shared condition and validation engines for the Fiber form builder system",
+	"keywords": ["fiber", "form-builder", "validation", "conditions", "shared"],
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/sonata-innovations/fiber.git",
+		"directory": "shared"
+	},
+	"bugs": { "url": "https://github.com/sonata-innovations/fiber/issues" },
+	"homepage": "https://github.com/sonata-innovations/fiber",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"sideEffects": false,
+	"scripts": {
+		"build": "tsc",
+		"test": "vitest run",
+		"test:watch": "vitest"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"dependencies": {
+		"@sonata-innovations/fiber-types": "^1.0.0"
+	},
+	"devDependencies": {
+		"typescript": "^5.7.0",
+		"vitest": "^4.0.18"
+	}
+}