@freighttech/ui 0.13.18

package/dist/backend/dynamic-table/formula/check.js

@@ -0,0 +1,243 @@
+import { formulaIssue } from "./types.js";
+import { collectFieldRefs, parseFormula } from "./parse.js";
+import { declaredArgType, lookupFormulaFunction, resolveResultType, unifyTypes } from "./functions.js";
+const ORDERABLE = ["number", "date", "text", "unknown"];
+function describeNode(node, fields) {
+  switch (node.k) {
+    case "field":
+      return fields.get(node.name)?.label ?? node.name;
+    case "call":
+      return `${node.fn}()`;
+    case "lit":
+      return node.v === null ? "empty" : JSON.stringify(node.v);
+    default:
+      return "the expression";
+  }
+}
+function typeAccepts(expected, actual) {
+  if (expected === "unknown" || actual === "unknown") return true;
+  return expected === actual;
+}
+function checkAst(ast, ctx) {
+  const fields = new Map(ctx.fields.map((f) => [f.key, f]));
+  const issues = [];
+  const walk = (node) => {
+    switch (node.k) {
+      case "lit": {
+        if (node.v === null) return "unknown";
+        if (typeof node.v === "number") return "number";
+        if (typeof node.v === "boolean") return "boolean";
+        return "text";
+      }
+      case "field": {
+        const meta = fields.get(node.name);
+        if (!meta) {
+          issues.push(
+            formulaIssue("unknown_field", `Unknown column: ${node.name}`, { name: node.name })
+          );
+          return "unknown";
+        }
+        return meta.type;
+      }
+      case "neg": {
+        const inner = walk(node.e);
+        if (!typeAccepts("number", inner)) {
+          const name = describeNode(node.e, fields);
+          issues.push(formulaIssue("type_mismatch", `${name} is not a number`, { name }));
+        }
+        return "number";
+      }
+      case "call": {
+        const def = lookupFormulaFunction(node.fn);
+        if (!def) {
+          issues.push(
+            formulaIssue("unknown_function", `Unknown function: ${node.fn}`, { name: node.fn })
+          );
+          node.args.forEach(walk);
+          return "unknown";
+        }
+        const argTypes = node.args.map(walk);
+        if (node.args.length < def.minArgs || node.args.length > def.maxArgs) {
+          issues.push(
+            formulaIssue("arity", `${def.name} takes ${def.signature}`, {
+              name: def.name,
+              signature: def.signature
+            })
+          );
+          return resolveResultType(def, argTypes);
+        }
+        node.args.forEach((arg, index) => {
+          const expected = declaredArgType(def, index);
+          if (!typeAccepts(expected, argTypes[index])) {
+            const name = describeNode(arg, fields);
+            issues.push(
+              formulaIssue("type_mismatch", `${name} is not a ${expected}`, {
+                name,
+                expected
+              })
+            );
+          }
+        });
+        return resolveResultType(def, argTypes);
+      }
+      case "bin": {
+        const left = walk(node.l);
+        const right = walk(node.r);
+        const requireNumber = (side, type2) => {
+          if (typeAccepts("number", type2)) return;
+          const name = describeNode(side, fields);
+          issues.push(formulaIssue("type_mismatch", `${name} is not a number`, { name }));
+        };
+        const requireBoolean = (side, type2) => {
+          if (typeAccepts("boolean", type2)) return;
+          const name = describeNode(side, fields);
+          issues.push(
+            formulaIssue("type_mismatch", `${name} is not a true/false value`, {
+              name,
+              expected: "boolean"
+            })
+          );
+        };
+        switch (node.op) {
+          case "+":
+          case "-":
+          case "*":
+          case "/":
+            requireNumber(node.l, left);
+            requireNumber(node.r, right);
+            if (node.op === "/" && node.r.k === "lit" && node.r.v === 0) {
+              issues.push(formulaIssue("divide_by_zero", "Cannot divide by zero"));
+            }
+            return "number";
+          case "&&":
+          case "||":
+            requireBoolean(node.l, left);
+            requireBoolean(node.r, right);
+            return "boolean";
+          case "concat":
+            return "text";
+          case "=":
+          case "!=":
+            return "boolean";
+          case ">":
+          case ">=":
+          case "<":
+          case "<=": {
+            for (const [side, type2] of [
+              [node.l, left],
+              [node.r, right]
+            ]) {
+              if (!ORDERABLE.includes(type2)) {
+                const name = describeNode(side, fields);
+                issues.push(formulaIssue("type_mismatch", `${name} cannot be compared`, { name }));
+              }
+            }
+            if (unifyTypes(left, right) === "unknown" && left !== "unknown" && right !== "unknown") {
+              const name = describeNode(node.r, fields);
+              issues.push(
+                formulaIssue("type_mismatch", `${name} is not a ${left}`, { name, expected: left })
+              );
+            }
+            return "boolean";
+          }
+          default:
+            return "unknown";
+        }
+      }
+      default:
+        return "unknown";
+    }
+  };
+  const type = walk(ast);
+  return issues.length > 0 ? { ok: false, issues } : { ok: true, type };
+}
+function detectFormulaCycles(refs) {
+  const keys = new Set(refs.map((r) => r.key));
+  const edges = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const parsed = parseFormula(ref.expression);
+    const deps = parsed.ok ? collectFieldRefs(parsed.ast).filter((d) => keys.has(d)) : [];
+    edges.set(ref.key, deps);
+  }
+  const cycles = /* @__PURE__ */ new Map();
+  const state = /* @__PURE__ */ new Map();
+  const stack = [];
+  const visit = (key) => {
+    const mark = state.get(key);
+    if (mark === "done") return;
+    if (mark === "visiting") {
+      const from = stack.indexOf(key);
+      const path = [...stack.slice(from), key];
+      for (const member of path) cycles.set(member, path);
+      return;
+    }
+    state.set(key, "visiting");
+    stack.push(key);
+    for (const dep of edges.get(key) ?? []) visit(dep);
+    stack.pop();
+    state.set(key, "done");
+  };
+  for (const ref of refs) visit(ref.key);
+  return cycles;
+}
+function checkFormulaColumn(input) {
+  const { ref, fields } = input;
+  const existing = (input.existing ?? []).filter((r) => r.key !== ref.key);
+  const parsed = parseFormula(ref.expression);
+  if (!parsed.ok) return { ok: false, issues: [parsed.issue] };
+  const cycles = detectFormulaCycles([...existing, ref]);
+  const cycle = cycles.get(ref.key);
+  if (cycle) {
+    const isSelf = cycle.length <= 2;
+    return {
+      ok: false,
+      issues: [
+        formulaIssue(
+          "cycle",
+          isSelf ? "This formula refers to itself" : `Circular reference: ${cycle.join(" \u2192 ")}`,
+          { path: cycle.join(" \u2192 ") }
+        )
+      ]
+    };
+  }
+  const formulaFields = existing.map((r) => ({
+    key: r.key,
+    label: r.label,
+    type: r.resultType
+  }));
+  return mapCheck(checkAst(parsed.ast, { fields: [...fields, ...formulaFields] }), parsed.ast);
+}
+function mapCheck(result, ast) {
+  return result.ok ? { ok: true, ast, type: result.type } : { ok: false, issues: result.issues };
+}
+function fieldMetaFromColumns(columns) {
+  return columns.map((col) => ({
+    key: col.data,
+    label: col.title,
+    type: columnTypeToFormulaType(col.type)
+  }));
+}
+function columnTypeToFormulaType(type) {
+  switch (type) {
+    case "numeric":
+      return "number";
+    case "date":
+      return "date";
+    case "boolean":
+      return "boolean";
+    case "text":
+    case "dropdown":
+    case "multiselect":
+      return "text";
+    default:
+      return "unknown";
+  }
+}
+export {
+  checkAst,
+  checkFormulaColumn,
+  columnTypeToFormulaType,
+  detectFormulaCycles,
+  fieldMetaFromColumns
+};
+//# sourceMappingURL=check.js.map

