@ai-matrx/records 0.82.1 → 0.83.0

package/dist/templates/index.cjs

@@ -30,7 +30,7 @@ __export(templates_exports, {
   DEFAULT_TEMPLATE_AGENT: () => DEFAULT_TEMPLATE_AGENT,
   DESIGNATED_REAL_NUMBERS: () => DESIGNATED_REAL_NUMBERS,
   ENTITY_REFERENCE_KINDS: () => ENTITY_REFERENCE_KINDS,
-  FORMULA_FUNCTIONS: () => FORMULA_FUNCTIONS,
+  FORMULA_FUNCTION_NAMES: () => FORMULA_FUNCTION_NAMES,
   GALLERY_ONLY: () => GALLERY_ONLY,
   GOOD_OUTCOME: () => GOOD_OUTCOME,
   INDUSTRY_GROUPS: () => INDUSTRY_GROUPS,
@@ -113,7 +113,7 @@ __export(templates_exports, {
   numberedStreet: () => numberedStreet,
   packageDescribeResult: () => packageDescribeResult,
   parseAt: () => parseAt,
-  parseFormula: () => parseFormula,
+  parseGateFormula: () => parseGateFormula,
   parseNumeric: () => parseNumeric,
   pathOfAt: () => pathOfAt,
   peopleOf: () => peopleOf,
@@ -492,6 +492,7 @@ var CATALOGUE_STATUSES = ["planned", "authoring", "checking", "waiting_on_lane_1
 
 // src/templates/validate.ts
 var import_uuid = require("@ai-matrx/kit/uuid");
+var import_formula = require("@ai-matrx/kit/formula");
 
 // src/templates/confidential.ts
 var TABLE_KERNEL_ID = "11111111-0000-4000-8000-000000000001";
@@ -2903,134 +2904,28 @@ function storeFilterMatches(row, filter, _timeZone) {
     return have === String(want);
   });
 }
-var FORMULA_FUNCTIONS = /* @__PURE__ */ new Set([
-  "ABS",
-  "AND",
-  "ARRAYCOMPACT",
-  "ARRAYJOIN",
-  "AVERAGE",
-  "BLANK",
-  "CONCATENATE",
-  "CONTAINS",
-  "DATEADD",
-  "DATEDIFF",
-  "DATETIME_FORMAT",
-  "DAY",
-  "FIND",
-  "IF",
-  "ISBLANK",
-  "LEFT",
-  "LEN",
-  "LOWER",
-  "MAX",
-  "MIN",
-  "MONTH",
-  "NOT",
-  "OR",
-  "REGEX_MATCH",
-  "RIGHT",
-  "ROUND",
-  "SUBSTITUTE",
-  "SUM",
-  "SWITCH",
-  "TODAY",
-  "NOW",
-  "TRIM",
-  "UPPER",
-  "WORKDAY",
-  "YEAR"
-]);
-function fxTokens(text) {
-  const out = [];
-  let i = 0;
-  while (i < text.length) {
-    const c = text[i];
-    if (/\s/.test(c)) i += 1;
-    else if (c === "{") {
-      const j = text.indexOf("}", i);
-      if (j < 0) return "a { has no closing }";
-      out.push({ t: "ref", v: text.slice(i + 1, j).trim() });
-      i = j + 1;
-    } else if (c === "'" || c === '"') {
-      const j = text.indexOf(c, i + 1);
-      if (j < 0) return "a quoted word has no closing quote";
-      out.push({ t: "str", v: text.slice(i + 1, j) });
-      i = j + 1;
-    } else if (/[0-9.]/.test(c)) {
-      const m = /^[0-9]*\.?[0-9]+/.exec(text.slice(i));
-      out.push({ t: "num", v: m[0] });
-      i += m[0].length;
-    } else if (/[A-Za-z_]/.test(c)) {
-      const m = /^[A-Za-z_][A-Za-z_0-9]*/.exec(text.slice(i));
-      out.push({ t: "name", v: m[0] });
-      i += m[0].length;
-    } else if ("+-*/(),%".includes(c)) {
-      out.push({ t: "op", v: c });
-      i += 1;
-    } else return `"${c}" is not part of a formula`;
-  }
-  return out;
-}
-function parseFormula(text) {
-  const toks = fxTokens(text);
-  if (typeof toks === "string") return toks;
-  let p = 0;
-  const peek = () => toks[p];
-  const fail = (why) => {
-    throw new Error(why);
-  };
-  const expr = () => {
-    let a = term();
-    while (peek()?.t === "op" && (peek().v === "+" || peek().v === "-")) {
-      const op = toks[p++].v;
-      a = { k: "bin", op, a, b: term() };
-    }
-    return a;
-  };
-  const term = () => {
-    let a = factor();
-    while (peek()?.t === "op" && (peek().v === "*" || peek().v === "/" || peek().v === "%")) {
-      const op = toks[p++].v;
-      a = { k: "bin", op, a, b: factor() };
-    }
-    return a;
-  };
-  const factor = () => {
-    const tk = toks[p++];
-    if (!tk) return fail("the formula ends too early");
-    if (tk.t === "num") return { k: "num", v: parseNumeric(tk.v) };
-    if (tk.t === "str") return { k: "str", v: tk.v };
-    if (tk.t === "ref") return { k: "ref", v: tk.v };
-    if (tk.t === "op" && tk.v === "-") return { k: "neg", a: factor() };
-    if (tk.t === "op" && tk.v === "(") {
-      const e = expr();
-      if (toks[p++]?.v !== ")") fail("a ( has no closing )");
-      return e;
-    }
-    if (tk.t === "name") {
-      const f = tk.v.toUpperCase();
-      if (!FORMULA_FUNCTIONS.has(f)) fail(`${tk.v} is not a formula function the store knows`);
-      if (toks[p++]?.v !== "(") fail(`${f} is followed by its arguments in ( )`);
-      const args = [];
-      if (peek()?.v !== ")") {
-        args.push(expr());
-        while (peek()?.v === ",") {
-          p += 1;
-          args.push(expr());
-        }
-      }
-      if (toks[p++]?.v !== ")") fail(`${f}( has no closing )`);
-      return { k: "call", f, args };
-    }
-    return fail(`"${tk.v}" is out of place`);
-  };
-  try {
-    const e = expr();
-    if (p !== toks.length) return `"${toks[p].v}" is out of place`;
-    return e;
-  } catch (err) {
-    return err.message;
-  }
+var FORMULA_FUNCTION_NAMES = new Set(import_formula.FORMULA_FUNCTIONS.map((f) => f.name));
+function toFx(n) {
+  switch (n.kind) {
+    case "number":
+      return { k: "num", v: parseNumeric(n.raw) };
+    case "string":
+      return { k: "str", v: n.value };
+    case "boolean":
+      return { k: "call", f: n.value ? "TRUE" : "FALSE", args: [] };
+    case "reference":
+      return { k: "ref", v: n.name };
+    case "unary":
+      return { k: "neg", a: toFx(n.operand) };
+    case "binary":
+      return { k: "bin", op: n.operator, a: toFx(n.left), b: toFx(n.right) };
+    case "call":
+      return { k: "call", f: n.name, args: n.args.map(toFx) };
+  }
+}
+function parseGateFormula(text) {
+  const parsed = (0, import_formula.parseFormula)(text);
+  return parsed.ok ? toFx(parsed.ast) : parsed.error;
 }
 function formulaRefs(n) {
   if (n.k === "ref") return [n.v];
@@ -3070,7 +2965,7 @@ function evalFormula(n, valueOf) {
       if (n.op === "*") return { ok: true, v: q(a.n * b.n, a.d * b.d) };
       if (b.n === 0n) return { ok: false, why: "it divides by zero on a row" };
       if (n.op === "/") return { ok: true, v: q(a.n * b.d, a.d * b.n) };
-      return { ok: false, why: "% is not mirrored" };
+      return { ok: false, why: `${n.op} is not mirrored` };
     }
     case "call": {
       if (n.f === "ABS" && n.args.length === 1) {
@@ -3813,7 +3708,7 @@ function validateTemplate(raw, options = {}) {
       return isComputed(pf) ? computedOf(target, pf, { key: far.key, values: far.values }, depth + 1) : { ok: true, v: far.values?.[f.pick] ?? null };
     }
     if (f.parityType === "formula" && f.formula) {
-      const ast = parseFormula(f.formula);
+      const ast = parseGateFormula(f.formula);
       if (typeof ast === "string") return { ok: false, why: ast };
       let why = null;
       const r2 = evalFormula(ast, (label2) => {
@@ -3843,7 +3738,7 @@ function validateTemplate(raw, options = {}) {
     if (!f) return false;
     if (isNumber(f)) return true;
     if (f.parityType !== "formula" || !f.formula) return false;
-    const ast = parseFormula(f.formula);
+    const ast = parseGateFormula(f.formula);
     if (typeof ast === "string") return false;
     const refsStored = formulaRefs(ast).every((l) => {
       const rf = byToken.get(table)?.fields.find((x) => x.label === l);
@@ -5150,7 +5045,7 @@ function validateTemplate(raw, options = {}) {
         say(fat, `"${f.label}" is a formula; write it in formula, naming fields in braces: {Total} - {Paid}.`);
         continue;
       }
-      const ast = parseFormula(f.formula);
+      const ast = parseGateFormula(f.formula);
       if (typeof ast === "string") {
         say(fat, `The formula "${f.formula}" cannot be read: ${ast}.`);
         continue;