@freighttech/ui 0.13.18

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

@@ -0,0 +1,47 @@
+import { FORMULA_ERROR_I18N_KEYS, formulaIssue, formulaIssueI18nKey } from "./types.js";
+import { collectFieldRefs, parseFormula, tokenize } from "./parse.js";
+import {
+  checkAst,
+  checkFormulaColumn,
+  columnTypeToFormulaType,
+  detectFormulaCycles,
+  fieldMetaFromColumns
+} from "./check.js";
+import {
+  FORMULA_FUNCTIONS,
+  FORMULA_FUNCTION_NAMES,
+  FORMULA_FUNCTION_SIGNATURES,
+  lookupFormulaFunction
+} from "./functions.js";
+import {
+  coerceToResultType,
+  compileFormulaColumns,
+  createFormulaRowEvaluator,
+  evaluateAst,
+  evaluateExpression,
+  evaluateFormulaRow
+} from "./evaluate.js";
+export {
+  FORMULA_ERROR_I18N_KEYS,
+  FORMULA_FUNCTIONS,
+  FORMULA_FUNCTION_NAMES,
+  FORMULA_FUNCTION_SIGNATURES,
+  checkAst,
+  checkFormulaColumn,
+  coerceToResultType,
+  collectFieldRefs,
+  columnTypeToFormulaType,
+  compileFormulaColumns,
+  createFormulaRowEvaluator,
+  detectFormulaCycles,
+  evaluateAst,
+  evaluateExpression,
+  evaluateFormulaRow,
+  fieldMetaFromColumns,
+  formulaIssue,
+  formulaIssueI18nKey,
+  lookupFormulaFunction,
+  parseFormula,
+  tokenize
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/formula/index.ts"],
+  "sourcesContent": ["// formula/index.ts\n//\n// Public surface of the DynamicTable expression language.\n//\n// Everything here is dependency-free and framework-free: no React, no network,\n// no `@open-mercato/*`. That is deliberate \u2014 the same modules are intended to\n// run server-side unchanged if formula columns are ever persisted (spec A2b).\n\nexport type {\n  FormulaAst,\n  FormulaBinaryOp,\n  FormulaCellResult,\n  FormulaCellState,\n  FormulaColumnRef,\n  FormulaErrorCode,\n  FormulaFieldMeta,\n  FormulaIssue,\n  FormulaResultType,\n  FormulaValue,\n  FormulaValueType,\n} from './types';\nexport { FORMULA_ERROR_I18N_KEYS, formulaIssue, formulaIssueI18nKey } from './types';\n\nexport type { FormulaToken, FormulaTokenType, ParseResult } from './parse';\nexport { collectFieldRefs, parseFormula, tokenize } from './parse';\n\nexport type {\n  CheckFormulaColumnInput,\n  CheckFormulaColumnResult,\n  CheckResult,\n  FormulaCheckContext,\n} from './check';\nexport {\n  checkAst,\n  checkFormulaColumn,\n  columnTypeToFormulaType,\n  detectFormulaCycles,\n  fieldMetaFromColumns,\n} from './check';\n\nexport type { EvalOutcome, FormulaFunctionDef, FormulaRuntime } from './functions';\nexport {\n  FORMULA_FUNCTIONS,\n  FORMULA_FUNCTION_NAMES,\n  FORMULA_FUNCTION_SIGNATURES,\n  lookupFormulaFunction,\n} from './functions';\n\nexport type { CompiledFormula, CompiledFormulaSet, EvaluateOptions } from './evaluate';\nexport {\n  coerceToResultType,\n  compileFormulaColumns,\n  createFormulaRowEvaluator,\n  evaluateAst,\n  evaluateExpression,\n  evaluateFormulaRow,\n} from './evaluate';\n"],
+  "mappings": "AAqBA,SAAS,yBAAyB,cAAc,2BAA2B;AAG3E,SAAS,kBAAkB,cAAc,gBAAgB;AAQzD;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;",
+  "names": []
+}

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