package/dist/backend/dynamic-table/formula/check.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/formula/check.ts"],
+  "sourcesContent": ["// formula/check.ts\n//\n// Definition-time validation. Everything that can be known without data is\n// decided HERE, when the user saves the formula \u2014 not discovered per cell at\n// render time. That is the whole point: an unknown column reference and a\n// self-referencing formula are refused by the editor, so a saved view can never\n// contain one.\n//\n// What survives to evaluation time is only what genuinely depends on the data:\n// a `type_mismatch` on an undeclared column, and `divide_by_zero`.\n\nimport type {\n  FormulaAst,\n  FormulaColumnRef,\n  FormulaFieldMeta,\n  FormulaIssue,\n  FormulaValueType,\n} from './types';\nimport { formulaIssue } from './types';\nimport { collectFieldRefs, parseFormula } from './parse';\nimport { declaredArgType, lookupFormulaFunction, resolveResultType, unifyTypes } from './functions';\n\n// ============================================\n// TYPE + REFERENCE CHECKING\n// ============================================\n\nexport interface FormulaCheckContext {\n  /** Every column the formula may reference, native or synthesised. */\n  fields: readonly FormulaFieldMeta[];\n}\n\nexport type CheckResult =\n  | { ok: true; type: FormulaValueType }\n  | { ok: false; issues: FormulaIssue[] };\n\n/** Types that can be compared with `<`, `>`, `<=`, `>=`. */\nconst ORDERABLE: FormulaValueType[] = ['number', 'date', 'text', 'unknown'];\n\n/**\n * A human name for a node, used in `{name} is not a number`. A field reference\n * names the column; anything else is described by shape, because quoting the\n * user's own sub-expression back at them is noise.\n */\nfunction describeNode(node: FormulaAst, fields: Map<string, FormulaFieldMeta>): string {\n  switch (node.k) {\n    case 'field':\n      return fields.get(node.name)?.label ?? node.name;\n    case 'call':\n      return `${node.fn}()`;\n    case 'lit':\n      return node.v === null ? 'empty' : JSON.stringify(node.v);\n    default:\n      return 'the expression';\n  }\n}\n\n/** True when `actual` is acceptable where `expected` is declared. */\nfunction typeAccepts(expected: FormulaValueType, actual: FormulaValueType): boolean {\n  if (expected === 'unknown' || actual === 'unknown') return true;\n  return expected === actual;\n}\n\n/**\n * Walk the AST assigning types and collecting every problem \u2014 not just the\n * first, because a user fixing one error at a time is a user who stops using\n * the feature.\n */\nexport function checkAst(ast: FormulaAst, ctx: FormulaCheckContext): CheckResult {\n  const fields = new Map<string, FormulaFieldMeta>(ctx.fields.map((f) => [f.key, f]));\n  const issues: FormulaIssue[] = [];\n\n  const walk = (node: FormulaAst): FormulaValueType => {\n    switch (node.k) {\n      case 'lit': {\n        if (node.v === null) return 'unknown';\n        if (typeof node.v === 'number') return 'number';\n        if (typeof node.v === 'boolean') return 'boolean';\n        return 'text';\n      }\n\n      case 'field': {\n        const meta = fields.get(node.name);\n        if (!meta) {\n          issues.push(\n            formulaIssue('unknown_field', `Unknown column: ${node.name}`, { name: node.name }),\n          );\n          return 'unknown';\n        }\n        return meta.type;\n      }\n\n      case 'neg': {\n        const inner = walk(node.e);\n        if (!typeAccepts('number', inner)) {\n          const name = describeNode(node.e, fields);\n          issues.push(formulaIssue('type_mismatch', `${name} is not a number`, { name }));\n        }\n        return 'number';\n      }\n\n      case 'call': {\n        const def = lookupFormulaFunction(node.fn);\n        if (!def) {\n          issues.push(\n            formulaIssue('unknown_function', `Unknown function: ${node.fn}`, { name: node.fn }),\n          );\n          node.args.forEach(walk);\n          return 'unknown';\n        }\n        const argTypes = node.args.map(walk);\n        if (node.args.length < def.minArgs || node.args.length > def.maxArgs) {\n          issues.push(\n            formulaIssue('arity', `${def.name} takes ${def.signature}`, {\n              name: def.name,\n              signature: def.signature,\n            }),\n          );\n          return resolveResultType(def, argTypes);\n        }\n        node.args.forEach((arg, index) => {\n          const expected = declaredArgType(def, index);\n          if (!typeAccepts(expected, argTypes[index])) {\n            const name = describeNode(arg, fields);\n            issues.push(\n              formulaIssue('type_mismatch', `${name} is not a ${expected}`, {\n                name,\n                expected,\n              }),\n            );\n          }\n        });\n        return resolveResultType(def, argTypes);\n      }\n\n      case 'bin': {\n        const left = walk(node.l);\n        const right = walk(node.r);\n\n        const requireNumber = (side: FormulaAst, type: FormulaValueType) => {\n          if (typeAccepts('number', type)) return;\n          const name = describeNode(side, fields);\n          issues.push(formulaIssue('type_mismatch', `${name} is not a number`, { name }));\n        };\n        const requireBoolean = (side: FormulaAst, type: FormulaValueType) => {\n          if (typeAccepts('boolean', type)) return;\n          const name = describeNode(side, fields);\n          issues.push(\n            formulaIssue('type_mismatch', `${name} is not a true/false value`, {\n              name,\n              expected: 'boolean',\n            }),\n          );\n        };\n\n        switch (node.op) {\n          case '+':\n          case '-':\n          case '*':\n          case '/':\n            requireNumber(node.l, left);\n            requireNumber(node.r, right);\n            // A literal zero divisor is provable now, so prove it now.\n            if (node.op === '/' && node.r.k === 'lit' && node.r.v === 0) {\n              issues.push(formulaIssue('divide_by_zero', 'Cannot divide by zero'));\n            }\n            return 'number';\n\n          case '&&':\n          case '||':\n            requireBoolean(node.l, left);\n            requireBoolean(node.r, right);\n            return 'boolean';\n\n          case 'concat':\n            return 'text';\n\n          case '=':\n          case '!=':\n            return 'boolean';\n\n          case '>':\n          case '>=':\n          case '<':\n          case '<=': {\n            for (const [side, type] of [\n              [node.l, left],\n              [node.r, right],\n            ] as [FormulaAst, FormulaValueType][]) {\n              if (!ORDERABLE.includes(type)) {\n                const name = describeNode(side, fields);\n                issues.push(formulaIssue('type_mismatch', `${name} cannot be compared`, { name }));\n              }\n            }\n            if (unifyTypes(left, right) === 'unknown' && left !== 'unknown' && right !== 'unknown') {\n              const name = describeNode(node.r, fields);\n              issues.push(\n                formulaIssue('type_mismatch', `${name} is not a ${left}`, { name, expected: left }),\n              );\n            }\n            return 'boolean';\n          }\n\n          default:\n            return 'unknown';\n        }\n      }\n\n      default:\n        return 'unknown';\n    }\n  };\n\n  const type = walk(ast);\n  return issues.length > 0 ? { ok: false, issues } : { ok: true, type };\n}\n\n// ============================================\n// CYCLE DETECTION\n// ============================================\n\n/**\n * Cycles among formula columns, keyed by the formula key that participates.\n * Same-row references (A3) keep the graph tiny \u2014 one node per formula column \u2014\n * so this is exhaustive rather than heuristic, and it runs at DEFINITION time.\n *\n * A formula that fails to parse contributes no edges; its syntax error is\n * reported separately and it cannot be saved anyway.\n */\nexport function detectFormulaCycles(refs: readonly FormulaColumnRef[]): Map<string, string[]> {\n  const keys = new Set(refs.map((r) => r.key));\n  const edges = new Map<string, string[]>();\n\n  for (const ref of refs) {\n    const parsed = parseFormula(ref.expression);\n    const deps = parsed.ok ? collectFieldRefs(parsed.ast).filter((d) => keys.has(d)) : [];\n    edges.set(ref.key, deps);\n  }\n\n  const cycles = new Map<string, string[]>();\n  const state = new Map<string, 'visiting' | 'done'>();\n  const stack: string[] = [];\n\n  const visit = (key: string): void => {\n    const mark = state.get(key);\n    if (mark === 'done') return;\n    if (mark === 'visiting') {\n      // Found a back-edge: everything from `key` to the top of the stack is the\n      // cycle, and every member of it is refused.\n      const from = stack.indexOf(key);\n      const path = [...stack.slice(from), key];\n      for (const member of path) cycles.set(member, path);\n      return;\n    }\n    state.set(key, 'visiting');\n    stack.push(key);\n    for (const dep of edges.get(key) ?? []) visit(dep);\n    stack.pop();\n    state.set(key, 'done');\n  };\n\n  for (const ref of refs) visit(ref.key);\n  return cycles;\n}\n\n// ============================================\n// THE EDITOR'S ENTRY POINT\n// ============================================\n\nexport interface CheckFormulaColumnInput {\n  /** The definition being saved (new or edited). */\n  ref: FormulaColumnRef;\n  /** Native + lookup columns the formula may reference. */\n  fields: readonly FormulaFieldMeta[];\n  /**\n   * Every other formula column already on the view. The one being edited is\n   * matched by key and replaced, so re-saving an existing formula is not\n   * mistaken for a cycle with its own previous version.\n   */\n  existing?: readonly FormulaColumnRef[];\n}\n\nexport type CheckFormulaColumnResult =\n  | { ok: true; ast: FormulaAst; type: FormulaValueType }\n  | { ok: false; issues: FormulaIssue[] };\n\n/**\n * Validate one formula definition end to end: syntax \u2192 cycles \u2192 references and\n * types. Returns EVERY issue so the editor can list them.\n */\nexport function checkFormulaColumn(input: CheckFormulaColumnInput): CheckFormulaColumnResult {\n  const { ref, fields } = input;\n  const existing = (input.existing ?? []).filter((r) => r.key !== ref.key);\n\n  const parsed = parseFormula(ref.expression);\n  if (!parsed.ok) return { ok: false, issues: [parsed.issue] };\n\n  // Cycles first: a self-reference makes the type check meaningless.\n  const cycles = detectFormulaCycles([...existing, ref]);\n  const cycle = cycles.get(ref.key);\n  if (cycle) {\n    const isSelf = cycle.length <= 2;\n    return {\n      ok: false,\n      issues: [\n        formulaIssue(\n          'cycle',\n          isSelf ? 'This formula refers to itself' : `Circular reference: ${cycle.join(' \u2192 ')}`,\n          { path: cycle.join(' \u2192 ') },\n        ),\n      ],\n    };\n  }\n\n  // Other formula columns are referenceable, typed by their declared result.\n  const formulaFields: FormulaFieldMeta[] = existing.map((r) => ({\n    key: r.key,\n    label: r.label,\n    type: r.resultType,\n  }));\n\n  return mapCheck(checkAst(parsed.ast, { fields: [...fields, ...formulaFields] }), parsed.ast);\n}\n\nfunction mapCheck(result: CheckResult, ast: FormulaAst): CheckFormulaColumnResult {\n  return result.ok ? { ok: true, ast, type: result.type } : { ok: false, issues: result.issues };\n}\n\n/**\n * Column metadata in the shape the checker wants, derived from `ColumnDef`s.\n * `ColumnDef.type` is the grid's vocabulary (`numeric`, `dropdown`, \u2026); this is\n * the single place that translation lives.\n */\nexport function fieldMetaFromColumns(\n  columns: readonly { data: string; title?: string; type?: string }[],\n): FormulaFieldMeta[] {\n  return columns.map((col) => ({\n    key: col.data,\n    label: col.title,\n    type: columnTypeToFormulaType(col.type),\n  }));\n}\n\n/** `ColumnDef.type` \u2192 checker type. Undeclared columns are `unknown`. */\nexport function columnTypeToFormulaType(type: string | undefined): FormulaValueType {\n  switch (type) {\n    case 'numeric':\n      return 'number';\n    case 'date':\n      return 'date';\n    case 'boolean':\n      return 'boolean';\n    case 'text':\n    case 'dropdown':\n    case 'multiselect':\n      return 'text';\n    default:\n      return 'unknown';\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["type"]
+}

