@ai-matrx/design-system 0.22.0 → 0.25.0

package/dist/formulas/index.cjs

@@ -0,0 +1,1041 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/formulas/index.ts
+var formulas_exports = {};
+__export(formulas_exports, {
+  FORMULA_FUNCTIONS: () => FORMULA_FUNCTIONS,
+  evaluateFormula: () => evaluateFormula,
+  formulaColumnsOf: () => formulaColumnsOf,
+  formulaResultType: () => formulaResultType,
+  isFormulaColumn: () => isFormulaColumn,
+  parseFormula: () => parseFormula,
+  rewriteFormulaReferences: () => rewriteFormulaReferences,
+  withComputedColumns: () => withComputedColumns
+});
+module.exports = __toCommonJS(formulas_exports);
+
+// src/formulas/formulas.ts
+var FUNCTION_SPECS = {
+  SUM: {
+    signature: "SUM(number, \u2026)",
+    description: "Adds every value, ignoring empty ones.",
+    min: 1,
+    max: Infinity,
+    result: "number"
+  },
+  MIN: {
+    signature: "MIN(number, \u2026)",
+    description: "The smallest value, ignoring empty ones.",
+    min: 1,
+    max: Infinity,
+    result: "number"
+  },
+  MAX: {
+    signature: "MAX(number, \u2026)",
+    description: "The largest value, ignoring empty ones.",
+    min: 1,
+    max: Infinity,
+    result: "number"
+  },
+  AVERAGE: {
+    signature: "AVERAGE(number, \u2026)",
+    description: "The average of the values that are filled in. Empty values are not counted.",
+    min: 1,
+    max: Infinity,
+    result: "number"
+  },
+  ROUND: {
+    signature: "ROUND(number, places?)",
+    description: "Rounds to the given number of decimal places (0 when omitted). Halves round away from zero.",
+    min: 1,
+    max: 2,
+    result: "number"
+  },
+  ABS: {
+    signature: "ABS(number)",
+    description: "The value without its minus sign.",
+    min: 1,
+    max: 1,
+    result: "number"
+  },
+  LEN: {
+    signature: "LEN(text)",
+    description: "How many characters the text has.",
+    min: 1,
+    max: 1,
+    result: "number"
+  },
+  UPPER: {
+    signature: "UPPER(text)",
+    description: "The text in capitals.",
+    min: 1,
+    max: 1,
+    result: "text"
+  },
+  LOWER: {
+    signature: "LOWER(text)",
+    description: "The text in lower case.",
+    min: 1,
+    max: 1,
+    result: "text"
+  },
+  TRIM: {
+    signature: "TRIM(text)",
+    description: "The text without leading or trailing spaces.",
+    min: 1,
+    max: 1,
+    result: "text"
+  },
+  CONCATENATE: {
+    signature: "CONCATENATE(text, \u2026)",
+    description: "Joins every value into one piece of text.",
+    min: 1,
+    max: Infinity,
+    result: "text"
+  },
+  LEFT: {
+    signature: "LEFT(text, count)",
+    description: "The first few characters of the text.",
+    min: 2,
+    max: 2,
+    result: "text"
+  },
+  RIGHT: {
+    signature: "RIGHT(text, count)",
+    description: "The last few characters of the text.",
+    min: 2,
+    max: 2,
+    result: "text"
+  },
+  CONTAINS: {
+    signature: "CONTAINS(text, part)",
+    description: "Yes when the text contains that part. Upper and lower case are treated the same.",
+    min: 2,
+    max: 2,
+    result: "boolean"
+  },
+  IF: {
+    signature: "IF(condition, then, otherwise?)",
+    description: "The second value when the condition holds, otherwise the third (empty when omitted).",
+    min: 2,
+    max: 3,
+    result: "unknown"
+  },
+  AND: {
+    signature: "AND(condition, \u2026)",
+    description: "Yes when every condition holds.",
+    min: 1,
+    max: Infinity,
+    result: "boolean"
+  },
+  OR: {
+    signature: "OR(condition, \u2026)",
+    description: "Yes when at least one condition holds.",
+    min: 1,
+    max: Infinity,
+    result: "boolean"
+  },
+  NOT: {
+    signature: "NOT(condition)",
+    description: "Turns yes into no and no into yes.",
+    min: 1,
+    max: 1,
+    result: "boolean"
+  },
+  BLANK: {
+    signature: "BLANK()",
+    description: "An empty value, for comparing against or returning.",
+    min: 0,
+    max: 0,
+    result: "unknown"
+  },
+  ISBLANK: {
+    signature: "ISBLANK(value)",
+    description: "Yes when the value is empty.",
+    min: 1,
+    max: 1,
+    result: "boolean"
+  },
+  TODAY: {
+    signature: "TODAY()",
+    description: "Today's date.",
+    min: 0,
+    max: 0,
+    result: "date"
+  },
+  NOW: {
+    signature: "NOW()",
+    description: "The current date and time.",
+    min: 0,
+    max: 0,
+    result: "date"
+  },
+  DATEDIFF: {
+    signature: "DATEDIFF(from, to, 'days' | 'hours' | 'minutes')",
+    description: "How far the second date is after the first. Negative when it is earlier.",
+    min: 3,
+    max: 3,
+    result: "number"
+  },
+  YEAR: {
+    signature: "YEAR(date)",
+    description: "The four-digit year of the date.",
+    min: 1,
+    max: 1,
+    result: "number"
+  },
+  MONTH: {
+    signature: "MONTH(date)",
+    description: "The month of the date, 1 to 12.",
+    min: 1,
+    max: 1,
+    result: "number"
+  },
+  DAY: {
+    signature: "DAY(date)",
+    description: "The day of the month, 1 to 31.",
+    min: 1,
+    max: 1,
+    result: "number"
+  },
+  DATEADD: {
+    signature: "DATEADD(date, count, 'days' | 'months' | 'years')",
+    description: "The date moved forward by that many units. Use a negative count to go back.",
+    min: 3,
+    max: 3,
+    result: "date"
+  }
+};
+var FUNCTION_NAMES = Object.keys(FUNCTION_SPECS);
+var FORMULA_FUNCTIONS = Object.freeze(
+  FUNCTION_NAMES.map((name) => ({
+    name,
+    signature: FUNCTION_SPECS[name].signature,
+    description: FUNCTION_SPECS[name].description
+  }))
+);
+var FormulaError = class extends Error {
+  position;
+  constructor(message, position = 0) {
+    super(message);
+    this.name = "FormulaError";
+    this.position = position;
+  }
+};
+var TWO_CHAR_OPERATORS = ["!=", "<>", "<=", ">="];
+var ONE_CHAR_OPERATORS = ["+", "-", "*", "/", "%", "&", "=", "<", ">"];
+function isDigit(ch) {
+  return ch >= "0" && ch <= "9";
+}
+function isIdentifierStart(ch) {
+  return /[A-Za-z_]/.test(ch);
+}
+function isIdentifierPart(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 === void 0) break;
+    if (/\s/.test(ch)) {
+      i += 1;
+      continue;
+    }
+    if (ch === "{") {
+      const close = source.indexOf("}", i + 1);
+      if (close === -1) {
+        throw new FormulaError(
+          "This column reference is missing its closing brace `}`.",
+          i
+        );
+      }
+      const name = source.slice(i + 1, close).trim();
+      if (name === "") {
+        throw new FormulaError("This column reference has no name inside `{}`.", i);
+      }
+      tokens.push({ type: "reference", text: name, position: i });
+      i = close + 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      let j = i + 1;
+      let text = "";
+      let closed = false;
+      while (j < source.length) {
+        if (source[j] === "\\" && j + 1 < source.length) {
+          text += source[j + 1];
+          j += 2;
+          continue;
+        }
+        if (source[j] === quote) {
+          closed = true;
+          j += 1;
+          break;
+        }
+        text += source[j];
+        j += 1;
+      }
+      if (!closed) {
+        throw new FormulaError(
+          `This text is missing its closing ${quote === '"' ? "double" : "single"} quote.`,
+          i
+        );
+      }
+      tokens.push({ type: "string", text, position: i });
+      i = j;
+      continue;
+    }
+    if (isDigit(ch) || ch === "." && isDigit(source[i + 1] ?? "")) {
+      let j = i;
+      let seenDot = false;
+      while (j < source.length) {
+        if (isDigit(source[j] ?? "")) {
+          j += 1;
+          continue;
+        }
+        if (source[j] === "." && !seenDot) {
+          seenDot = true;
+          j += 1;
+          continue;
+        }
+        break;
+      }
+      tokens.push({ type: "number", text: source.slice(i, j), position: i });
+      i = j;
+      continue;
+    }
+    if (isIdentifierStart(ch)) {
+      let j = i;
+      while (j < source.length && isIdentifierPart(source[j] ?? "")) j += 1;
+      tokens.push({ type: "identifier", text: source.slice(i, j), position: i });
+      i = j;
+      continue;
+    }
+    if (ch === "(") {
+      tokens.push({ type: "paren-open", text: ch, position: i });
+      i += 1;
+      continue;
+    }
+    if (ch === ")") {
+      tokens.push({ type: "paren-close", text: ch, position: i });
+      i += 1;
+      continue;
+    }
+    if (ch === ",") {
+      tokens.push({ type: "comma", text: ch, position: i });
+      i += 1;
+      continue;
+    }
+    const two = source.slice(i, i + 2);
+    if (TWO_CHAR_OPERATORS.includes(two)) {
+      tokens.push({ type: "operator", text: two, position: i });
+      i += 2;
+      continue;
+    }
+    if (ONE_CHAR_OPERATORS.includes(ch)) {
+      tokens.push({ type: "operator", text: ch, position: i });
+      i += 1;
+      continue;
+    }
+    throw new FormulaError(`\`${ch}\` does not mean anything in a formula.`, i);
+  }
+  tokens.push({ type: "end", text: "", position: source.length });
+  return tokens;
+}
+var COMPARISON_OPERATORS = ["=", "!=", "<>", "<", "<=", ">", ">="];
+var Parser = class {
+  tokens;
+  index = 0;
+  references = [];
+  /**
+   * `tokenize` always terminates the list with an `end` token and the grammar
+   * never advances past it, so neither accessor below can actually run off the
+   * end. This sentinel is what they would return if one ever did, which keeps
+   * both accessors total without an assertion.
+   */
+  endToken;
+  constructor(tokens) {
+    this.tokens = tokens;
+    this.endToken = tokens[tokens.length - 1] ?? {
+      type: "end",
+      text: "",
+      position: 0
+    };
+  }
+  peek() {
+    return this.tokens[this.index] ?? this.endToken;
+  }
+  next() {
+    return this.tokens[this.index++] ?? this.endToken;
+  }
+  matchOperator(candidates) {
+    const token = this.peek();
+    if (token.type === "operator" && candidates.includes(token.text)) {
+      this.index += 1;
+      return token;
+    }
+    return null;
+  }
+  parseProgram() {
+    const expression = this.parseComparison();
+    const trailing = this.peek();
+    if (trailing.type !== "end") {
+      throw new FormulaError(
+        `Nothing should follow the formula here \u2014 remove \`${trailing.text}\`.`,
+        trailing.position
+      );
+    }
+    return expression;
+  }
+  parseComparison() {
+    let left = this.parseConcat();
+    let operator = this.matchOperator(COMPARISON_OPERATORS);
+    while (operator) {
+      const right = this.parseConcat();
+      left = {
+        kind: "binary",
+        operator: operator.text,
+        left,
+        right,
+        position: operator.position
+      };
+      operator = this.matchOperator(COMPARISON_OPERATORS);
+    }
+    return left;
+  }
+  parseConcat() {
+    let left = this.parseAdditive();
+    let operator = this.matchOperator(["&"]);
+    while (operator) {
+      const right = this.parseAdditive();
+      left = {
+        kind: "binary",
+        operator: "&",
+        left,
+        right,
+        position: operator.position
+      };
+      operator = this.matchOperator(["&"]);
+    }
+    return left;
+  }
+  parseAdditive() {
+    let left = this.parseMultiplicative();
+    let operator = this.matchOperator(["+", "-"]);
+    while (operator) {
+      const right = this.parseMultiplicative();
+      left = {
+        kind: "binary",
+        operator: operator.text,
+        left,
+        right,
+        position: operator.position
+      };
+      operator = this.matchOperator(["+", "-"]);
+    }
+    return left;
+  }
+  parseMultiplicative() {
+    let left = this.parseUnary();
+    let operator = this.matchOperator(["*", "/", "%"]);
+    while (operator) {
+      const right = this.parseUnary();
+      left = {
+        kind: "binary",
+        operator: operator.text,
+        left,
+        right,
+        position: operator.position
+      };
+      operator = this.matchOperator(["*", "/", "%"]);
+    }
+    return left;
+  }
+  parseUnary() {
+    const minus = this.matchOperator(["-"]);
+    if (minus) {
+      return {
+        kind: "unary",
+        operator: "-",
+        operand: this.parseUnary(),
+        position: minus.position
+      };
+    }
+    const plus = this.matchOperator(["+"]);
+    if (plus) return this.parseUnary();
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    const token = this.next();
+    if (token.type === "number") {
+      return { kind: "number", value: Number(token.text), position: token.position };
+    }
+    if (token.type === "string") {
+      return { kind: "string", value: token.text, position: token.position };
+    }
+    if (token.type === "reference") {
+      if (!this.references.includes(token.text)) this.references.push(token.text);
+      return { kind: "reference", name: token.text, position: token.position };
+    }
+    if (token.type === "paren-open") {
+      const inner = this.parseComparison();
+      const close = this.next();
+      if (close.type !== "paren-close") {
+        throw new FormulaError(
+          "This opening bracket `(` never closes.",
+          token.position
+        );
+      }
+      return inner;
+    }
+    if (token.type === "identifier") {
+      const upper = token.text.toUpperCase();
+      if (upper === "TRUE" || upper === "FALSE") {
+        return {
+          kind: "boolean",
+          value: upper === "TRUE",
+          position: token.position
+        };
+      }
+      if (!FUNCTION_NAMES.includes(upper)) {
+        throw new FormulaError(
+          `There is no function called \`${token.text}\`. A column goes in braces, like {${token.text}}.`,
+          token.position
+        );
+      }
+      const name = upper;
+      const open = this.next();
+      if (open.type !== "paren-open") {
+        throw new FormulaError(
+          `\`${name}\` needs brackets after it, like ${FUNCTION_SPECS[name].signature}.`,
+          token.position
+        );
+      }
+      const args = [];
+      if (this.peek().type === "paren-close") {
+        this.index += 1;
+      } else {
+        for (; ; ) {
+          args.push(this.parseComparison());
+          const separator = this.next();
+          if (separator.type === "comma") continue;
+          if (separator.type === "paren-close") break;
+          throw new FormulaError(
+            `\`${name}\` is missing a comma or its closing bracket.`,
+            separator.position
+          );
+        }
+      }
+      const spec = FUNCTION_SPECS[name];
+      if (args.length < spec.min || args.length > spec.max) {
+        throw new FormulaError(
+          `\`${name}\` was given ${args.length} value${args.length === 1 ? "" : "s"}. Use ${spec.signature}.`,
+          token.position
+        );
+      }
+      return { kind: "call", name, args, position: token.position };
+    }
+    if (token.type === "end") {
+      throw new FormulaError("The formula stops before it is finished.", token.position);
+    }
+    throw new FormulaError(
+      `\`${token.text}\` cannot start a value here.`,
+      token.position
+    );
+  }
+};
+function parseFormula(source) {
+  try {
+    const text = source ?? "";
+    if (text.trim() === "") {
+      return { ok: false, error: "This formula is empty.", position: 0 };
+    }
+    const parser = new Parser(tokenize(text));
+    const ast = parser.parseProgram();
+    return { ok: true, ast, references: parser.references };
+  } catch (error) {
+    if (error instanceof FormulaError) {
+      return { ok: false, error: error.message, position: error.position };
+    }
+    return {
+      ok: false,
+      error: "This formula could not be read.",
+      position: 0
+    };
+  }
+}
+var MISSING = /* @__PURE__ */ Symbol("missing-column");
+function isBlank(value) {
+  return value === null || value === "";
+}
+function numberToText(n) {
+  if (Number.isInteger(n)) return String(n);
+  const trimmed = Number(n.toPrecision(15));
+  return String(Number.isFinite(trimmed) ? trimmed : n);
+}
+function toText(value) {
+  if (value === null) return "";
+  if (typeof value === "number") return numberToText(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  return value;
+}
+function looseNumber(value) {
+  if (value === null || value === "") return 0;
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "boolean") return value ? 1 : 0;
+  const cleaned = value.replace(/[,\s$€£¥%]/g, "");
+  if (cleaned === "") return 0;
+  const n = Number(cleaned);
+  return Number.isFinite(n) ? n : null;
+}
+function requireNumber(value, what) {
+  const n = looseNumber(value);
+  if (n === null) {
+    throw new FormulaError(`${what} needs a number, but got "${toText(value)}".`);
+  }
+  return n;
+}
+function truthy(value) {
+  if (value === null || value === "") return false;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  return true;
+}
+function compareValues(left, right) {
+  const looksNumeric = (v) => typeof v === "number" || typeof v === "string" && v.trim() !== "" && looseNumber(v) !== null;
+  if (isBlank(left) && isBlank(right)) return 0;
+  const blankBesideNumber = isBlank(left) && looksNumeric(right) || isBlank(right) && looksNumeric(left);
+  if (blankBesideNumber || looksNumeric(left) && looksNumeric(right)) {
+    const a2 = looseNumber(left) ?? 0;
+    const b2 = looseNumber(right) ?? 0;
+    return a2 < b2 ? -1 : a2 > b2 ? 1 : 0;
+  }
+  if (typeof left === "boolean" || typeof right === "boolean") {
+    const a2 = truthy(left);
+    const b2 = truthy(right);
+    return a2 === b2 ? 0 : a2 ? 1 : -1;
+  }
+  const a = toText(left);
+  const b = toText(right);
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+var DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+function requireDate(value, what) {
+  if (value === null || value === "") {
+    throw new FormulaError(`${what} needs a date, but that value is empty.`);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    const ms = Date.parse(trimmed);
+    if (!Number.isNaN(ms)) return { ms, dateOnly: DATE_ONLY_RE.test(trimmed) };
+  }
+  throw new FormulaError(`${what} needs a date, but got "${toText(value)}".`);
+}
+function isoFrom(ms, dateOnly) {
+  const iso = new Date(ms).toISOString();
+  return dateOnly ? iso.slice(0, 10) : iso;
+}
+var DATEDIFF_UNITS = {
+  days: 864e5,
+  hours: 36e5,
+  minutes: 6e4
+};
+function requireUnit(value, allowed, fn) {
+  const unit = toText(value).trim().toLowerCase();
+  if (!allowed.includes(unit)) {
+    throw new FormulaError(
+      `\`${fn}\` needs one of ${allowed.map((u) => `'${u}'`).join(", ")} \u2014 got "${toText(value)}".`
+    );
+  }
+  return unit;
+}
+function addMonths(ms, count) {
+  const d = new Date(ms);
+  const day = d.getUTCDate();
+  const target = new Date(ms);
+  target.setUTCDate(1);
+  target.setUTCMonth(target.getUTCMonth() + count);
+  const lastDay = new Date(
+    Date.UTC(target.getUTCFullYear(), target.getUTCMonth() + 1, 0)
+  ).getUTCDate();
+  target.setUTCDate(Math.min(day, lastDay));
+  return target.getTime();
+}
+function numericArgs(values, fn) {
+  const out = [];
+  for (const value of values) {
+    if (isBlank(value)) continue;
+    out.push(requireNumber(value, `\`${fn}\``));
+  }
+  return out;
+}
+function roundHalfAway(n, places) {
+  const factor = 10 ** places;
+  const scaled = n * factor;
+  const corrected = Number(scaled.toPrecision(15));
+  const rounded = corrected < 0 ? -Math.round(-corrected) : Math.round(corrected);
+  return rounded / factor;
+}
+function argAt(args, index) {
+  return args[index] ?? null;
+}
+function callFunction(name, args) {
+  switch (name) {
+    case "SUM":
+      return numericArgs(args, "SUM").reduce((a, b) => a + b, 0);
+    case "MIN": {
+      const nums = numericArgs(args, "MIN");
+      return nums.length === 0 ? null : Math.min(...nums);
+    }
+    case "MAX": {
+      const nums = numericArgs(args, "MAX");
+      return nums.length === 0 ? null : Math.max(...nums);
+    }
+    case "AVERAGE": {
+      const nums = numericArgs(args, "AVERAGE");
+      if (nums.length === 0) return null;
+      return nums.reduce((a, b) => a + b, 0) / nums.length;
+    }
+    case "ROUND": {
+      const n = requireNumber(argAt(args, 0), "`ROUND`");
+      const places = args.length > 1 ? Math.trunc(requireNumber(argAt(args, 1), "`ROUND`")) : 0;
+      return roundHalfAway(n, places);
+    }
+    case "ABS":
+      return Math.abs(requireNumber(argAt(args, 0), "`ABS`"));
+    case "LEN":
+      return toText(argAt(args, 0)).length;
+    case "UPPER":
+      return toText(argAt(args, 0)).toUpperCase();
+    case "LOWER":
+      return toText(argAt(args, 0)).toLowerCase();
+    case "TRIM":
+      return toText(argAt(args, 0)).trim();
+    case "CONCATENATE":
+      return args.map(toText).join("");
+    case "LEFT": {
+      const count = Math.trunc(requireNumber(argAt(args, 1), "`LEFT`"));
+      return toText(argAt(args, 0)).slice(0, Math.max(0, count));
+    }
+    case "RIGHT": {
+      const count = Math.trunc(requireNumber(argAt(args, 1), "`RIGHT`"));
+      if (count <= 0) return "";
+      return toText(argAt(args, 0)).slice(-count);
+    }
+    case "CONTAINS":
+      return toText(argAt(args, 0)).toLowerCase().includes(toText(argAt(args, 1)).toLowerCase());
+    case "NOT":
+      return !truthy(argAt(args, 0));
+    case "BLANK":
+      return null;
+    case "ISBLANK":
+      return isBlank(argAt(args, 0));
+    case "TODAY":
+      return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    case "NOW":
+      return (/* @__PURE__ */ new Date()).toISOString();
+    case "DATEDIFF": {
+      const from = requireDate(argAt(args, 0), "`DATEDIFF`");
+      const to = requireDate(argAt(args, 1), "`DATEDIFF`");
+      const unit = requireUnit(argAt(args, 2), Object.keys(DATEDIFF_UNITS), "DATEDIFF");
+      const perUnit = DATEDIFF_UNITS[unit];
+      if (perUnit === void 0) return null;
+      return Math.trunc((to.ms - from.ms) / perUnit);
+    }
+    case "YEAR":
+      return new Date(requireDate(argAt(args, 0), "`YEAR`").ms).getUTCFullYear();
+    case "MONTH":
+      return new Date(requireDate(argAt(args, 0), "`MONTH`").ms).getUTCMonth() + 1;
+    case "DAY":
+      return new Date(requireDate(argAt(args, 0), "`DAY`").ms).getUTCDate();
+    case "DATEADD": {
+      const base = requireDate(argAt(args, 0), "`DATEADD`");
+      const count = Math.trunc(requireNumber(argAt(args, 1), "`DATEADD`"));
+      const unit = requireUnit(argAt(args, 2), ["days", "months", "years"], "DATEADD");
+      const ms = unit === "days" ? base.ms + count * 864e5 : addMonths(base.ms, unit === "months" ? count : count * 12);
+      return isoFrom(ms, base.dateOnly);
+    }
+    // IF / AND / OR short-circuit in `evaluateNode` and never reach here.
+    case "IF":
+    case "AND":
+    case "OR":
+      throw new FormulaError(`\`${name}\` could not be evaluated.`);
+  }
+}
+function applyBinary(operator, left, right) {
+  switch (operator) {
+    case "&":
+      return toText(left) + toText(right);
+    case "+":
+      return requireNumber(left, "`+`") + requireNumber(right, "`+`");
+    case "-":
+      return requireNumber(left, "`-`") - requireNumber(right, "`-`");
+    case "*":
+      return requireNumber(left, "`*`") * requireNumber(right, "`*`");
+    case "/": {
+      const divisor = requireNumber(right, "`/`");
+      if (divisor === 0) {
+        throw new FormulaError("This formula divides by zero.");
+      }
+      return requireNumber(left, "`/`") / divisor;
+    }
+    case "%": {
+      const divisor = requireNumber(right, "`%`");
+      if (divisor === 0) {
+        throw new FormulaError("This formula divides by zero.");
+      }
+      return requireNumber(left, "`%`") % divisor;
+    }
+    case "=":
+      return compareValues(left, right) === 0;
+    case "!=":
+    case "<>":
+      return compareValues(left, right) !== 0;
+    case "<":
+      return compareValues(left, right) < 0;
+    case "<=":
+      return compareValues(left, right) <= 0;
+    case ">":
+      return compareValues(left, right) > 0;
+    case ">=":
+      return compareValues(left, right) >= 0;
+  }
+}
+function normalizeCell(raw, name) {
+  if (raw === MISSING) {
+    throw new FormulaError(`There is no column called {${name}}.`);
+  }
+  if (raw === null || raw === void 0) return null;
+  if (typeof raw === "string" || typeof raw === "boolean") return raw;
+  if (typeof raw === "number") {
+    if (!Number.isFinite(raw)) {
+      throw new FormulaError(`The value in {${name}} is not a usable number.`);
+    }
+    return raw;
+  }
+  if (raw instanceof Date) {
+    return Number.isNaN(raw.getTime()) ? null : raw.toISOString();
+  }
+  try {
+    return JSON.stringify(raw);
+  } catch {
+    return String(raw);
+  }
+}
+function evaluateNode(node, resolve) {
+  switch (node.kind) {
+    case "number":
+    case "string":
+    case "boolean":
+      return node.value;
+    case "reference": {
+      const raw = resolve(node.name);
+      return normalizeCell(raw === void 0 ? MISSING : raw, node.name);
+    }
+    case "unary":
+      return -requireNumber(evaluateNode(node.operand, resolve), "`-`");
+    case "binary":
+      return applyBinary(
+        node.operator,
+        evaluateNode(node.left, resolve),
+        evaluateNode(node.right, resolve)
+      );
+    case "call": {
+      if (node.name === "IF") {
+        const test = node.args[0];
+        const whenTrue = node.args[1];
+        const condition = truthy(test ? evaluateNode(test, resolve) : null);
+        if (condition) return whenTrue ? evaluateNode(whenTrue, resolve) : null;
+        const whenFalse = node.args[2];
+        return node.args.length > 2 && whenFalse ? evaluateNode(whenFalse, resolve) : null;
+      }
+      if (node.name === "AND") {
+        for (const arg of node.args) {
+          if (!truthy(evaluateNode(arg, resolve))) return false;
+        }
+        return true;
+      }
+      if (node.name === "OR") {
+        for (const arg of node.args) {
+          if (truthy(evaluateNode(arg, resolve))) return true;
+        }
+        return false;
+      }
+      return callFunction(
+        node.name,
+        node.args.map((arg) => evaluateNode(arg, resolve))
+      );
+    }
+  }
+}
+function evaluateFormula(ast, resolve) {
+  try {
+    const value = evaluateNode(ast, resolve);
+    if (typeof value === "number" && !Number.isFinite(value)) {
+      return { ok: false, error: "This formula produced a number too large to show." };
+    }
+    return { ok: true, value };
+  } catch (error) {
+    if (error instanceof FormulaError) return { ok: false, error: error.message };
+    return { ok: false, error: "This formula could not be calculated." };
+  }
+}
+function formulaResultType(ast, columnType) {
+  switch (ast.kind) {
+    case "number":
+      return "number";
+    case "string":
+      return "text";
+    case "boolean":
+      return "boolean";
+    case "unary":
+      return "number";
+    case "reference":
+      return columnType(ast.name) ?? "unknown";
+    case "binary": {
+      if (ast.operator === "&") return "text";
+      if (COMPARISON_OPERATORS.includes(ast.operator)) return "boolean";
+      return "number";
+    }
+    case "call": {
+      if (ast.name === "IF") {
+        const thenArg = ast.args[1];
+        const then = thenArg ? formulaResultType(thenArg, columnType) : "unknown";
+        const otherwiseArg = ast.args[2];
+        if (ast.args.length < 3 || !otherwiseArg) return then;
+        const otherwise = formulaResultType(otherwiseArg, columnType);
+        if (then === otherwise) return then;
+        if (then === "unknown") return otherwise;
+        if (otherwise === "unknown") return then;
+        return "unknown";
+      }
+      if (ast.name === "MIN" || ast.name === "MAX") {
+        const types = ast.args.map((a) => formulaResultType(a, columnType));
+        if (types.length > 0 && types.every((t) => t === "date")) return "date";
+        return "number";
+      }
+      return FUNCTION_SPECS[ast.name].result;
+    }
+  }
+}
+function formulaExpressionOf(field) {
+  const metadata = field.metadata;
+  if (!metadata || typeof metadata !== "object") return null;
+  const format = metadata.format;
+  if (!format || typeof format !== "object") return null;
+  if (format.id !== "formula") return null;
+  const options = format.options;
+  const formula = options && typeof options === "object" ? options.formula : void 0;
+  const expression = formula && typeof formula === "object" ? formula.expression : void 0;
+  return typeof expression === "string" ? expression : "";
+}
+function isFormulaColumn(field) {
+  return formulaExpressionOf(field) !== null;
+}
+function formulaColumnsOf(fields) {
+  return fields.flatMap((field) => {
+    const expression = formulaExpressionOf(field);
+    if (expression === null) return [];
+    return [{ field, parsed: parseFormula(expression) }];
+  });
+}
+function withComputedColumns(rows, fields) {
+  const columns = formulaColumnsOf(fields);
+  const formulaFieldNames = new Set(columns.map((c) => c.field.field_name));
+  const errors = /* @__PURE__ */ new Map();
+  if (columns.length === 0) {
+    return { rows, errors, formulaFieldNames };
+  }
+  const fieldNameByReference = /* @__PURE__ */ new Map();
+  for (const f of fields) {
+    fieldNameByReference.set(f.display_name.toLowerCase(), f.field_name);
+  }
+  for (const f of fields) {
+    fieldNameByReference.set(f.field_name.toLowerCase(), f.field_name);
+  }
+  const computed = rows.map((row) => {
+    const data = { ...row.data ?? {} };
+    const resolve = (name) => {
+      if (name in data) return data[name];
+      const fieldName = fieldNameByReference.get(name.toLowerCase());
+      if (fieldName === void 0) return void 0;
+      return data[fieldName] ?? null;
+    };
+    for (const { field, parsed } of columns) {
+      if (!parsed.ok) {
+        data[field.field_name] = null;
+        errors.set(`${row.id}::${field.field_name}`, parsed.error);
+        continue;
+      }
+      const result = evaluateFormula(parsed.ast, resolve);
+      if (result.ok) data[field.field_name] = result.value;
+      else {
+        data[field.field_name] = null;
+        errors.set(`${row.id}::${field.field_name}`, result.error);
+      }
+    }
+    return { ...row, data };
+  });
+  return { rows: computed, errors, formulaFieldNames };
+}
+function rewriteFormulaReferences(expression, from, to) {
+  const target = from.trim().toLowerCase();
+  if (!target) return expression;
+  let out = "";
+  let i = 0;
+  while (i < expression.length) {
+    const ch = expression[i];
+    if (ch === '"' || ch === "'") {
+      let j = i + 1;
+      while (j < expression.length) {
+        if (expression[j] === "\\" && j + 1 < expression.length) {
+          j += 2;
+          continue;
+        }
+        if (expression[j] === ch) {
+          j += 1;
+          break;
+        }
+        j += 1;
+      }
+      out += expression.slice(i, j);
+      i = j;
+      continue;
+    }
+    if (ch === "{") {
+      const close = expression.indexOf("}", i + 1);
+      if (close === -1) {
+        out += expression.slice(i);
+        break;
+      }
+      const name = expression.slice(i + 1, close);
+      out += name.trim().toLowerCase() === target ? `{${to}}` : expression.slice(i, close + 1);
+      i = close + 1;
+      continue;
+    }
+    out += ch;
+    i += 1;
+  }
+  return out;
+}
+//# sourceMappingURL=index.cjs.map