@@ -0,0 +1,293 @@
+import { formulaIssue } from "./types.js";
+const TWO_CHAR_OPS = [">=", "<=", "!=", "<>", "==", "&&", "||"];
+const ONE_CHAR_OPS = ["+", "-", "*", "/", "(", ")", ",", "&", "=", ">", "<", "!"];
+class FormulaSyntaxError extends Error {
+  constructor(issue) {
+    super(issue.message);
+    this.issue = issue;
+  }
+}
+function syntaxError(token, position) {
+  return new FormulaSyntaxError(
+    formulaIssue("syntax", `Could not read the formula near "${token}"`, { token }, position)
+  );
+}
+function isDigit(ch) {
+  return ch >= "0" && ch <= "9";
+}
+function isIdentStart(ch) {
+  return /[A-Za-z_]/.test(ch);
+}
+function isIdentPart(ch) {
+  return /[A-Za-z0-9_]/.test(ch);
+}
+function tokenize(source) {
+  const tokens = [];
+  let i = 0;
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+      i += 1;
+      continue;
+    }
+    if (isDigit(ch)) {
+      const start = i;
+      while (i < source.length && isDigit(source[i])) i += 1;
+      if (source[i] === ".") {
+        i += 1;
+        while (i < source.length && isDigit(source[i])) i += 1;
+      }
+      const text = source.slice(start, i);
+      tokens.push({ type: "number", text, value: Number(text), start });
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      const start = i;
+      i += 1;
+      let out = "";
+      let closed = false;
+      while (i < source.length) {
+        const c = source[i];
+        if (c === "\\" && i + 1 < source.length) {
+          out += source[i + 1];
+          i += 2;
+          continue;
+        }
+        if (c === quote) {
+          i += 1;
+          closed = true;
+          break;
+        }
+        out += c;
+        i += 1;
+      }
+      if (!closed) throw syntaxError(source.slice(start), start);
+      tokens.push({ type: "string", text: out, value: out, start });
+      continue;
+    }
+    if (ch === "[") {
+      const start = i;
+      const end = source.indexOf("]", i + 1);
+      if (end === -1) throw syntaxError(source.slice(start), start);
+      const name = source.slice(i + 1, end).trim();
+      if (!name) throw syntaxError("[]", start);
+      tokens.push({ type: "field", text: name, start });
+      i = end + 1;
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      const start = i;
+      while (i < source.length && isIdentPart(source[i])) i += 1;
+      tokens.push({ type: "ident", text: source.slice(start, i), start });
+      continue;
+    }
+    const two = source.slice(i, i + 2);
+    if (TWO_CHAR_OPS.includes(two)) {
+      tokens.push({ type: "punct", text: two, start: i });
+      i += 2;
+      continue;
+    }
+    if (ONE_CHAR_OPS.includes(ch)) {
+      tokens.push({ type: "punct", text: ch, start: i });
+      i += 1;
+      continue;
+    }
+    throw syntaxError(ch, i);
+  }
+  tokens.push({ type: "eof", text: "", start: source.length });
+  return tokens;
+}
+const KEYWORD_LITERALS = {
+  TRUE: { v: true },
+  FALSE: { v: false },
+  NULL: { v: null }
+};
+class Parser {
+  constructor(tokens) {
+    this.pos = 0;
+    this.tokens = tokens;
+  }
+  peek(offset = 0) {
+    return this.tokens[Math.min(this.pos + offset, this.tokens.length - 1)];
+  }
+  next() {
+    const token = this.peek();
+    if (token.type !== "eof") this.pos += 1;
+    return token;
+  }
+  fail(token) {
+    throw syntaxError(token.type === "eof" ? "end of formula" : token.text, token.start);
+  }
+  /**
+   * Match an operator that may be written as punctuation (`&&`) or as a keyword
+   * (`AND`). A keyword only counts as an operator when it is NOT immediately
+   * followed by `(` — otherwise `AND(a, b)` would parse as a dangling operator
+   * instead of the function call it is.
+   */
+  matchOperator(punct, keywords = []) {
+    const token = this.peek();
+    if (token.type === "punct" && punct.includes(token.text)) {
+      this.pos += 1;
+      return token.text;
+    }
+    if (token.type === "ident" && keywords.includes(token.text.toUpperCase())) {
+      if (this.peek(1).type === "punct" && this.peek(1).text === "(") return null;
+      this.pos += 1;
+      return token.text.toUpperCase();
+    }
+    return null;
+  }
+  parseExpression() {
+    return this.parseOr();
+  }
+  parseOr() {
+    let left = this.parseAnd();
+    for (; ; ) {
+      const op = this.matchOperator(["||"], ["OR"]);
+      if (!op) return left;
+      left = { k: "bin", op: "||", l: left, r: this.parseAnd() };
+    }
+  }
+  parseAnd() {
+    let left = this.parseNot();
+    for (; ; ) {
+      const op = this.matchOperator(["&&"], ["AND"]);
+      if (!op) return left;
+      left = { k: "bin", op: "&&", l: left, r: this.parseNot() };
+    }
+  }
+  parseNot() {
+    const op = this.matchOperator(["!"], ["NOT"]);
+    if (op) return { k: "call", fn: "NOT", args: [this.parseNot()] };
+    return this.parseComparison();
+  }
+  parseComparison() {
+    const left = this.parseConcat();
+    const op = this.matchOperator(["=", "==", "!=", "<>", ">", ">=", "<", "<="]);
+    if (!op) return left;
+    const normalised = op === "==" ? "=" : op === "<>" ? "!=" : op;
+    const right = this.parseConcat();
+    const chained = this.matchOperator(["=", "==", "!=", "<>", ">", ">=", "<", "<="]);
+    if (chained) this.fail(this.peek(-1));
+    return { k: "bin", op: normalised, l: left, r: right };
+  }
+  parseConcat() {
+    let left = this.parseAdditive();
+    for (; ; ) {
+      const op = this.matchOperator(["&"]);
+      if (!op) return left;
+      left = { k: "bin", op: "concat", l: left, r: this.parseAdditive() };
+    }
+  }
+  parseAdditive() {
+    let left = this.parseMultiplicative();
+    for (; ; ) {
+      const op = this.matchOperator(["+", "-"]);
+      if (!op) return left;
+      left = { k: "bin", op, l: left, r: this.parseMultiplicative() };
+    }
+  }
+  parseMultiplicative() {
+    let left = this.parseUnary();
+    for (; ; ) {
+      const op = this.matchOperator(["*", "/"]);
+      if (!op) return left;
+      left = { k: "bin", op, l: left, r: this.parseUnary() };
+    }
+  }
+  parseUnary() {
+    if (this.matchOperator(["-"])) return { k: "neg", e: this.parseUnary() };
+    if (this.matchOperator(["+"])) return this.parseUnary();
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    const token = this.next();
+    if (token.type === "number") return { k: "lit", v: token.value };
+    if (token.type === "string") return { k: "lit", v: token.value };
+    if (token.type === "field") return { k: "field", name: token.text };
+    if (token.type === "punct" && token.text === "(") {
+      const inner = this.parseExpression();
+      const close = this.next();
+      if (close.type !== "punct" || close.text !== ")") this.fail(close);
+      return inner;
+    }
+    if (token.type === "ident") {
+      const upper = token.text.toUpperCase();
+      const ahead = this.peek();
+      const isCall = ahead.type === "punct" && ahead.text === "(";
+      if (!isCall && upper in KEYWORD_LITERALS) {
+        return { k: "lit", v: KEYWORD_LITERALS[upper].v };
+      }
+      if (!isCall) return { k: "field", name: token.text };
+      this.pos += 1;
+      const args = [];
+      if (!(this.peek().type === "punct" && this.peek().text === ")")) {
+        for (; ; ) {
+          args.push(this.parseExpression());
+          if (this.matchOperator([","])) continue;
+          break;
+        }
+      }
+      const close = this.next();
+      if (close.type !== "punct" || close.text !== ")") this.fail(close);
+      return { k: "call", fn: upper, args };
+    }
+    this.fail(token);
+  }
+  expectEof() {
+    const token = this.peek();
+    if (token.type !== "eof") this.fail(token);
+  }
+}
+function parseFormula(source) {
+  if (!source || !source.trim()) {
+    return {
+      ok: false,
+      issue: formulaIssue("syntax", 'Could not read the formula near ""', { token: "" }, 0)
+    };
+  }
+  try {
+    const parser = new Parser(tokenize(source));
+    const ast = parser.parseExpression();
+    parser.expectEof();
+    return { ok: true, ast };
+  } catch (err) {
+    if (err instanceof FormulaSyntaxError) return { ok: false, issue: err.issue };
+    throw err;
+  }
+}
+function collectFieldRefs(ast) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const walk = (node) => {
+    switch (node.k) {
+      case "field":
+        if (!seen.has(node.name)) {
+          seen.add(node.name);
+          out.push(node.name);
+        }
+        return;
+      case "bin":
+        walk(node.l);
+        walk(node.r);
+        return;
+      case "neg":
+        walk(node.e);
+        return;
+      case "call":
+        node.args.forEach(walk);
+        return;
+      default:
+        return;
+    }
+  };
+  walk(ast);
+  return out;
+}
+export {
+  collectFieldRefs,
+  parseFormula,
+  tokenize
+};
+//# sourceMappingURL=parse.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/formula/parse.ts"],
+  "sourcesContent": ["// formula/parse.ts\n//\n// Tokeniser + hand-written recursive-descent parser for the DynamicTable\n// expression language. No parser dependency: the grammar is small enough that a\n// dependency would cost more (licence surface, bundle, indirection) than it\n// saves.\n//\n// Grammar, loosest binding first \u2014 Excel's precedence, deliberately:\n//\n//   expression  := or\n//   or          := and      ( (\"||\" | \"OR\")  and )*\n//   and         := not      ( (\"&&\" | \"AND\") not )*\n//   not         := (\"!\" | \"NOT\") not | comparison\n//   comparison  := concat   ( (\"=\" | \"==\" | \"!=\" | \"<>\" | \">\" | \">=\" | \"<\" | \"<=\") concat )?\n//   concat      := additive ( \"&\" additive )*\n//   additive    := multiplicative ( (\"+\" | \"-\") multiplicative )*\n//   multiplicative := unary ( (\"*\" | \"/\") unary )*\n//   unary       := \"-\" unary | primary\n//   primary     := NUMBER | STRING | TRUE | FALSE | NULL\n//                | IDENT \"(\" [ expression (\",\" expression)* ] \")\"     -- call\n//                | IDENT | \"[\" ... \"]\"                                -- field\n//                | \"(\" expression \")\"\n//\n// Comparison is intentionally non-associative: `a < b < c` is a bug in every\n// language that allows it, so it is a syntax error here.\n\nimport type { FormulaAst, FormulaBinaryOp, FormulaIssue } from './types';\nimport { formulaIssue } from './types';\n\n// ============================================\n// TOKENISER\n// ============================================\n\nexport type FormulaTokenType = 'number' | 'string' | 'ident' | 'field' | 'punct' | 'eof';\n\nexport interface FormulaToken {\n  type: FormulaTokenType;\n  /** Punctuation/identifier text, or the decoded value for literals. */\n  text: string;\n  /** Decoded literal value for `number` / `string` tokens. */\n  value?: number | string;\n  /** 0-based offset of the token's first character. */\n  start: number;\n}\n\n/**\n * Two-character operators, checked before the single-character table so `>=`\n * never tokenises as `>` followed by `=`.\n */\nconst TWO_CHAR_OPS = ['>=', '<=', '!=', '<>', '==', '&&', '||'];\nconst ONE_CHAR_OPS = ['+', '-', '*', '/', '(', ')', ',', '&', '=', '>', '<', '!'];\n\n/** A tokenisation or parse failure, carried as an issue rather than a throw. */\nclass FormulaSyntaxError extends Error {\n  readonly issue: FormulaIssue;\n  constructor(issue: FormulaIssue) {\n    super(issue.message);\n    this.issue = issue;\n  }\n}\n\nfunction syntaxError(token: string, position: number): FormulaSyntaxError {\n  return new FormulaSyntaxError(\n    formulaIssue('syntax', `Could not read the formula near \"${token}\"`, { token }, position),\n  );\n}\n\nfunction isDigit(ch: string): boolean {\n  return ch >= '0' && ch <= '9';\n}\n\nfunction isIdentStart(ch: string): boolean {\n  return /[A-Za-z_]/.test(ch);\n}\n\nfunction isIdentPart(ch: string): boolean {\n  return /[A-Za-z0-9_]/.test(ch);\n}\n\n/**\n * Split source text into tokens. Exported because the token stream is the\n * cheapest thing to assert against when a precedence bug is suspected.\n */\nexport function tokenize(source: string): FormulaToken[] {\n  const tokens: FormulaToken[] = [];\n  let i = 0;\n\n  while (i < source.length) {\n    const ch = source[i];\n\n    // Whitespace\n    if (ch === ' ' || ch === '\\t' || ch === '\\n' || ch === '\\r') {\n      i += 1;\n      continue;\n    }\n\n    // Number: 12, 12.5, .5 is NOT accepted (leading digit required, so `.` stays\n    // free for a future member operator without an ambiguity).\n    if (isDigit(ch)) {\n      const start = i;\n      while (i < source.length && isDigit(source[i])) i += 1;\n      if (source[i] === '.') {\n        i += 1;\n        while (i < source.length && isDigit(source[i])) i += 1;\n      }\n      const text = source.slice(start, i);\n      tokens.push({ type: 'number', text, value: Number(text), start });\n      continue;\n    }\n\n    // String: '\u2026' or \"\u2026\", backslash escapes.\n    if (ch === '\"' || ch === \"'\") {\n      const quote = ch;\n      const start = i;\n      i += 1;\n      let out = '';\n      let closed = false;\n      while (i < source.length) {\n        const c = source[i];\n        if (c === '\\\\' && i + 1 < source.length) {\n          out += source[i + 1];\n          i += 2;\n          continue;\n        }\n        if (c === quote) {\n          i += 1;\n          closed = true;\n          break;\n        }\n        out += c;\n        i += 1;\n      }\n      if (!closed) throw syntaxError(source.slice(start), start);\n      tokens.push({ type: 'string', text: out, value: out, start });\n      continue;\n    }\n\n    // Bracketed field reference: [Unit price], for keys with spaces or dots.\n    if (ch === '[') {\n      const start = i;\n      const end = source.indexOf(']', i + 1);\n      if (end === -1) throw syntaxError(source.slice(start), start);\n      const name = source.slice(i + 1, end).trim();\n      if (!name) throw syntaxError('[]', start);\n      tokens.push({ type: 'field', text: name, start });\n      i = end + 1;\n      continue;\n    }\n\n    // Identifier / keyword / bare field reference.\n    if (isIdentStart(ch)) {\n      const start = i;\n      while (i < source.length && isIdentPart(source[i])) i += 1;\n      tokens.push({ type: 'ident', text: source.slice(start, i), start });\n      continue;\n    }\n\n    // Operators / punctuation.\n    const two = source.slice(i, i + 2);\n    if (TWO_CHAR_OPS.includes(two)) {\n      tokens.push({ type: 'punct', text: two, start: i });\n      i += 2;\n      continue;\n    }\n    if (ONE_CHAR_OPS.includes(ch)) {\n      tokens.push({ type: 'punct', text: ch, start: i });\n      i += 1;\n      continue;\n    }\n\n    throw syntaxError(ch, i);\n  }\n\n  tokens.push({ type: 'eof', text: '', start: source.length });\n  return tokens;\n}\n\n// ============================================\n// PARSER\n// ============================================\n\nconst KEYWORD_LITERALS: Record<string, { v: number | string | boolean | null }> = {\n  TRUE: { v: true },\n  FALSE: { v: false },\n  NULL: { v: null },\n};\n\nclass Parser {\n  private readonly tokens: FormulaToken[];\n  private pos = 0;\n\n  constructor(tokens: FormulaToken[]) {\n    this.tokens = tokens;\n  }\n\n  private peek(offset = 0): FormulaToken {\n    return this.tokens[Math.min(this.pos + offset, this.tokens.length - 1)];\n  }\n\n  private next(): FormulaToken {\n    const token = this.peek();\n    if (token.type !== 'eof') this.pos += 1;\n    return token;\n  }\n\n  private fail(token: FormulaToken): never {\n    throw syntaxError(token.type === 'eof' ? 'end of formula' : token.text, token.start);\n  }\n\n  /**\n   * Match an operator that may be written as punctuation (`&&`) or as a keyword\n   * (`AND`). A keyword only counts as an operator when it is NOT immediately\n   * followed by `(` \u2014 otherwise `AND(a, b)` would parse as a dangling operator\n   * instead of the function call it is.\n   */\n  private matchOperator(punct: string[], keywords: string[] = []): string | null {\n    const token = this.peek();\n    if (token.type === 'punct' && punct.includes(token.text)) {\n      this.pos += 1;\n      return token.text;\n    }\n    if (token.type === 'ident' && keywords.includes(token.text.toUpperCase())) {\n      if (this.peek(1).type === 'punct' && this.peek(1).text === '(') return null;\n      this.pos += 1;\n      return token.text.toUpperCase();\n    }\n    return null;\n  }\n\n  parseExpression(): FormulaAst {\n    return this.parseOr();\n  }\n\n  private parseOr(): FormulaAst {\n    let left = this.parseAnd();\n    for (;;) {\n      const op = this.matchOperator(['||'], ['OR']);\n      if (!op) return left;\n      left = { k: 'bin', op: '||', l: left, r: this.parseAnd() };\n    }\n  }\n\n  private parseAnd(): FormulaAst {\n    let left = this.parseNot();\n    for (;;) {\n      const op = this.matchOperator(['&&'], ['AND']);\n      if (!op) return left;\n      left = { k: 'bin', op: '&&', l: left, r: this.parseNot() };\n    }\n  }\n\n  private parseNot(): FormulaAst {\n    const op = this.matchOperator(['!'], ['NOT']);\n    // `NOT` lowers to the library function of the same name rather than a\n    // dedicated AST node, so the persisted AST stays exactly the five kinds the\n    // spec fixes.\n    if (op) return { k: 'call', fn: 'NOT', args: [this.parseNot()] };\n    return this.parseComparison();\n  }\n\n  private parseComparison(): FormulaAst {\n    const left = this.parseConcat();\n    const op = this.matchOperator(['=', '==', '!=', '<>', '>', '>=', '<', '<=']);\n    if (!op) return left;\n    const normalised: FormulaBinaryOp =\n      op === '==' ? '=' : op === '<>' ? '!=' : (op as FormulaBinaryOp);\n    const right = this.parseConcat();\n    // Non-associative on purpose: `a < b < c` reads as maths but means something\n    // else in every language that allows it.\n    const chained = this.matchOperator(['=', '==', '!=', '<>', '>', '>=', '<', '<=']);\n    if (chained) this.fail(this.peek(-1));\n    return { k: 'bin', op: normalised, l: left, r: right };\n  }\n\n  private parseConcat(): FormulaAst {\n    let left = this.parseAdditive();\n    for (;;) {\n      const op = this.matchOperator(['&']);\n      if (!op) return left;\n      left = { k: 'bin', op: 'concat', l: left, r: this.parseAdditive() };\n    }\n  }\n\n  private parseAdditive(): FormulaAst {\n    let left = this.parseMultiplicative();\n    for (;;) {\n      const op = this.matchOperator(['+', '-']);\n      if (!op) return left;\n      left = { k: 'bin', op: op as FormulaBinaryOp, l: left, r: this.parseMultiplicative() };\n    }\n  }\n\n  private parseMultiplicative(): FormulaAst {\n    let left = this.parseUnary();\n    for (;;) {\n      const op = this.matchOperator(['*', '/']);\n      if (!op) return left;\n      left = { k: 'bin', op: op as FormulaBinaryOp, l: left, r: this.parseUnary() };\n    }\n  }\n\n  private parseUnary(): FormulaAst {\n    if (this.matchOperator(['-'])) return { k: 'neg', e: this.parseUnary() };\n    if (this.matchOperator(['+'])) return this.parseUnary();\n    return this.parsePrimary();\n  }\n\n  private parsePrimary(): FormulaAst {\n    const token = this.next();\n\n    if (token.type === 'number') return { k: 'lit', v: token.value as number };\n    if (token.type === 'string') return { k: 'lit', v: token.value as string };\n    if (token.type === 'field') return { k: 'field', name: token.text };\n\n    if (token.type === 'punct' && token.text === '(') {\n      const inner = this.parseExpression();\n      const close = this.next();\n      if (close.type !== 'punct' || close.text !== ')') this.fail(close);\n      return inner;\n    }\n\n    if (token.type === 'ident') {\n      const upper = token.text.toUpperCase();\n      const ahead = this.peek();\n      const isCall = ahead.type === 'punct' && ahead.text === '(';\n\n      if (!isCall && upper in KEYWORD_LITERALS) {\n        return { k: 'lit', v: KEYWORD_LITERALS[upper].v };\n      }\n      if (!isCall) return { k: 'field', name: token.text };\n\n      this.pos += 1; // consume '('\n      const args: FormulaAst[] = [];\n      if (!(this.peek().type === 'punct' && this.peek().text === ')')) {\n        for (;;) {\n          args.push(this.parseExpression());\n          if (this.matchOperator([','])) continue;\n          break;\n        }\n      }\n      const close = this.next();\n      if (close.type !== 'punct' || close.text !== ')') this.fail(close);\n      return { k: 'call', fn: upper, args };\n    }\n\n    this.fail(token);\n  }\n\n  expectEof(): void {\n    const token = this.peek();\n    if (token.type !== 'eof') this.fail(token);\n  }\n}\n\nexport type ParseResult =\n  | { ok: true; ast: FormulaAst }\n  | { ok: false; issue: FormulaIssue };\n\n/**\n * Parse source text into a `FormulaAst`. Never throws: a malformed formula is a\n * normal outcome (the user is mid-typing), so failure is a returned issue.\n */\nexport function parseFormula(source: string): ParseResult {\n  if (!source || !source.trim()) {\n    return {\n      ok: false,\n      issue: formulaIssue('syntax', 'Could not read the formula near \"\"', { token: '' }, 0),\n    };\n  }\n  try {\n    const parser = new Parser(tokenize(source));\n    const ast = parser.parseExpression();\n    parser.expectEof();\n    return { ok: true, ast };\n  } catch (err) {\n    if (err instanceof FormulaSyntaxError) return { ok: false, issue: err.issue };\n    throw err;\n  }\n}\n\n/**\n * Every field key an AST reads, de-duplicated, in first-seen order. The basis\n * for both cycle detection and the evaluator's per-row cache signature.\n */\nexport function collectFieldRefs(ast: FormulaAst): string[] {\n  const seen = new Set<string>();\n  const out: string[] = [];\n\n  const walk = (node: FormulaAst): void => {\n    switch (node.k) {\n      case 'field':\n        if (!seen.has(node.name)) {\n          seen.add(node.name);\n          out.push(node.name);\n        }\n        return;\n      case 'bin':\n        walk(node.l);\n        walk(node.r);\n        return;\n      case 'neg':\n        walk(node.e);\n        return;\n      case 'call':\n        node.args.forEach(walk);\n        return;\n      default:\n        return;\n    }\n  };\n\n  walk(ast);\n  return out;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,24 @@
+const FORMULA_ERROR_I18N_KEYS = {
+  syntax: "dynamicTable.formula.error.syntax",
+  unknown_field: "dynamicTable.formula.error.unknownField",
+  unknown_function: "dynamicTable.formula.error.unknownFunction",
+  arity: "dynamicTable.formula.error.arity",
+  type_mismatch: "dynamicTable.formula.error.typeMismatch",
+  divide_by_zero: "dynamicTable.formula.error.divideByZero",
+  cycle: "dynamicTable.formula.error.cycle"
+};
+function formulaIssueI18nKey(issue) {
+  return FORMULA_ERROR_I18N_KEYS[issue.code];
+}
+function formulaIssue(code, message, params, position) {
+  const issue = { code, message };
+  if (params) issue.params = params;
+  if (position !== void 0) issue.position = position;
+  return issue;
+}
+export {
+  FORMULA_ERROR_I18N_KEYS,
+  formulaIssue,
+  formulaIssueI18nKey
+};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/formula/types.ts"],
+  "sourcesContent": ["// formula/types.ts\n//\n// The shared vocabulary of the DynamicTable expression language.\n//\n// Everything here is deliberately *data*: the AST is a plain serialisable\n// discriminated union with no methods, no closures and no host references, so\n// the exact same definition that the browser walks today can later be walked by\n// a server evaluator or lowered to a parameterised SQL expression without ever\n// re-parsing the user's text.\n//\n// `FormulaColumnRef` is declared HERE rather than in `types/perspective.ts` on\n// purpose: the perspective module is the table's spine, and a formula column is\n// a leaf that depends on the language, not the other way round. Declaring it\n// locally keeps the dependency edge pointing one way.\n\n/**\n * Binary operators the language admits. `concat` is the `&` operator (string\n * concatenation, Excel's spelling); it is spelled out rather than punctuated so\n * a serialised AST stays readable in a saved view.\n */\nexport type FormulaBinaryOp =\n  | '+'\n  | '-'\n  | '*'\n  | '/'\n  | '='\n  | '!='\n  | '>'\n  | '>='\n  | '<'\n  | '<='\n  | '&&'\n  | '||'\n  | 'concat';\n\n/**\n * The whole language. Five node kinds, no loops, no assignment, no property\n * access, no host-object reach \u2014 which is what makes AST-walking evaluation\n * safe and `eval` unnecessary.\n */\nexport type FormulaAst =\n  | { k: 'lit'; v: number | string | boolean | null }\n  | { k: 'field'; name: string }\n  | { k: 'bin'; op: FormulaBinaryOp; l: FormulaAst; r: FormulaAst }\n  | { k: 'neg'; e: FormulaAst }\n  | { k: 'call'; fn: string; args: FormulaAst[] };\n\n/** The type a formula column declares it produces. */\nexport type FormulaResultType = 'number' | 'text' | 'boolean' | 'date';\n\n/**\n * A type as seen by the checker. `unknown` is the escape hatch for a column\n * whose `ColumnDef.type` the host never declared \u2014 it unifies with everything\n * so an undeclared column is never a false positive.\n */\nexport type FormulaValueType = FormulaResultType | 'unknown';\n\n/** Every value the evaluator can hold. `null` is \"empty\", never `NaN` or `0`. */\nexport type FormulaValue = number | string | boolean | Date | null;\n\n/**\n * A view-scoped calculated column. Rides in the perspectives `settings_json`\n * passthrough as `_formulas`, exactly as `_lookups` / `_aggregations` do.\n */\nexport interface FormulaColumnRef {\n  /** `formula__<slug>` \u2014 the synthesised `ColumnDef.data`. */\n  key: string;\n  /** Column header, user-authored. */\n  label: string;\n  /** Source text, exactly as the user typed it. */\n  expression: string;\n  resultType: FormulaResultType;\n}\n\n/**\n * Every way a formula can be wrong. `syntax`, `unknown_field`,\n * `unknown_function`, `arity` and `cycle` are *definition-time* failures \u2014 the\n * editor refuses to save them. `type_mismatch` and `divide_by_zero` can be\n * either: caught at definition time when the checker can prove them, and per\n * cell at evaluation time when only the data reveals them.\n */\nexport type FormulaErrorCode =\n  | 'syntax'\n  | 'unknown_field'\n  | 'unknown_function'\n  | 'arity'\n  | 'type_mismatch'\n  | 'divide_by_zero'\n  | 'cycle';\n\n/** One problem with a formula, carrying everything needed to translate it. */\nexport interface FormulaIssue {\n  code: FormulaErrorCode;\n  /** Untranslated English, used as the `t()` fallback and in tests. */\n  message: string;\n  /** Interpolation params for the i18n string (`{name}`, `{token}`). */\n  params?: Record<string, string | number>;\n  /** 0-based offset into the source text, when the issue has a location. */\n  position?: number;\n}\n\n/** Per-cell evaluation state, mirroring how `saveState` already works. */\nexport type FormulaCellState = 'ok' | 'empty' | 'error';\n\n/**\n * The outcome of evaluating one formula against one row. `empty` is a\n * first-class state: a null input yields `empty`, never `0` and never `NaN`.\n */\nexport type FormulaCellResult =\n  | { state: 'ok'; value: Exclude<FormulaValue, null> }\n  | { state: 'empty'; value: null }\n  | { state: 'error'; value: null; issue: FormulaIssue };\n\n/**\n * What the checker and the evaluator know about a referenceable column. `type`\n * comes from `ColumnDef.type`; `unknown` when the host did not declare one.\n */\nexport interface FormulaFieldMeta {\n  key: string;\n  label?: string;\n  type: FormulaValueType;\n}\n\n/** i18n keys for the error codes, so a caller never hand-maps them. */\nexport const FORMULA_ERROR_I18N_KEYS: Record<FormulaErrorCode, string> = {\n  syntax: 'dynamicTable.formula.error.syntax',\n  unknown_field: 'dynamicTable.formula.error.unknownField',\n  unknown_function: 'dynamicTable.formula.error.unknownFunction',\n  arity: 'dynamicTable.formula.error.arity',\n  type_mismatch: 'dynamicTable.formula.error.typeMismatch',\n  divide_by_zero: 'dynamicTable.formula.error.divideByZero',\n  cycle: 'dynamicTable.formula.error.cycle',\n};\n\n/** The i18n key for an issue, for `t(key, issue.message, issue.params)`. */\nexport function formulaIssueI18nKey(issue: FormulaIssue): string {\n  return FORMULA_ERROR_I18N_KEYS[issue.code];\n}\n\n/** Build an issue without repeating the object shape at 30 call sites. */\nexport function formulaIssue(\n  code: FormulaErrorCode,\n  message: string,\n  params?: Record<string, string | number>,\n  position?: number,\n): FormulaIssue {\n  const issue: FormulaIssue = { code, message };\n  if (params) issue.params = params;\n  if (position !== undefined) issue.position = position;\n  return issue;\n}\n"],
+  "mappings": "AA4HO,MAAM,0BAA4D;AAAA,EACvE,QAAQ;AAAA,EACR,eAAe;AAAA,EACf,kBAAkB;AAAA,EAClB,OAAO;AAAA,EACP,eAAe;AAAA,EACf,gBAAgB;AAAA,EAChB,OAAO;AACT;AAGO,SAAS,oBAAoB,OAA6B;AAC/D,SAAO,wBAAwB,MAAM,IAAI;AAC3C;AAGO,SAAS,aACd,MACA,SACA,QACA,UACc;AACd,QAAM,QAAsB,EAAE,MAAM,QAAQ;AAC5C,MAAI,OAAQ,OAAM,SAAS;AAC3B,MAAI,aAAa,OAAW,OAAM,WAAW;AAC7C,SAAO;AACT;",
+  "names": []
+}