package/dist/backend/dynamic-table/formula/evaluate.js

@@ -0,0 +1,302 @@
+import { collectFieldRefs, parseFormula } from "./parse.js";
+import {
+  EMPTY,
+  fail,
+  lookupFormulaFunction,
+  ok,
+  toBoolean,
+  toDate,
+  toNumber,
+  toText
+} from "./functions.js";
+import { checkFormulaColumn } from "./check.js";
+function normalise(raw) {
+  if (raw === null || raw === void 0) return null;
+  if (raw instanceof Date) return raw;
+  const type = typeof raw;
+  if (type === "number" || type === "string" || type === "boolean") return raw;
+  return null;
+}
+function evaluateAst(ast, row, options = {}) {
+  const nowFn = options.now ?? (() => /* @__PURE__ */ new Date());
+  const fields = options.fields;
+  const computed = options.computed;
+  const runtime = {
+    evaluateNode: (node) => walk(node),
+    now: nowFn
+  };
+  const nameOf = (node) => {
+    if (node.k === "field") return fields?.get(node.name)?.label ?? node.name;
+    if (node.k === "call") return `${node.fn}()`;
+    return "value";
+  };
+  function walk(node) {
+    switch (node.k) {
+      case "lit":
+        return ok(node.v);
+      case "field": {
+        const upstream = computed?.get(node.name);
+        if (upstream) {
+          if (upstream.state === "error") return { ok: false, issue: upstream.issue };
+          return ok(upstream.value);
+        }
+        return ok(normalise(row[node.name]));
+      }
+      case "neg": {
+        const inner = walk(node.e);
+        if (!inner.ok) return inner;
+        const n = toNumber(inner.value, nameOf(node.e));
+        if (!n.ok || n.value === null) return n;
+        return ok(-n.value);
+      }
+      case "call": {
+        const def = lookupFormulaFunction(node.fn);
+        if (!def) {
+          return fail("unknown_function", `Unknown function: ${node.fn}`, { name: node.fn });
+        }
+        if (node.args.length < def.minArgs || node.args.length > def.maxArgs) {
+          return fail("arity", `${def.name} takes ${def.signature}`, {
+            name: def.name,
+            signature: def.signature
+          });
+        }
+        if (def.lazy && def.callLazy) return def.callLazy(node.args, runtime);
+        const values = [];
+        for (const arg of node.args) {
+          const result = walk(arg);
+          if (!result.ok) return result;
+          if (result.value === null && def.nullPolicy !== "accept") return EMPTY;
+          values.push(result.value);
+        }
+        if (!def.call) return EMPTY;
+        return def.call(values, runtime);
+      }
+      case "bin":
+        return walkBinary(node);
+      default:
+        return EMPTY;
+    }
+  }
+  function walkBinary(node) {
+    const { op } = node;
+    if (op === "&&" || op === "||") {
+      const left2 = walk(node.l);
+      if (!left2.ok) return left2;
+      const lb = toBoolean(left2.value, nameOf(node.l));
+      if (!lb.ok) return lb;
+      if (lb.value === null) return EMPTY;
+      if (op === "&&" && lb.value === false) return ok(false);
+      if (op === "||" && lb.value === true) return ok(true);
+      const right2 = walk(node.r);
+      if (!right2.ok) return right2;
+      const rb = toBoolean(right2.value, nameOf(node.r));
+      if (!rb.ok || rb.value === null) return rb;
+      return ok(rb.value);
+    }
+    const left = walk(node.l);
+    if (!left.ok) return left;
+    const right = walk(node.r);
+    if (!right.ok) return right;
+    if (op === "concat") {
+      const l2 = toText(left.value);
+      if (!l2.ok) return l2;
+      const r2 = toText(right.value);
+      if (!r2.ok) return r2;
+      const ls = l2.value === null ? "" : l2.value;
+      const rs = r2.value === null ? "" : r2.value;
+      if (left.value === null && right.value === null) return EMPTY;
+      return ok(ls + rs);
+    }
+    if (op === "=" || op === "!=") {
+      const equal = looseEquals(left.value, right.value);
+      return ok(op === "=" ? equal : !equal);
+    }
+    if (op === ">" || op === ">=" || op === "<" || op === "<=") {
+      if (left.value === null || right.value === null) return EMPTY;
+      const cmp = compare(left.value, right.value, nameOf(node.r));
+      if (!cmp.ok) return cmp;
+      const c = cmp.value;
+      switch (op) {
+        case ">":
+          return ok(c > 0);
+        case ">=":
+          return ok(c >= 0);
+        case "<":
+          return ok(c < 0);
+        default:
+          return ok(c <= 0);
+      }
+    }
+    const l = toNumber(left.value, nameOf(node.l));
+    if (!l.ok) return l;
+    const r = toNumber(right.value, nameOf(node.r));
+    if (!r.ok) return r;
+    if (l.value === null || r.value === null) return EMPTY;
+    const a = l.value;
+    const b = r.value;
+    switch (op) {
+      case "+":
+        return ok(a + b);
+      case "-":
+        return ok(a - b);
+      case "*":
+        return ok(a * b);
+      case "/":
+        if (b === 0) return fail("divide_by_zero", "Cannot divide by zero");
+        return ok(a / b);
+      default:
+        return EMPTY;
+    }
+  }
+  function looseEquals(a, b) {
+    if (a === null || b === null) return a === b;
+    if (a instanceof Date || b instanceof Date) {
+      const da = toDate(a);
+      const db = toDate(b);
+      if (!da.ok || !db.ok || da.value === null || db.value === null) return false;
+      return da.value.getTime() === db.value.getTime();
+    }
+    if (typeof a === "number" || typeof b === "number") {
+      const na = toNumber(a);
+      const nb = toNumber(b);
+      if (na.ok && nb.ok && na.value !== null && nb.value !== null) return na.value === nb.value;
+      return false;
+    }
+    return a === b;
+  }
+  function compare(a, b, rightName) {
+    if (a instanceof Date || b instanceof Date) {
+      const da = toDate(a, rightName);
+      if (!da.ok) return da;
+      const db = toDate(b, rightName);
+      if (!db.ok) return db;
+      if (da.value === null || db.value === null) return EMPTY;
+      return ok(Math.sign(da.value.getTime() - db.value.getTime()));
+    }
+    if (typeof a === "string" && typeof b === "string") {
+      const na2 = Number(a.trim());
+      const nb2 = Number(b.trim());
+      if (a.trim() && b.trim() && !Number.isNaN(na2) && !Number.isNaN(nb2)) {
+        return ok(Math.sign(na2 - nb2));
+      }
+      return ok(Math.sign(a.localeCompare(b)));
+    }
+    const na = toNumber(a, rightName);
+    if (!na.ok) return na;
+    const nb = toNumber(b, rightName);
+    if (!nb.ok) return nb;
+    if (na.value === null || nb.value === null) return EMPTY;
+    return ok(Math.sign(na.value - nb.value));
+  }
+  return walk(ast);
+}
+function coerceToResultType(outcome, resultType, label) {
+  if (!outcome.ok) return { state: "error", value: null, issue: outcome.issue };
+  if (outcome.value === null) return { state: "empty", value: null };
+  let coerced;
+  switch (resultType) {
+    case "number":
+      coerced = toNumber(outcome.value, label);
+      break;
+    case "text":
+      coerced = toText(outcome.value);
+      break;
+    case "boolean":
+      coerced = toBoolean(outcome.value, label);
+      break;
+    default:
+      coerced = toDate(outcome.value, label);
+  }
+  if (!coerced.ok) return { state: "error", value: null, issue: coerced.issue };
+  if (coerced.value === null) return { state: "empty", value: null };
+  return { state: "ok", value: coerced.value };
+}
+function compileFormulaColumns(refs, fields) {
+  const fieldMap = new Map(fields.map((f) => [f.key, f]));
+  const invalid = /* @__PURE__ */ new Map();
+  const compiled = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const checked = checkFormulaColumn({ ref, fields, existing: refs });
+    if (!checked.ok) {
+      invalid.set(ref.key, checked.issues[0]);
+      continue;
+    }
+    compiled.set(ref.key, { ref, ast: checked.ast, deps: collectFieldRefs(checked.ast) });
+  }
+  const order = [];
+  const placed = /* @__PURE__ */ new Set();
+  const place = (key, seen) => {
+    if (placed.has(key) || seen.has(key)) return;
+    const entry = compiled.get(key);
+    if (!entry) return;
+    seen.add(key);
+    for (const dep of entry.deps) {
+      if (compiled.has(dep)) place(dep, seen);
+    }
+    seen.delete(key);
+    placed.add(key);
+    order.push(entry);
+  };
+  for (const ref of refs) place(ref.key, /* @__PURE__ */ new Set());
+  const inputKeys = /* @__PURE__ */ new Set();
+  for (const entry of order) {
+    for (const dep of entry.deps) {
+      if (!compiled.has(dep)) inputKeys.add(dep);
+    }
+  }
+  return { order, invalid, fields: fieldMap, inputKeys: [...inputKeys] };
+}
+function evaluateFormulaRow(set, row, options = {}) {
+  const computed = /* @__PURE__ */ new Map();
+  for (const [key, issue] of set.invalid) {
+    computed.set(key, { state: "error", value: null, issue });
+  }
+  for (const entry of set.order) {
+    const outcome = evaluateAst(entry.ast, row, {
+      fields: set.fields,
+      now: options.now,
+      computed
+    });
+    computed.set(
+      entry.ref.key,
+      coerceToResultType(outcome, entry.ref.resultType, entry.ref.label)
+    );
+  }
+  return computed;
+}
+function createFormulaRowEvaluator(set, options = {}) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  const signatureOf = (row) => set.inputKeys.map((key) => {
+    const value = row[key];
+    if (value === null || value === void 0) return "\0";
+    if (value instanceof Date) return String(value.getTime());
+    return String(value);
+  }).join("
");
+  return (row) => {
+    if (!row || typeof row !== "object") return /* @__PURE__ */ new Map();
+    const signature = signatureOf(row);
+    const hit = cache.get(row);
+    if (hit && hit.signature === signature) return hit.results;
+    const results = evaluateFormulaRow(set, row, options);
+    cache.set(row, { signature, results });
+    return results;
+  };
+}
+function evaluateExpression(expression, row, fields, resultType = "number", options = {}) {
+  const parsed = parseFormula(expression);
+  if (!parsed.ok) return { state: "error", value: null, issue: parsed.issue };
+  const outcome = evaluateAst(parsed.ast, row, {
+    fields: new Map(fields.map((f) => [f.key, f])),
+    now: options.now
+  });
+  return coerceToResultType(outcome, resultType, expression);
+}
+export {
+  coerceToResultType,
+  compileFormulaColumns,
+  createFormulaRowEvaluator,
+  evaluateAst,
+  evaluateExpression,
+  evaluateFormulaRow
+};
+//# sourceMappingURL=evaluate.js.map

