@marktiderman/genesis-forms 0.4.0 → 0.4.1

package/dist/testing.js

@@ -32,6 +32,7 @@ function tokenize(source) {
         i++;
         while (isDigit(source[i] ?? "")) i++;
       }
+      if (isIdStart(source[i] ?? "")) throw new FormulaError("Write a number in digits only, like 1000000.", at);
       const v = Number(source.slice(at, i));
       if (!Number.isFinite(v)) throw new FormulaError("This number is too large.", at);
       tokens.push({ t: "num", v, at });
@@ -230,6 +231,27 @@ function numbersIn(values, out = []) {
   }
   return out;
 }
+var listTotals = /* @__PURE__ */ new WeakMap();
+var ownLists = /* @__PURE__ */ new WeakSet();
+function ownFormulaList(list) {
+  Object.freeze(list);
+  ownLists.add(list);
+  return list;
+}
+function totalsOf(list) {
+  const own2 = ownLists.has(list);
+  let t = own2 ? listTotals.get(list) : void 0;
+  if (t) return t;
+  const nums = numbersIn(list);
+  t = { sum: 0, count: nums.length, min: Infinity, max: -Infinity };
+  for (const n of nums) {
+    t.sum += n;
+    if (n < t.min) t.min = n;
+    if (n > t.max) t.max = n;
+  }
+  if (own2) listTotals.set(list, t);
+  return t;
+}
 function compare(op, a, b) {
   const blank2 = (v) => v === null || Array.isArray(v) || typeof v === "string" && v.trim() === "";
   if (blank2(a) || blank2(b)) return op === "!=";
@@ -254,7 +276,7 @@ function evaluateFormula(ast, read) {
       case "text":
         return node.value;
       case "ref":
-        return read(node.column !== void 0 ? { key: node.key, column: node.column } : { key: node.key });
+        return read(node);
       case "unary": {
         const n = formulaNumber(scalar(run(node.arg)));
         return n === null ? null : -n;
@@ -262,12 +284,31 @@ function evaluateFormula(ast, read) {
       case "if":
         return truthy(run(node.test)) ? run(node.then) : run(node.else);
       case "call": {
-        const nums = numbersIn(node.args.map(run));
-        const total = nums.reduce((a, b) => a + b, 0);
+        let total = 0;
+        let count = 0;
+        let min = Infinity;
+        let max = -Infinity;
+        for (const arg of node.args) {
+          const v = run(arg);
+          if (Array.isArray(v)) {
+            const t = totalsOf(v);
+            total += t.sum;
+            count += t.count;
+            if (t.min < min) min = t.min;
+            if (t.max > max) max = t.max;
+            continue;
+          }
+          const n = formulaNumber(v);
+          if (n === null) continue;
+          total += n;
+          count++;
+          if (n < min) min = n;
+          if (n > max) max = n;
+        }
         if (node.fn === "sum") return finite(total);
-        if (!nums.length) return null;
-        if (node.fn === "avg") return finite(total / nums.length);
-        return nums.reduce((a, b) => node.fn === "min" ? Math.min(a, b) : Math.max(a, b));
+        if (!count) return null;
+        if (node.fn === "avg") return finite(total / count);
+        return node.fn === "min" ? min : max;
       }
       case "binary": {
         const a = run(node.left);
@@ -294,6 +335,7 @@ function evaluateFormula(ast, read) {
 
 // src/calculated.ts
 var CALCULATED_TYPE = "calculated";
+var MAX_FORM_FORMULA_LENGTH = 2e4;
 var MAX_CALCULATED_DECIMALS = 10;
 function calculatedProps(field) {
   const p = field.props ?? {};
@@ -332,23 +374,41 @@ function formatCalculated(value, field) {
   return typeof value === "string" ? value : "";
 }
 var MAX_FORMULA_ITEMS = 1e4;
+var MAX_SETTLE_ITEMS = 5e4;
+var extract = (value, column) => column !== void 0 ? value.flatMap((row) => {
+  if (!row || typeof row !== "object" || Array.isArray(row)) return [];
+  const cell = row[column];
+  return typeof cell === "string" || typeof cell === "number" ? [cell] : [];
+}) : value.flatMap((v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean" ? [v] : []);
+var extracted = /* @__PURE__ */ new WeakMap();
+function cachedList(value, column) {
+  let byColumn = extracted.get(value);
+  if (!byColumn) extracted.set(value, byColumn = /* @__PURE__ */ new Map());
+  const key = column ?? "";
+  let list = byColumn.get(key);
+  if (!list) byColumn.set(key, list = ownFormulaList(extract(value, column)));
+  return list;
+}
+function readAnswer(value, column) {
+  if (Array.isArray(value)) return cachedList(value, column);
+  return column !== void 0 ? null : formulaInput(value);
+}
 function formulaInput(value, column) {
   if (value === void 0 || value === null) return null;
   if (Array.isArray(value) && value.length > MAX_FORMULA_ITEMS) return null;
-  if (column !== void 0) {
-    if (!Array.isArray(value)) return null;
-    return value.flatMap((row) => {
-      if (!row || typeof row !== "object" || Array.isArray(row)) return [];
-      const cell = row[column];
-      return typeof cell === "string" || typeof cell === "number" ? [cell] : [];
-    });
-  }
-  if (Array.isArray(value)) {
-    return value.flatMap((v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean" ? [v] : []);
-  }
+  if (Array.isArray(value)) return extract(value, void 0);
   return typeof value === "object" ? null : value;
 }
+function refNodes(node, out = []) {
+  if (node.kind === "ref") out.push(node);
+  else if (node.kind === "unary") refNodes(node.arg, out);
+  else if (node.kind === "binary") refNodes(node.left, out), refNodes(node.right, out);
+  else if (node.kind === "if") refNodes(node.test, out), refNodes(node.then, out), refNodes(node.else, out);
+  else if (node.kind === "call") for (const a of node.args) refNodes(a, out);
+  return out;
+}
 var UNREAD = /* @__PURE__ */ Symbol("unread");
+var OVER = /* @__PURE__ */ Symbol("over");
 function calculator(definition) {
   const compiled = [];
   const idByKey = /* @__PURE__ */ new Map();
@@ -359,14 +419,39 @@ function calculator(definition) {
   for (const block of definition.blocks) {
     if (block.kind !== "field" || !isCalculated(block)) continue;
     const parsed = parseFormula(calculatedProps(block).formula);
-    const reads = parsed.ok ? parsed.refs.map((r) => idByKey.get(r.key)) : [];
-    compiled.push({ field: block, ast: parsed.ok ? parsed.ast : null, reads, last: null });
+    const reads = [];
+    const slots = /* @__PURE__ */ new Map();
+    const byKey = /* @__PURE__ */ new Map();
+    for (const ref of parsed.ok ? refNodes(parsed.ast) : []) {
+      const id = idByKey.get(ref.key);
+      const key = `${id ?? ""}\0${ref.column ?? ""}`;
+      let slot = byKey.get(key);
+      if (slot === void 0) {
+        slot = reads.push({ id, column: ref.column, key }) - 1;
+        byKey.set(key, slot);
+      }
+      slots.set(ref, slot);
+    }
+    compiled.push({ field: block, ast: parsed.ok ? parsed.ast : null, reads, slots, last: null });
   }
   const withCalculated = (values, path) => {
     if (!compiled.length) return values;
     const visible = new Set(path);
     let next = values;
-    const input = (id) => id === void 0 || !visible.has(id) || !Object.prototype.hasOwnProperty.call(next, id) ? UNREAD : next[id];
+    let budget = MAX_SETTLE_ITEMS;
+    const within = /* @__PURE__ */ new Map();
+    const input = ({ id, key }) => {
+      if (id === void 0 || !visible.has(id) || !Object.prototype.hasOwnProperty.call(next, id)) return UNREAD;
+      const value = next[id];
+      if (!Array.isArray(value)) return value;
+      let ok = within.get(key);
+      if (ok === void 0) {
+        ok = value.length <= MAX_FORMULA_ITEMS && value.length <= budget;
+        if (ok) budget -= value.length;
+        within.set(key, ok);
+      }
+      return ok ? value : OVER;
+    };
     for (const entry of compiled) {
       const { field, ast } = entry;
       const inputs = entry.reads.map(input);
@@ -374,11 +459,18 @@ function calculator(definition) {
       if (entry.last && entry.last.inputs.length === inputs.length && entry.last.inputs.every((v, i) => v === inputs[i])) {
         value = entry.last.value;
       } else {
+        const resolved = new Array(inputs.length);
         const read = (ref) => {
-          const raw = input(idByKey.get(ref.key));
-          return raw === UNREAD ? null : formulaInput(raw, ref.column);
+          const slot = entry.slots.get(ref);
+          if (slot === void 0) return null;
+          let v = resolved[slot];
+          if (v === void 0) {
+            const raw = inputs[slot];
+            v = resolved[slot] = raw === UNREAD ? null : readAnswer(raw, entry.reads[slot].column);
+          }
+          return v;
         };
-        value = ast ? calculatedValue(evaluateFormula(ast, read), field) : void 0;
+        value = ast && !inputs.includes(OVER) ? calculatedValue(evaluateFormula(ast, read), field) : void 0;
         entry.last = { inputs, value };
       }
       const current = Object.prototype.hasOwnProperty.call(next, field.id) ? next[field.id] : void 0;
@@ -1780,9 +1872,15 @@ function parseForm(input) {
       issue(`${path}.kind`, "Unknown block kind.");
     }
   });
+  let formulaChars = 0;
   input.blocks.forEach((block, i) => {
     if (!isObject2(block) || block.kind !== "field" || block.type !== CALCULATED_TYPE) return;
     const path = `blocks[${i}].props.formula`;
+    const source = isObject2(block.props) && typeof block.props.formula === "string" ? block.props.formula : "";
+    formulaChars += source.length;
+    if (formulaChars > MAX_FORM_FORMULA_LENGTH && formulaChars - source.length <= MAX_FORM_FORMULA_LENGTH) {
+      issue(path, `The form's formulas together are over ${MAX_FORM_FORMULA_LENGTH} characters; shorten some, or work part out once in an earlier calculated field.`);
+    }
     if (block.required === true) {
       warnings.push({ path: `blocks[${i}].required`, message: "A calculated field is worked out, not answered, so it is never required." });
     }