package/dist/backend/dynamic-table/handlers/cellWrites.js

@@ -0,0 +1,143 @@
+import { dispatch } from "../events/events.js";
+const CELL_BATCH_SAVE_EVENT = "table:cell:batch:save";
+const CELL_BATCH_SAVE_RESULT_EVENT = "table:cell:batch:save:result";
+function emptyRejectionCounts() {
+  return {
+    readOnly: 0,
+    notCoercible: 0,
+    notInSource: 0,
+    required: 0,
+    outOfRange: 0
+  };
+}
+function isCellValueUnchanged(oldValue, newValue) {
+  if (Array.isArray(oldValue) || Array.isArray(newValue)) {
+    return JSON.stringify(oldValue) === JSON.stringify(newValue);
+  }
+  return String(oldValue ?? "") === String(newValue ?? "");
+}
+function isEmptyValue(value) {
+  return value === null || value === void 0 || value === "";
+}
+const passThroughCoercer = (value) => ({ ok: true, value });
+function dedupeWrites(writes) {
+  const byCell = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const write of writes) {
+    const key = `${write.row}:${write.col}`;
+    const at = byCell.get(key);
+    if (at === void 0) {
+      byCell.set(key, out.length);
+      out.push(write);
+    } else {
+      out[at] = write;
+    }
+  }
+  return out;
+}
+function applyCellWrites(deps, writes, options) {
+  const {
+    store,
+    columns,
+    handleCellSave,
+    coerce = passThroughCoercer,
+    element = null,
+    idColumnName = "id"
+  } = deps;
+  const { origin } = options;
+  const respectDisableFill = options.respectDisableFill ?? origin === "fill";
+  const requested = writes.length;
+  const deduped = dedupeWrites(writes);
+  const rowCount = store.getRowCount();
+  const results = [];
+  const accepted = [];
+  for (const write of deduped) {
+    const { row, col } = write;
+    const column = columns[col];
+    if (!column || col < 0 || row < 0 || row >= rowCount) {
+      results.push({ row, col, prop: column?.data ?? null, status: "rejected", reason: "outOfRange" });
+      continue;
+    }
+    const prop = column.data;
+    if (column.readOnly || respectDisableFill && column.disableFill) {
+      results.push({ row, col, prop, status: "rejected", reason: "readOnly" });
+      continue;
+    }
+    const coerced = coerce(write.value, column);
+    if (!coerced.ok) {
+      results.push({ row, col, prop, status: "rejected", reason: coerced.reason });
+      continue;
+    }
+    const value = coerced.value;
+    if (column.required === true && isEmptyValue(value)) {
+      results.push({ row, col, prop, status: "rejected", reason: "required" });
+      continue;
+    }
+    const rowData = store.getRowData(row);
+    const oldValue = rowData ? rowData[prop] : void 0;
+    if (isCellValueUnchanged(oldValue, value)) {
+      results.push({ row, col, prop, status: "unchanged", oldValue, newValue: value });
+      continue;
+    }
+    const result = { row, col, prop, status: "written", oldValue, newValue: value };
+    results.push(result);
+    accepted.push({ row, col, column, value, oldValue, rowData, result });
+  }
+  if (accepted.length > 0) {
+    store.beginUndoGroup();
+    try {
+      for (const item of accepted) {
+        handleCellSave(item.row, item.col, item.value, false);
+      }
+    } finally {
+      store.endUndoGroup();
+    }
+  }
+  const rejected = results.filter((r) => r.status === "rejected");
+  const rejectedByReason = emptyRejectionCounts();
+  for (const r of rejected) {
+    if (r.reason) rejectedByReason[r.reason] += 1;
+  }
+  const report = {
+    origin,
+    requested,
+    written: accepted.length,
+    unchanged: results.filter((r) => r.status === "unchanged").length,
+    rejected,
+    rejectedByReason,
+    results
+  };
+  if (element) {
+    dispatch(element, CELL_BATCH_SAVE_EVENT, {
+      origin,
+      writes: accepted.map((item) => ({
+        rowIndex: item.row,
+        colIndex: item.col,
+        prop: item.column.data,
+        oldValue: item.oldValue,
+        newValue: item.value,
+        rowData: item.rowData,
+        id: item.rowData?.[idColumnName]
+      }))
+    });
+    dispatch(element, CELL_BATCH_SAVE_RESULT_EVENT, {
+      applied: report.written,
+      rejected: rejected.map((r) => ({ rowIndex: r.row, colIndex: r.col, reason: r.reason }))
+    });
+  }
+  return report;
+}
+function createCellWriter(deps) {
+  return function write(writes, origin) {
+    const options = typeof origin === "string" ? { origin } : origin;
+    return applyCellWrites(deps, writes, options);
+  };
+}
+export {
+  CELL_BATCH_SAVE_EVENT,
+  CELL_BATCH_SAVE_RESULT_EVENT,
+  applyCellWrites,
+  createCellWriter,
+  isCellValueUnchanged
+};
+//# sourceMappingURL=cellWrites.js.map