package/dist/backend/dynamic-table/formula/evaluate.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/formula/evaluate.ts"],
+  "sourcesContent": ["// formula/evaluate.ts\n//\n// The AST walker. It is a plain recursive function over five node kinds.\n//\n// There is no `eval`, no `new Function`, no template interpolation into SQL and\n// no dynamic property access into host objects \u2014 a formula can read the row it\n// is handed and nothing else. That is enforced structurally (the language has\n// no syntax for anything else) and asserted mechanically by\n// `__tests__/formula.noEval.test.ts`.\n//\n// Null propagates: an arithmetic operand that is empty makes the whole result\n// empty. It never becomes `0` and it never becomes `NaN`.\n\nimport type {\n  FormulaAst,\n  FormulaCellResult,\n  FormulaColumnRef,\n  FormulaFieldMeta,\n  FormulaIssue,\n  FormulaResultType,\n  FormulaValue,\n} from './types';\nimport { collectFieldRefs, parseFormula } from './parse';\nimport {\n  EMPTY,\n  fail,\n  lookupFormulaFunction,\n  ok,\n  toBoolean,\n  toDate,\n  toNumber,\n  toText,\n  type EvalOutcome,\n  type FormulaRuntime,\n} from './functions';\nimport { checkFormulaColumn } from './check';\n\nexport interface EvaluateOptions {\n  /** Column metadata, used to name a column in a `type_mismatch` message. */\n  fields?: ReadonlyMap<string, FormulaFieldMeta>;\n  /** Injectable clock so `TODAY()` is deterministic under test. */\n  now?: () => Date;\n  /**\n   * Results of formula columns already evaluated for this row. A field\n   * reference resolves here first, which is how one formula reads another.\n   */\n  computed?: ReadonlyMap<string, FormulaCellResult>;\n}\n\n// ============================================\n// CORE WALKER\n// ============================================\n\n/** Normalise a raw row value into the evaluator's value domain. */\nfunction normalise(raw: unknown): FormulaValue {\n  if (raw === null || raw === undefined) return null;\n  if (raw instanceof Date) return raw;\n  const type = typeof raw;\n  if (type === 'number' || type === 'string' || type === 'boolean') return raw as FormulaValue;\n  // Objects and arrays have no meaning in a same-row language; treating them as\n  // empty is safer than stringifying `[object Object]` into a total.\n  return null;\n}\n\n/**\n * Evaluate one AST against one row. Never throws \u2014 every failure is an\n * `EvalOutcome` carrying the issue that will be shown in that cell.\n */\nexport function evaluateAst(\n  ast: FormulaAst,\n  row: Record<string, unknown>,\n  options: EvaluateOptions = {},\n): EvalOutcome {\n  const nowFn = options.now ?? (() => new Date());\n  const fields = options.fields;\n  const computed = options.computed;\n\n  const runtime: FormulaRuntime = {\n    evaluateNode: (node) => walk(node),\n    now: nowFn,\n  };\n\n  const nameOf = (node: FormulaAst): string => {\n    if (node.k === 'field') return fields?.get(node.name)?.label ?? node.name;\n    if (node.k === 'call') return `${node.fn}()`;\n    return 'value';\n  };\n\n  function walk(node: FormulaAst): EvalOutcome {\n    switch (node.k) {\n      case 'lit':\n        return ok(node.v);\n\n      case 'field': {\n        const upstream = computed?.get(node.name);\n        if (upstream) {\n          // A formula reading another formula inherits its error rather than\n          // inventing a fresh one \u2014 the user needs to fix the upstream cell.\n          if (upstream.state === 'error') return { ok: false, issue: upstream.issue };\n          return ok(upstream.value);\n        }\n        return ok(normalise(row[node.name]));\n      }\n\n      case 'neg': {\n        const inner = walk(node.e);\n        if (!inner.ok) return inner;\n        const n = toNumber(inner.value, nameOf(node.e));\n        if (!n.ok || n.value === null) return n;\n        return ok(-(n.value as number));\n      }\n\n      case 'call': {\n        const def = lookupFormulaFunction(node.fn);\n        if (!def) {\n          return fail('unknown_function', `Unknown function: ${node.fn}`, { name: node.fn });\n        }\n        if (node.args.length < def.minArgs || node.args.length > def.maxArgs) {\n          return fail('arity', `${def.name} takes ${def.signature}`, {\n            name: def.name,\n            signature: def.signature,\n          });\n        }\n        if (def.lazy && def.callLazy) return def.callLazy(node.args, runtime);\n\n        const values: FormulaValue[] = [];\n        for (const arg of node.args) {\n          const result = walk(arg);\n          if (!result.ok) return result;\n          if (result.value === null && def.nullPolicy !== 'accept') return EMPTY;\n          values.push(result.value);\n        }\n        if (!def.call) return EMPTY;\n        return def.call(values, runtime);\n      }\n\n      case 'bin':\n        return walkBinary(node);\n\n      default:\n        return EMPTY;\n    }\n  }\n\n  function walkBinary(node: Extract<FormulaAst, { k: 'bin' }>): EvalOutcome {\n    const { op } = node;\n\n    // `&&` / `||` short-circuit, so the right operand is not evaluated at all\n    // when the left decides the answer.\n    if (op === '&&' || op === '||') {\n      const left = walk(node.l);\n      if (!left.ok) return left;\n      const lb = toBoolean(left.value, nameOf(node.l));\n      if (!lb.ok) return lb;\n      if (lb.value === null) return EMPTY;\n      if (op === '&&' && lb.value === false) return ok(false);\n      if (op === '||' && lb.value === true) return ok(true);\n      const right = walk(node.r);\n      if (!right.ok) return right;\n      const rb = toBoolean(right.value, nameOf(node.r));\n      if (!rb.ok || rb.value === null) return rb;\n      return ok(rb.value);\n    }\n\n    const left = walk(node.l);\n    if (!left.ok) return left;\n    const right = walk(node.r);\n    if (!right.ok) return right;\n\n    if (op === 'concat') {\n      const l = toText(left.value);\n      if (!l.ok) return l;\n      const r = toText(right.value);\n      if (!r.ok) return r;\n      // Concatenation treats empty as the empty string; `'A' & null` is `'A'`,\n      // not empty \u2014 otherwise every optional suffix would blank the column.\n      const ls = l.value === null ? '' : (l.value as string);\n      const rs = r.value === null ? '' : (r.value as string);\n      if (left.value === null && right.value === null) return EMPTY;\n      return ok(ls + rs);\n    }\n\n    if (op === '=' || op === '!=') {\n      const equal = looseEquals(left.value, right.value);\n      return ok(op === '=' ? equal : !equal);\n    }\n\n    if (op === '>' || op === '>=' || op === '<' || op === '<=') {\n      if (left.value === null || right.value === null) return EMPTY;\n      const cmp = compare(left.value, right.value, nameOf(node.r));\n      if (!cmp.ok) return cmp;\n      const c = cmp.value as number;\n      switch (op) {\n        case '>':\n          return ok(c > 0);\n        case '>=':\n          return ok(c >= 0);\n        case '<':\n          return ok(c < 0);\n        default:\n          return ok(c <= 0);\n      }\n    }\n\n    // Arithmetic.\n    const l = toNumber(left.value, nameOf(node.l));\n    if (!l.ok) return l;\n    const r = toNumber(right.value, nameOf(node.r));\n    if (!r.ok) return r;\n    if (l.value === null || r.value === null) return EMPTY;\n\n    const a = l.value as number;\n    const b = r.value as number;\n    switch (op) {\n      case '+':\n        return ok(a + b);\n      case '-':\n        return ok(a - b);\n      case '*':\n        return ok(a * b);\n      case '/':\n        if (b === 0) return fail('divide_by_zero', 'Cannot divide by zero');\n        return ok(a / b);\n      default:\n        return EMPTY;\n    }\n  }\n\n  /**\n   * Equality across the value domain. Two empties are equal (as in Excel, where\n   * blank equals blank); a date equals a date with the same instant; numbers\n   * and numeric strings compare as numbers so `'10' = 10` is true.\n   */\n  function looseEquals(a: FormulaValue, b: FormulaValue): boolean {\n    if (a === null || b === null) return a === b;\n    if (a instanceof Date || b instanceof Date) {\n      const da = toDate(a);\n      const db = toDate(b);\n      if (!da.ok || !db.ok || da.value === null || db.value === null) return false;\n      return (da.value as Date).getTime() === (db.value as Date).getTime();\n    }\n    if (typeof a === 'number' || typeof b === 'number') {\n      const na = toNumber(a);\n      const nb = toNumber(b);\n      if (na.ok && nb.ok && na.value !== null && nb.value !== null) return na.value === nb.value;\n      return false;\n    }\n    return a === b;\n  }\n\n  /** Three-way comparison for ordering operators. */\n  function compare(a: FormulaValue, b: FormulaValue, rightName: string): EvalOutcome {\n    if (a instanceof Date || b instanceof Date) {\n      const da = toDate(a, rightName);\n      if (!da.ok) return da;\n      const db = toDate(b, rightName);\n      if (!db.ok) return db;\n      if (da.value === null || db.value === null) return EMPTY;\n      return ok(Math.sign((da.value as Date).getTime() - (db.value as Date).getTime()));\n    }\n    if (typeof a === 'string' && typeof b === 'string') {\n      const na = Number(a.trim());\n      const nb = Number(b.trim());\n      if (a.trim() && b.trim() && !Number.isNaN(na) && !Number.isNaN(nb)) {\n        return ok(Math.sign(na - nb));\n      }\n      return ok(Math.sign(a.localeCompare(b)));\n    }\n    const na = toNumber(a, rightName);\n    if (!na.ok) return na;\n    const nb = toNumber(b, rightName);\n    if (!nb.ok) return nb;\n    if (na.value === null || nb.value === null) return EMPTY;\n    return ok(Math.sign((na.value as number) - (nb.value as number)));\n  }\n\n  return walk(ast);\n}\n\n// ============================================\n// RESULT SHAPING\n// ============================================\n\n/** Coerce an evaluated value into the column's declared result type. */\nexport function coerceToResultType(\n  outcome: EvalOutcome,\n  resultType: FormulaResultType,\n  label: string,\n): FormulaCellResult {\n  if (!outcome.ok) return { state: 'error', value: null, issue: outcome.issue };\n  if (outcome.value === null) return { state: 'empty', value: null };\n\n  let coerced: EvalOutcome;\n  switch (resultType) {\n    case 'number':\n      coerced = toNumber(outcome.value, label);\n      break;\n    case 'text':\n      coerced = toText(outcome.value);\n      break;\n    case 'boolean':\n      coerced = toBoolean(outcome.value, label);\n      break;\n    default:\n      coerced = toDate(outcome.value, label);\n  }\n\n  if (!coerced.ok) return { state: 'error', value: null, issue: coerced.issue };\n  if (coerced.value === null) return { state: 'empty', value: null };\n  return { state: 'ok', value: coerced.value };\n}\n\n// ============================================\n// COLUMN SETS\n// ============================================\n\nexport interface CompiledFormula {\n  ref: FormulaColumnRef;\n  ast: FormulaAst;\n  /** Every field key the expression reads, formula keys included. */\n  deps: string[];\n}\n\nexport interface CompiledFormulaSet {\n  /** Valid formulas in dependency order \u2014 an upstream formula evaluates first. */\n  order: CompiledFormula[];\n  /** Definition-time failures, keyed by formula column key. */\n  invalid: Map<string, FormulaIssue>;\n  fields: Map<string, FormulaFieldMeta>;\n  /**\n   * Union of every NON-formula field the set reads. The evaluator's cache\n   * signature is built from exactly these, so a cache entry is invalidated when\n   * an input changes and by nothing else.\n   */\n  inputKeys: string[];\n}\n\n/**\n * Validate and order a view's formula columns once, so per-row evaluation is a\n * walk and nothing more. Definition failures (syntax, unknown field, cycle) are\n * captured per key: one broken formula shows an error in its own column and\n * leaves every other column working.\n */\nexport function compileFormulaColumns(\n  refs: readonly FormulaColumnRef[],\n  fields: readonly FormulaFieldMeta[],\n): CompiledFormulaSet {\n  const fieldMap = new Map<string, FormulaFieldMeta>(fields.map((f) => [f.key, f]));\n  const invalid = new Map<string, FormulaIssue>();\n  const compiled = new Map<string, CompiledFormula>();\n\n  for (const ref of refs) {\n    const checked = checkFormulaColumn({ ref, fields, existing: refs });\n    if (!checked.ok) {\n      invalid.set(ref.key, checked.issues[0]);\n      continue;\n    }\n    compiled.set(ref.key, { ref, ast: checked.ast, deps: collectFieldRefs(checked.ast) });\n  }\n\n  // Dependency order. Cycles are already refused above, so this terminates.\n  const order: CompiledFormula[] = [];\n  const placed = new Set<string>();\n  const place = (key: string, seen: Set<string>): void => {\n    if (placed.has(key) || seen.has(key)) return;\n    const entry = compiled.get(key);\n    if (!entry) return;\n    seen.add(key);\n    for (const dep of entry.deps) {\n      if (compiled.has(dep)) place(dep, seen);\n    }\n    seen.delete(key);\n    placed.add(key);\n    order.push(entry);\n  };\n  for (const ref of refs) place(ref.key, new Set());\n\n  const inputKeys = new Set<string>();\n  for (const entry of order) {\n    for (const dep of entry.deps) {\n      if (!compiled.has(dep)) inputKeys.add(dep);\n    }\n  }\n\n  return { order, invalid, fields: fieldMap, inputKeys: [...inputKeys] };\n}\n\n/**\n * Evaluate every formula column for one row, in dependency order.\n * Returns a result for EVERY declared key \u2014 including the invalid ones, whose\n * definition error is what that cell shows.\n */\nexport function evaluateFormulaRow(\n  set: CompiledFormulaSet,\n  row: Record<string, unknown>,\n  options: { now?: () => Date } = {},\n): Map<string, FormulaCellResult> {\n  const computed = new Map<string, FormulaCellResult>();\n\n  for (const [key, issue] of set.invalid) {\n    computed.set(key, { state: 'error', value: null, issue });\n  }\n\n  for (const entry of set.order) {\n    const outcome = evaluateAst(entry.ast, row, {\n      fields: set.fields,\n      now: options.now,\n      computed,\n    });\n    computed.set(\n      entry.ref.key,\n      coerceToResultType(outcome, entry.ref.resultType, entry.ref.label),\n    );\n  }\n\n  return computed;\n}\n\n/**\n * A row evaluator that computes each row at most once per change to its inputs.\n *\n * The cache is keyed on the row object AND a signature over just the fields the\n * formulas read. Object identity alone is not enough: the cell store mutates\n * `rowData` in place on an inline edit, so an identity-only cache would serve a\n * stale margin after the user changed the cost. The signature is over two or\n * three values, so it is far cheaper than re-walking the ASTs.\n */\nexport function createFormulaRowEvaluator(\n  set: CompiledFormulaSet,\n  options: { now?: () => Date } = {},\n): (row: Record<string, unknown>) => Map<string, FormulaCellResult> {\n  const cache = new WeakMap<object, { signature: string; results: Map<string, FormulaCellResult> }>();\n\n  const signatureOf = (row: Record<string, unknown>): string =>\n    set.inputKeys\n      .map((key) => {\n        const value = row[key];\n        if (value === null || value === undefined) return '\u0000';\n        if (value instanceof Date) return String(value.getTime());\n        return String(value);\n      })\n      .join('\u0001');\n\n  return (row) => {\n    if (!row || typeof row !== 'object') return new Map();\n    const signature = signatureOf(row);\n    const hit = cache.get(row);\n    if (hit && hit.signature === signature) return hit.results;\n    const results = evaluateFormulaRow(set, row, options);\n    cache.set(row, { signature, results });\n    return results;\n  };\n}\n\n/**\n * One-shot convenience: parse, check and evaluate a single expression against a\n * row. Used by the editor's live preview, where there is no compiled set yet.\n */\nexport function evaluateExpression(\n  expression: string,\n  row: Record<string, unknown>,\n  fields: readonly FormulaFieldMeta[],\n  resultType: FormulaResultType = 'number',\n  options: { now?: () => Date } = {},\n): FormulaCellResult {\n  const parsed = parseFormula(expression);\n  if (!parsed.ok) return { state: 'error', value: null, issue: parsed.issue };\n  const outcome = evaluateAst(parsed.ast, row, {\n    fields: new Map(fields.map((f) => [f.key, f])),\n    now: options.now,\n  });\n  return coerceToResultType(outcome, resultType, expression);\n}\n"],
+  "mappings": "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",
+  "names": ["left", "right", "l", "r", "na", "nb"]
+}