package/dist/backend/dynamic-table/handlers/cellWrites.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/handlers/cellWrites.ts"],
+  "sourcesContent": ["// handlers/cellWrites.ts\n//\n// THE shared multi-cell write primitive.\n//\n// Paste, cut, clear-contents, fill, find-&-replace and import all write more\n// than one cell at a time. Every one of them goes through `applyCellWrites`.\n// A second write path is how the grid ends up with two undo behaviours, two\n// rejection tables and two sets of events \u2014 so there is exactly one.\n//\n// Contract:\n//   * every accepted write goes through the EXISTING `createCellHandlers`\n//     `handleCellSave` path, so per-cell `CELL_EDIT_SAVE`, the optimistic store\n//     update and the undo recording are all unchanged;\n//   * the whole batch is wrapped in ONE `beginUndoGroup()`/`endUndoGroup()`\n//     pair, so a 30x4 paste is a single Ctrl+Z;\n//   * per-cell results are RETURNED, never swallowed \u2014 a caller can report\n//     \"39 of 120 written, 3 read-only, 2 not coercible\".\n\nimport type { ColumnDef } from '../types/index';\nimport type { CellStore } from '../store/index';\nimport { dispatch } from '../events/events';\n\n// ============================================\n// EVENT NAMES\n// ============================================\n// Defined HERE \u2014 in the module that emits them \u2014 and imported by\n// `types/index.ts` as the values of `TableEvents.CELL_BATCH_SAVE` /\n// `CELL_BATCH_SAVE_RESULT`. One spelling of each string in the codebase.\n// Do not re-type these literals anywhere else.\n\n/** Emitted once per multi-cell write, alongside the per-cell `CELL_EDIT_SAVE`s. */\nexport const CELL_BATCH_SAVE_EVENT = 'table:cell:batch:save';\n/** Emitted once per multi-cell write with the applied/rejected tally. */\nexport const CELL_BATCH_SAVE_RESULT_EVENT = 'table:cell:batch:save:result';\n\n// ============================================\n// TYPES\n// ============================================\n\n/** Which interaction produced the batch. Drives reporting copy, not behaviour. */\nexport type CellWriteOrigin = 'paste' | 'cut' | 'clear' | 'fill' | 'replace' | 'import';\n\n/**\n * Why a cell was refused. Kept deliberately small: the caller renders one\n * counted line per reason, so every reason must be explainable in a few words.\n */\nexport type CellWriteRejectReason =\n  /** `readOnly` column, a lookup column, or (fill only) `disableFill`. */\n  | 'readOnly'\n  /** The value cannot become this column's type (numeric, date, relation, ...). */\n  | 'notCoercible'\n  /** A `dropdown`/`multiselect` value that is not one of `col.source`. */\n  | 'notInSource'\n  /** Emptying a column the module declares as required would 400. */\n  | 'required'\n  /** Row or column index is not on the loaded page (e.g. a clamped paste). */\n  | 'outOfRange';\n\n/** Coercion outcome \u2014 mirrors `utils/coerceCellValue.ts` (Wave 3). */\nexport type CoerceReason = 'readOnly' | 'notCoercible' | 'notInSource';\nexport type CoerceResult = { ok: true; value: unknown } | { ok: false; reason: CoerceReason };\n/**\n * Turns a raw incoming value into something the column can store.\n * Injected rather than imported so this module stays free of the coercion\n * table: there must be exactly one of those, and it lives in\n * `utils/coerceCellValue.ts`. Omitted \u2192 values pass through untouched, which is\n * today's fill behaviour (same column in, same column out).\n */\nexport type CellValueCoercer = (value: unknown, column: ColumnDef) => CoerceResult;\n\n/** One requested cell mutation, addressed by loaded-page row + view column. */\nexport interface CellWrite {\n  row: number;\n  col: number;\n  value: unknown;\n}\n\n/** What happened to one requested cell. */\nexport interface CellWriteResult {\n  row: number;\n  col: number;\n  /** The column's field key, or `null` when the column index was out of range. */\n  prop: string | null;\n  status: 'written' | 'unchanged' | 'rejected';\n  /** Present only when `status === 'rejected'`. */\n  reason?: CellWriteRejectReason;\n  oldValue?: unknown;\n  /** The coerced value, i.e. what was actually handed to the save path. */\n  newValue?: unknown;\n}\n\nexport type CellWriteRejectionCounts = Record<CellWriteRejectReason, number>;\n\n/** The full, non-swallowed outcome of one multi-cell write. */\nexport interface CellWriteReport {\n  origin: CellWriteOrigin;\n  /** Writes handed in, before duplicate-cell collapsing. */\n  requested: number;\n  /** Cells whose value actually changed and were saved. */\n  written: number;\n  /** Cells already holding the requested value \u2014 cheap no-ops, not failures. */\n  unchanged: number;\n  /** One entry per refused cell, in request order. */\n  rejected: CellWriteResult[];\n  /** Rejection tally by reason, for a one-line report. */\n  rejectedByReason: CellWriteRejectionCounts;\n  /** Every cell's outcome, after duplicate-cell collapsing, in request order. */\n  results: CellWriteResult[];\n}\n\n/** The store surface this primitive needs \u2014 nothing more, so it is fakeable. */\nexport type CellWriteStore = Pick<\n  CellStore,\n  'getRowData' | 'getRowCount' | 'beginUndoGroup' | 'endUndoGroup'\n>;\n\nexport interface CellWriteDeps {\n  store: CellWriteStore;\n  /**\n   * The VIEW column order \u2014 `write.col` indexes this array.\n   *\n   * MUST be every visible column, in view order. NEVER a virtualization\n   * window: a write to an unmounted column is a normal write, not an\n   * out-of-range one. Bind a window here and a paste that straddles the\n   * viewport edge silently reports half its cells as `outOfRange`.\n   */\n  columns: ColumnDef[];\n  /** `createCellHandlers(...).handleCellSave`. Pass it as-is. */\n  handleCellSave: (row: number, col: number, value: unknown, clearEditing?: boolean) => void;\n  /** See `CellValueCoercer`. Defaults to pass-through. */\n  coerce?: CellValueCoercer;\n  /** The grid container, for the batch events. Omit to stay silent. */\n  element?: HTMLElement | null;\n  /** Field key holding the row's stable id, for the batch event payload. */\n  idColumnName?: string;\n}\n\nexport interface ApplyCellWritesOptions {\n  origin: CellWriteOrigin;\n  /**\n   * Treat `ColumnDef.disableFill` as read-only. `disableFill` is fill-specific\n   * (it excludes identity columns from the handle while leaving them normally\n   * editable), so it must NOT block a paste or a replace.\n   * Defaults to `origin === 'fill'`.\n   */\n  respectDisableFill?: boolean;\n}\n\n// ============================================\n// HELPERS\n// ============================================\n\nfunction emptyRejectionCounts(): CellWriteRejectionCounts {\n  return {\n    readOnly: 0,\n    notCoercible: 0,\n    notInSource: 0,\n    required: 0,\n    outOfRange: 0,\n  };\n}\n\n/**\n * The same unchanged test `handleCellSave` applies before it does anything.\n * Duplicated here (not re-derived) so the report can distinguish \"written\" from\n * \"already had that value\" \u2014 `handleCellSave` returns void and cannot tell us.\n */\nexport function isCellValueUnchanged(oldValue: unknown, newValue: unknown): boolean {\n  if (Array.isArray(oldValue) || Array.isArray(newValue)) {\n    return JSON.stringify(oldValue) === JSON.stringify(newValue);\n  }\n  return String(oldValue ?? '') === String(newValue ?? '');\n}\n\nfunction isEmptyValue(value: unknown): boolean {\n  return value === null || value === undefined || value === '';\n}\n\nconst passThroughCoercer: CellValueCoercer = (value) => ({ ok: true, value });\n\n/**\n * Collapse repeated writes to the same cell, last one wins, request order\n * preserved. Overlapping rectangles (a fill dragged back over a paste target,\n * a replace-all hitting one cell twice) must not produce two undo records for\n * one cell.\n */\nfunction dedupeWrites(writes: readonly CellWrite[]): CellWrite[] {\n  const byCell = new Map<string, number>();\n  const out: CellWrite[] = [];\n  for (const write of writes) {\n    const key = `${write.row}:${write.col}`;\n    const at = byCell.get(key);\n    if (at === undefined) {\n      byCell.set(key, out.length);\n      out.push(write);\n    } else {\n      out[at] = write;\n    }\n  }\n  return out;\n}\n\n// ============================================\n// THE PRIMITIVE\n// ============================================\n\n/**\n * Apply many cell writes as ONE undoable, reported batch.\n *\n * Rejected cells never reach `handleCellSave`, so they are never persisted and\n * never recorded for undo \u2014 an undo must not \"restore\" a value that was never\n * written.\n *\n * Unchanged cells cost nothing: `handleCellSave` returns early before both the\n * event and the undo record, so a batch that overwrites identical values pushes\n * no undo entry at all. That is correct \u2014 Ctrl+Z must not consume an entry for\n * a no-op.\n */\nexport function applyCellWrites(\n  deps: CellWriteDeps,\n  writes: readonly CellWrite[],\n  options: ApplyCellWritesOptions,\n): CellWriteReport {\n  const {\n    store,\n    columns,\n    handleCellSave,\n    coerce = passThroughCoercer,\n    element = null,\n    idColumnName = 'id',\n  } = deps;\n  const { origin } = options;\n  const respectDisableFill = options.respectDisableFill ?? origin === 'fill';\n\n  const requested = writes.length;\n  const deduped = dedupeWrites(writes);\n  const rowCount = store.getRowCount();\n\n  const results: CellWriteResult[] = [];\n  const accepted: Array<{\n    row: number;\n    col: number;\n    column: ColumnDef;\n    value: unknown;\n    oldValue: unknown;\n    rowData: any;\n    result: CellWriteResult;\n  }> = [];\n\n  for (const write of deduped) {\n    const { row, col } = write;\n    const column = columns[col];\n\n    if (!column || col < 0 || row < 0 || row >= rowCount) {\n      results.push({ row, col, prop: column?.data ?? null, status: 'rejected', reason: 'outOfRange' });\n      continue;\n    }\n\n    const prop = column.data;\n\n    if (column.readOnly || (respectDisableFill && column.disableFill)) {\n      results.push({ row, col, prop, status: 'rejected', reason: 'readOnly' });\n      continue;\n    }\n\n    const coerced = coerce(write.value, column);\n    if (!coerced.ok) {\n      // `readOnly` from the coercer collapses onto the same reason the column\n      // check produces \u2014 one reason per user-visible cause, not per code path.\n      results.push({ row, col, prop, status: 'rejected', reason: coerced.reason });\n      continue;\n    }\n    const value = coerced.value;\n\n    if (column.required === true && isEmptyValue(value)) {\n      results.push({ row, col, prop, status: 'rejected', reason: 'required' });\n      continue;\n    }\n\n    // Old values are read for the WHOLE batch before anything is written, so a\n    // batch that touches the same row twice still reports pre-batch values.\n    const rowData = store.getRowData(row);\n    const oldValue = rowData ? rowData[prop] : undefined;\n\n    if (isCellValueUnchanged(oldValue, value)) {\n      results.push({ row, col, prop, status: 'unchanged', oldValue, newValue: value });\n      continue;\n    }\n\n    const result: CellWriteResult = { row, col, prop, status: 'written', oldValue, newValue: value };\n    results.push(result);\n    accepted.push({ row, col, column, value, oldValue, rowData, result });\n  }\n\n  // ONE group around the ENTIRE batch. Opening a group per row or per column\n  // would produce one undo entry per row/column \u2014 an n-column fill would need\n  // n Ctrl+Z's. Nothing below this line may open another group.\n  if (accepted.length > 0) {\n    store.beginUndoGroup();\n    try {\n      for (const item of accepted) {\n        handleCellSave(item.row, item.col, item.value, false);\n      }\n    } finally {\n      store.endUndoGroup();\n    }\n  }\n\n  const rejected = results.filter((r) => r.status === 'rejected');\n  const rejectedByReason = emptyRejectionCounts();\n  for (const r of rejected) {\n    if (r.reason) rejectedByReason[r.reason] += 1;\n  }\n\n  const report: CellWriteReport = {\n    origin,\n    requested,\n    written: accepted.length,\n    unchanged: results.filter((r) => r.status === 'unchanged').length,\n    rejected,\n    rejectedByReason,\n    results,\n  };\n\n  if (element) {\n    // Additive to the per-cell `CELL_EDIT_SAVE`s `handleCellSave` already fired:\n    // consumers that ignore these two events keep working unchanged.\n    dispatch(element, CELL_BATCH_SAVE_EVENT, {\n      origin,\n      writes: accepted.map((item) => ({\n        rowIndex: item.row,\n        colIndex: item.col,\n        prop: item.column.data,\n        oldValue: item.oldValue,\n        newValue: item.value,\n        rowData: item.rowData,\n        id: item.rowData?.[idColumnName],\n      })),\n    });\n    dispatch(element, CELL_BATCH_SAVE_RESULT_EVENT, {\n      applied: report.written,\n      rejected: rejected.map((r) => ({ rowIndex: r.row, colIndex: r.col, reason: r.reason })),\n    });\n  }\n\n  return report;\n}\n\n/**\n * Bind the dependencies once and get the call shape every caller uses:\n * `write(writes, 'paste')`. Keeps `DynamicTable.tsx` free of the deps object\n * while there is still only ONE implementation underneath.\n */\nexport function createCellWriter(deps: CellWriteDeps) {\n  return function write(\n    writes: readonly CellWrite[],\n    origin: CellWriteOrigin | ApplyCellWritesOptions,\n  ): CellWriteReport {\n    const options = typeof origin === 'string' ? { origin } : origin;\n    return applyCellWrites(deps, writes, options);\n  };\n}\n"],
+  "mappings": "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",
+  "names": []
+}