@adminide-stack/yantra-mobile 12.0.140 → 12.0.141

package/lib/features/notion/database/databaseFormula.js

@@ -0,0 +1,1072 @@
+import {baseCellValue,richTextToPlain,cellDisplayText,multiSelectNames,connectorCellValue,numberValue,dateString}from'./databaseView.js';var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class FormulaError extends Error {
+}
+class FormulaCycleError extends Error {
+}
+const MAX_SOURCE = 2e3;
+const MAX_NESTING = 64;
+const OPERATORS = ["==", "!=", ">=", "<=", "&&", "||", "+", "-", "*", "/", "%", "^", ">", "<", "!", "="];
+function tokenize(src) {
+  var _a;
+  const out = [];
+  let i = 0;
+  while (i < src.length) {
+    const ch = src[i];
+    if (/\s/.test(ch)) {
+      i += 1;
+      continue;
+    }
+    if (/[0-9]/.test(ch) || ch === "." && /[0-9]/.test((_a = src[i + 1]) != null ? _a : "")) {
+      const m = /^(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/.exec(src.slice(i));
+      if (!m) throw new FormulaError(`Unexpected "${ch}" at ${i + 1}`);
+      out.push({
+        t: "num",
+        v: Number(m[0]),
+        pos: i
+      });
+      i += m[0].length;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      let j = i + 1;
+      let text2 = "";
+      while (j < src.length && src[j] !== ch) {
+        if (src[j] === "\\" && j + 1 < src.length) {
+          const next = src[j + 1];
+          text2 += next === "n" ? "\n" : next === "t" ? "	" : next;
+          j += 2;
+        } else {
+          text2 += src[j];
+          j += 1;
+        }
+      }
+      if (j >= src.length) throw new FormulaError("Missing closing quote");
+      out.push({
+        t: "str",
+        v: text2,
+        pos: i
+      });
+      i = j + 1;
+      continue;
+    }
+    if (/[A-Za-z_]/.test(ch)) {
+      const m = /^[A-Za-z_][A-Za-z0-9_]*/.exec(src.slice(i));
+      out.push({
+        t: "id",
+        v: m[0],
+        pos: i
+      });
+      i += m[0].length;
+      continue;
+    }
+    if (ch === "(" || ch === ")" || ch === "," || ch === "[" || ch === "]" || ch === ".") {
+      out.push({
+        t: ch,
+        pos: i
+      });
+      i += 1;
+      continue;
+    }
+    const op = OPERATORS.find((o) => src.startsWith(o, i));
+    if (op) {
+      out.push({
+        t: "op",
+        v: op === "=" ? "==" : op,
+        pos: i
+      });
+      i += op.length;
+      continue;
+    }
+    throw new FormulaError(`Unexpected "${ch}" at ${i + 1}`);
+  }
+  out.push({
+    t: "eof",
+    pos: src.length
+  });
+  return out;
+}
+const BINARY_BP = {
+  or: 1,
+  and: 2,
+  "==": 3,
+  "!=": 3,
+  ">": 4,
+  "<": 4,
+  ">=": 4,
+  "<=": 4,
+  "+": 5,
+  "-": 5,
+  "*": 6,
+  "/": 6,
+  "%": 6,
+  "^": 7
+};
+const FUNCTIONS = {
+  if: [3, 3],
+  concat: [1, 50],
+  length: [1, 1],
+  lower: [1, 1],
+  upper: [1, 1],
+  contains: [2, 2],
+  empty: [1, 1],
+  format: [1, 1],
+  tonumber: [1, 1],
+  round: [1, 2],
+  floor: [1, 1],
+  ceil: [1, 1],
+  abs: [1, 1],
+  sqrt: [1, 1],
+  min: [1, 50],
+  max: [1, 50],
+  now: [0, 0],
+  today: [0, 0],
+  datebetween: [3, 3],
+  dateadd: [3, 3],
+  not: [1, 1],
+  and: [2, 50],
+  or: [2, 50],
+  // Formula 2.0
+  ifs: [3, 51],
+  map: [2, 2],
+  filter: [2, 2],
+  find: [2, 2],
+  some: [2, 2],
+  every: [2, 2],
+  join: [1, 2],
+  at: [2, 2],
+  first: [1, 1],
+  last: [1, 1],
+  sum: [1, 50],
+  average: [1, 50],
+  median: [1, 50],
+  sort: [1, 1],
+  reverse: [1, 1],
+  unique: [1, 1],
+  includes: [2, 2],
+  slice: [2, 3],
+  split: [2, 2],
+  trim: [1, 1],
+  replace: [3, 3],
+  replaceall: [3, 3],
+  substring: [2, 3],
+  repeat: [2, 2],
+  startswith: [2, 2],
+  endswith: [2, 2],
+  padstart: [2, 3],
+  formatdate: [2, 2],
+  parsedate: [1, 1],
+  year: [1, 1],
+  month: [1, 1],
+  date: [1, 1],
+  day: [1, 1],
+  week: [1, 1],
+  hour: [1, 1],
+  minute: [1, 1],
+  timestamp: [1, 1],
+  tostring: [1, 1]
+};
+const LIST_LAMBDAS = /* @__PURE__ */ new Set(["map", "filter", "find", "some", "every"]);
+class Parser {
+  constructor(tokens) {
+    this.tokens = tokens;
+    __publicField(this, "i", 0);
+    __publicField(this, "depth", 0);
+    __publicField(this, "refs", /* @__PURE__ */ new Set());
+    /** Names in scope: let / lets variables, `current` / `index` inside map() & co. */
+    __publicField(this, "scopes", []);
+  }
+  inScope(name) {
+    return this.scopes.some((s) => s.includes(name));
+  }
+  withScope(names, fn) {
+    this.scopes.push(names);
+    try {
+      return fn();
+    } finally {
+      this.scopes.pop();
+    }
+  }
+  peekAt(offset) {
+    return this.tokens[Math.min(this.i + offset, this.tokens.length - 1)];
+  }
+  /** `x.f(a)` → f(x, a); repeated for chains. */
+  parsePostfix(node) {
+    let out = node;
+    while (this.peek().t === ".") {
+      const dot = this.next();
+      const name = this.next();
+      if (name.t !== "id") throw new FormulaError(`Expected a function name after "." at ${dot.pos + 1}`);
+      this.expect("(", `"(" after .${name.v}`);
+      out = this.parseCallRest(name.v, out);
+    }
+    return out;
+  }
+  parseArgList() {
+    const args = [];
+    if (this.peek().t !== ")") {
+      for (; ; ) {
+        args.push(this.parseExpr(0));
+        if (this.peek().t === ",") {
+          this.next();
+          continue;
+        }
+        break;
+      }
+    }
+    return args;
+  }
+  /** After `name(` (and an optional receiver from `x.name(`): the arguments and `)`. */
+  parseCallRest(word, receiver) {
+    const lower = word.toLowerCase();
+    if (lower === "let" || lower === "lets") {
+      if (receiver) throw new FormulaError(`${word}() can't be chained`);
+      const names = [];
+      const values = [];
+      for (; ; ) {
+        const id = this.next();
+        if (id.t !== "id") throw new FormulaError(`${word}() needs a variable name, e.g. let(x, 1, x + 1)`);
+        this.expect(",", `"," after ${id.v}`);
+        values.push(this.withScope(names.slice(), () => this.parseExpr(0)));
+        names.push(id.v);
+        this.expect(",", `"," in ${word}()`);
+        const more = lower === "lets" && this.peek().t === "id" && this.peekAt(1).t === "," && this.peekAt(1) !== void 0;
+        if (!more) break;
+      }
+      const body = this.withScope(names, () => this.parseExpr(0));
+      this.expect(")", `")" to close ${word}(`);
+      return {
+        k: "let",
+        names,
+        values,
+        body
+      };
+    }
+    let args;
+    if (LIST_LAMBDAS.has(lower)) {
+      const list2 = receiver != null ? receiver : this.parseExpr(0);
+      if (!receiver) this.expect(",", `"," in ${word}()`);
+      const fn = this.withScope(["current", "index"], () => this.parseExpr(0));
+      args = [list2, fn];
+    } else {
+      args = this.parseArgList();
+      if (receiver) args = [receiver, ...args];
+    }
+    this.expect(")", `")" to close ${word}(`);
+    if (lower === "prop") {
+      const a = args[0];
+      if (receiver || args.length !== 1 || a.k !== "lit" || typeof a.v !== "string") {
+        throw new FormulaError('prop() takes one property name in quotes, e.g. prop("Price")');
+      }
+      this.refs.add(a.v);
+      return {
+        k: "prop",
+        name: a.v
+      };
+    }
+    const arity = FUNCTIONS[lower];
+    if (!arity) throw new FormulaError(`Unknown function "${word}"`);
+    if (args.length < arity[0] || args.length > arity[1]) {
+      const want = arity[0] === arity[1] ? `${arity[0]}` : `${arity[0]}\u2013${arity[1]}`;
+      throw new FormulaError(`${word}() takes ${want} argument${arity[1] === 1 ? "" : "s"}`);
+    }
+    return {
+      k: "call",
+      name: lower,
+      args
+    };
+  }
+  peek() {
+    return this.tokens[this.i];
+  }
+  next() {
+    return this.tokens[this.i++];
+  }
+  expect(t, what) {
+    const tok = this.next();
+    if (tok.t !== t) throw new FormulaError(`Expected ${what} at ${tok.pos + 1}`);
+    return tok;
+  }
+  /** Binary operator name of a token (`&&` → and), or null. */
+  binaryOp(tok) {
+    if (tok.t === "op") {
+      if (tok.v === "&&") return "and";
+      if (tok.v === "||") return "or";
+      return tok.v in BINARY_BP ? tok.v : null;
+    }
+    if (tok.t === "id" && (tok.v === "and" || tok.v === "or")) return tok.v;
+    return null;
+  }
+  parseAll() {
+    if (this.peek().t === "eof") throw new FormulaError("Formula is empty");
+    const node = this.parseExpr(0);
+    const tok = this.peek();
+    if (tok.t !== "eof") throw new FormulaError(`Unexpected ${describe(tok)} at ${tok.pos + 1}`);
+    return node;
+  }
+  parseExpr(minBp) {
+    if (++this.depth > MAX_NESTING) throw new FormulaError("Formula is nested too deeply");
+    let left = this.parsePrefix();
+    for (; ; ) {
+      const op = this.binaryOp(this.peek());
+      if (!op) break;
+      const bp = BINARY_BP[op];
+      if (bp <= minBp) break;
+      this.next();
+      const right = this.parseExpr(op === "^" ? bp - 1 : bp);
+      left = {
+        k: "bin",
+        op,
+        l: left,
+        r: right
+      };
+    }
+    this.depth -= 1;
+    return left;
+  }
+  parsePrefix() {
+    return this.parsePostfix(this.parsePrimary());
+  }
+  parsePrimary() {
+    const tok = this.next();
+    switch (tok.t) {
+      case "num":
+        return {
+          k: "lit",
+          v: tok.v
+        };
+      case "str":
+        return {
+          k: "lit",
+          v: tok.v
+        };
+      case "(": {
+        const inner = this.parseExpr(0);
+        this.expect(")", '")"');
+        return inner;
+      }
+      case "[": {
+        const items = [];
+        if (this.peek().t !== "]") {
+          for (; ; ) {
+            items.push(this.parseExpr(0));
+            if (this.peek().t === ",") {
+              this.next();
+              continue;
+            }
+            break;
+          }
+        }
+        this.expect("]", '"]" to close the list');
+        return {
+          k: "list",
+          items
+        };
+      }
+      case "op":
+        if (tok.v === "-") return {
+          k: "unary",
+          op: "-",
+          arg: this.parseExpr(6)
+        };
+        if (tok.v === "+") return this.parseExpr(6);
+        if (tok.v === "!") return {
+          k: "unary",
+          op: "not",
+          arg: this.parseExpr(2)
+        };
+        throw new FormulaError(`Unexpected "${tok.v}" at ${tok.pos + 1}`);
+      case "id": {
+        const word = tok.v;
+        const lower = word.toLowerCase();
+        if (lower === "true" || lower === "false") return {
+          k: "lit",
+          v: lower === "true"
+        };
+        if (lower === "not" && this.peek().t !== "(") {
+          return {
+            k: "unary",
+            op: "not",
+            arg: this.parseExpr(2)
+          };
+        }
+        if (this.peek().t !== "(") {
+          if (this.inScope(word)) return {
+            k: "var",
+            name: word
+          };
+          throw new FormulaError(`Unknown name "${word}" \u2014 use prop("${word}")`);
+        }
+        this.next();
+        return this.parseCallRest(word);
+      }
+      case ")":
+        throw new FormulaError(`Unexpected ")" at ${tok.pos + 1}`);
+      case ",":
+        throw new FormulaError(`Unexpected "," at ${tok.pos + 1}`);
+      case "]":
+      case ".":
+        throw new FormulaError(`Unexpected "${tok.t}" at ${tok.pos + 1}`);
+      default:
+        throw new FormulaError("Formula ended unexpectedly");
+    }
+  }
+}
+function describe(tok) {
+  if (tok.t === "num" || tok.t === "id") return `"${tok.v}"`;
+  if (tok.t === "str") return "text";
+  if (tok.t === "op") return `"${tok.v}"`;
+  if (tok.t === "eof") return "end";
+  return `"${tok.t}"`;
+}
+function compileFormula(source, opts = {}) {
+  try {
+    if ((source != null ? source : "").length > MAX_SOURCE) throw new FormulaError("Formula is too long");
+    const parser = new Parser(tokenize(source != null ? source : ""));
+    const ast = parser.parseAll();
+    const refs = [...parser.refs];
+    if (opts.self && refs.includes(opts.self)) throw new FormulaError("A formula cannot reference itself");
+    if (opts.properties) {
+      const missing = refs.find((r) => !opts.properties.includes(r));
+      if (missing) throw new FormulaError(`Unknown property "${missing}"`);
+    }
+    return {
+      ok: true,
+      ast,
+      refs
+    };
+  } catch (e) {
+    if (e instanceof FormulaError) return {
+      ok: false,
+      error: e.message
+    };
+    throw e;
+  }
+}
+const compileCache = /* @__PURE__ */ new Map();
+function compileCached(source) {
+  let hit = compileCache.get(source);
+  if (!hit) {
+    if (compileCache.size > 500) compileCache.clear();
+    hit = compileFormula(source);
+    compileCache.set(source, hit);
+  }
+  return hit;
+}
+const MAX_STEPS = 1e5;
+const MAX_LIST = 1e4;
+const MAX_TEXT = 1e5;
+const isDate = (v) => v instanceof Date;
+function formatFormulaValue(v) {
+  if (v === null) return "";
+  if (Array.isArray(v)) return v.map(formatFormulaValue).join(", ");
+  if (isDate(v)) {
+    const midnight = v.getHours() === 0 && v.getMinutes() === 0 && v.getSeconds() === 0;
+    return midnight ? v.toLocaleDateString(void 0, {
+      year: "numeric",
+      month: "short",
+      day: "numeric"
+    }) : v.toLocaleString(void 0, {
+      dateStyle: "medium",
+      timeStyle: "short"
+    });
+  }
+  if (typeof v === "number") return String(Number(v.toPrecision(12)));
+  return String(v);
+}
+function truthy(v) {
+  if (v === null) return false;
+  if (Array.isArray(v)) return v.length > 0;
+  if (typeof v === "boolean") return v;
+  if (typeof v === "number") return v !== 0;
+  if (typeof v === "string") return v.length > 0;
+  return true;
+}
+function num(v, what) {
+  if (v === null) return 0;
+  if (typeof v === "number") return v;
+  if (typeof v === "boolean") return v ? 1 : 0;
+  throw new FormulaError(`${what} needs a number, got ${kind(v)}`);
+}
+function date(v, what) {
+  if (isDate(v)) return v;
+  throw new FormulaError(`${what} needs a date`);
+}
+function text(v) {
+  return formatFormulaValue(v);
+}
+const DAY = 864e5;
+function wallClockDiff(a, b) {
+  return a.getTime() - b.getTime() - (a.getTimezoneOffset() - b.getTimezoneOffset()) * 6e4;
+}
+function addMonthsClamped(d, months) {
+  const out = new Date(d.getTime());
+  const day = d.getDate();
+  out.setDate(1);
+  out.setMonth(out.getMonth() + months);
+  const last = new Date(out.getFullYear(), out.getMonth() + 1, 0).getDate();
+  out.setDate(Math.min(day, last));
+  return out;
+}
+function monthsBetween(a, b) {
+  let m = (a.getFullYear() - b.getFullYear()) * 12 + (a.getMonth() - b.getMonth());
+  const anchor = addMonthsClamped(b, m);
+  if (m > 0 && anchor.getTime() > a.getTime()) m -= 1;
+  else if (m < 0 && anchor.getTime() < a.getTime()) m += 1;
+  return m;
+}
+function normUnit(u) {
+  const s = String(u != null ? u : "").toLowerCase().trim();
+  const unit = s.endsWith("s") ? s : `${s}s`;
+  if (!["years", "quarters", "months", "weeks", "days", "hours", "minutes"].includes(unit)) {
+    throw new FormulaError(`Unknown unit "${String(u)}" (use "days", "weeks", "months", \u2026)`);
+  }
+  return unit;
+}
+function dateBetween(a, b, unitIn) {
+  const unit = normUnit(unitIn);
+  switch (unit) {
+    case "years":
+      return Math.trunc(monthsBetween(a, b) / 12);
+    case "quarters":
+      return Math.trunc(monthsBetween(a, b) / 3);
+    case "months":
+      return monthsBetween(a, b);
+    case "weeks":
+      return Math.trunc(wallClockDiff(a, b) / (7 * DAY));
+    case "days":
+      return Math.trunc(wallClockDiff(a, b) / DAY);
+    case "hours":
+      return Math.trunc((a.getTime() - b.getTime()) / 36e5);
+    default:
+      return Math.trunc((a.getTime() - b.getTime()) / 6e4);
+  }
+}
+function dateAdd(d, n, unitIn) {
+  const unit = normUnit(unitIn);
+  const whole = Math.trunc(n);
+  switch (unit) {
+    case "years":
+      return addMonthsClamped(d, whole * 12);
+    case "quarters":
+      return addMonthsClamped(d, whole * 3);
+    case "months":
+      return addMonthsClamped(d, whole);
+    case "weeks":
+    case "days": {
+      const out = new Date(d.getTime());
+      out.setDate(out.getDate() + whole * (unit === "weeks" ? 7 : 1));
+      return out;
+    }
+    case "hours":
+      return new Date(d.getTime() + n * 36e5);
+    default:
+      return new Date(d.getTime() + n * 6e4);
+  }
+}
+function sameValue(l, r) {
+  if (isDate(l) && isDate(r)) return l.getTime() === r.getTime();
+  if (Array.isArray(l) && Array.isArray(r)) return l.length === r.length && l.every((x, i) => sameValue(x, r[i]));
+  return l === r;
+}
+function compare(op, l, r) {
+  if (op === "==" || op === "!=") {
+    const eq = sameValue(l, r);
+    return op === "==" ? eq : !eq;
+  }
+  let a;
+  let b;
+  if (isDate(l) && isDate(r)) {
+    a = l.getTime();
+    b = r.getTime();
+  } else if (typeof l === "string" && typeof r === "string") {
+    const c = l.localeCompare(r, void 0, {
+      numeric: true,
+      sensitivity: "base"
+    });
+    a = c;
+    b = 0;
+  } else if ((typeof l === "number" || l === null || typeof l === "boolean") && (typeof r === "number" || r === null || typeof r === "boolean")) {
+    a = num(l, op);
+    b = num(r, op);
+  } else {
+    throw new FormulaError(`Can't compare ${kind(l)} with ${kind(r)}`);
+  }
+  switch (op) {
+    case ">":
+      return a > b;
+    case "<":
+      return a < b;
+    case ">=":
+      return a >= b;
+    default:
+      return a <= b;
+  }
+}
+function kind(v) {
+  if (v === null) return "empty";
+  if (Array.isArray(v)) return "a list";
+  if (isDate(v)) return "a date";
+  if (typeof v === "string") return "text";
+  if (typeof v === "boolean") return "a checkbox";
+  return "a number";
+}
+function evalNode(node, ctx) {
+  var _a;
+  if (ctx.budget && --ctx.budget.left < 0) throw new FormulaError("Formula is too complex");
+  switch (node.k) {
+    case "lit":
+      return node.v;
+    case "prop":
+      return ctx.getProp(node.name);
+    case "var": {
+      const vars = (_a = ctx.vars) != null ? _a : {};
+      if (!(node.name in vars)) throw new FormulaError(`"${node.name}" has no value here`);
+      return vars[node.name];
+    }
+    case "list":
+      return node.items.map((n) => evalNode(n, ctx));
+    case "let": {
+      let scope = ctx;
+      node.names.forEach((name, i) => {
+        var _a2;
+        const v = evalNode(node.values[i], scope);
+        scope = __spreadProps(__spreadValues({}, scope), {
+          vars: __spreadProps(__spreadValues({}, (_a2 = scope.vars) != null ? _a2 : {}), {
+            [name]: v
+          })
+        });
+      });
+      return evalNode(node.body, scope);
+    }
+    case "unary": {
+      const v = evalNode(node.arg, ctx);
+      return node.op === "-" ? -num(v, "Minus") : !truthy(v);
+    }
+    case "bin": {
+      if (node.op === "and") return truthy(evalNode(node.l, ctx)) && truthy(evalNode(node.r, ctx));
+      if (node.op === "or") return truthy(evalNode(node.l, ctx)) || truthy(evalNode(node.r, ctx));
+      const l = evalNode(node.l, ctx);
+      const r = evalNode(node.r, ctx);
+      switch (node.op) {
+        case "+":
+          if (typeof l === "string" || typeof r === "string") return text(l) + text(r);
+          if (isDate(l) || isDate(r)) throw new FormulaError("Use dateAdd() to add to a date");
+          return num(l, "+") + num(r, "+");
+        case "-":
+          if (isDate(l) || isDate(r)) throw new FormulaError("Use dateBetween() to subtract dates");
+          return num(l, "-") - num(r, "-");
+        case "*":
+          return num(l, "*") * num(r, "*");
+        case "/": {
+          const d = num(r, "/");
+          if (d === 0) throw new FormulaError("Division by zero");
+          return num(l, "/") / d;
+        }
+        case "%": {
+          const d = num(r, "%");
+          if (d === 0) throw new FormulaError("Division by zero");
+          return num(l, "%") % d;
+        }
+        case "^":
+          return num(l, "^") ** num(r, "^");
+        default:
+          return compare(node.op, l, r);
+      }
+    }
+    case "call":
+      return callFunction(node.name, node.args, ctx);
+    default:
+      return null;
+  }
+}
+function list(v) {
+  if (Array.isArray(v)) return v;
+  return v === null ? [] : [v];
+}
+function numbers(args, what) {
+  const out = [];
+  for (const a of args) for (const x of list(a)) if (x !== null) out.push(num(x, what));
+  return out;
+}
+function capList(v) {
+  if (v.length > MAX_LIST) throw new FormulaError("List is too long");
+  return v;
+}
+function capText(t) {
+  if (t.length > MAX_TEXT) throw new FormulaError("Text is too long");
+  return t;
+}
+const pad2 = (n) => String(n).padStart(2, "0");
+function isoWeek(d) {
+  const t = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
+  const dayNum = t.getUTCDay() || 7;
+  t.setUTCDate(t.getUTCDate() + 4 - dayNum);
+  const yearStart = new Date(Date.UTC(t.getUTCFullYear(), 0, 1));
+  return Math.ceil(((t.getTime() - yearStart.getTime()) / DAY + 1) / 7);
+}
+function formatDatePattern(d, pattern) {
+  const month = (style) => d.toLocaleDateString("en-US", {
+    month: style
+  });
+  const weekday = (style) => d.toLocaleDateString("en-US", {
+    weekday: style
+  });
+  const h12 = d.getHours() % 12 || 12;
+  const tokens = {
+    YYYY: () => String(d.getFullYear()),
+    YY: () => String(d.getFullYear()).slice(-2),
+    MMMM: () => month("long"),
+    MMM: () => month("short"),
+    MM: () => pad2(d.getMonth() + 1),
+    M: () => String(d.getMonth() + 1),
+    DD: () => pad2(d.getDate()),
+    D: () => String(d.getDate()),
+    dddd: () => weekday("long"),
+    ddd: () => weekday("short"),
+    HH: () => pad2(d.getHours()),
+    H: () => String(d.getHours()),
+    hh: () => pad2(h12),
+    h: () => String(h12),
+    mm: () => pad2(d.getMinutes()),
+    ss: () => pad2(d.getSeconds()),
+    A: () => d.getHours() < 12 ? "AM" : "PM",
+    a: () => d.getHours() < 12 ? "am" : "pm"
+  };
+  return pattern.replace(/\[([^\]]*)\]|YYYY|YY|MMMM|MMM|MM|M|DD|D|dddd|ddd|HH|H|hh|h|mm|ss|A|a/g, (m, lit) => lit !== void 0 ? lit : tokens[m]());
+}
+function callFunction(name, argNodes, ctx) {
+  var _a, _b, _c, _d;
+  if (name === "if") return truthy(evalNode(argNodes[0], ctx)) ? evalNode(argNodes[1], ctx) : evalNode(argNodes[2], ctx);
+  if (name === "ifs") {
+    let i = 0;
+    for (; i + 1 < argNodes.length; i += 2) if (truthy(evalNode(argNodes[i], ctx))) return evalNode(argNodes[i + 1], ctx);
+    return i < argNodes.length ? evalNode(argNodes[i], ctx) : null;
+  }
+  if (LIST_LAMBDAS.has(name)) {
+    const items = list(evalNode(argNodes[0], ctx));
+    const each = (x, i) => {
+      var _a2;
+      return evalNode(argNodes[1], __spreadProps(__spreadValues({}, ctx), {
+        vars: __spreadProps(__spreadValues({}, (_a2 = ctx.vars) != null ? _a2 : {}), {
+          current: x,
+          index: i
+        })
+      }));
+    };
+    switch (name) {
+      case "map":
+        return capList(items.map(each));
+      case "filter":
+        return items.filter((x, i) => truthy(each(x, i)));
+      case "find":
+        return (_a = items.find((x, i) => truthy(each(x, i)))) != null ? _a : null;
+      case "some":
+        return items.some((x, i) => truthy(each(x, i)));
+      default:
+        return items.every((x, i) => truthy(each(x, i)));
+    }
+  }
+  if (name === "and") return argNodes.every((a2) => truthy(evalNode(a2, ctx)));
+  if (name === "or") return argNodes.some((a2) => truthy(evalNode(a2, ctx)));
+  const args = argNodes.map((a2) => evalNode(a2, ctx));
+  const [a, b, c] = args;
+  switch (name) {
+    case "concat":
+      if (args.some(Array.isArray)) return capList(args.flatMap((x) => list(x)));
+      return capText(args.map(text).join(""));
+    case "length":
+      return Array.isArray(a) ? a.length : text(a).length;
+    case "lower":
+      return text(a).toLowerCase();
+    case "upper":
+      return text(a).toUpperCase();
+    case "contains":
+      if (Array.isArray(a)) return a.some((x) => text(x).toLowerCase().includes(text(b).toLowerCase()));
+      return text(a).toLowerCase().includes(text(b).toLowerCase());
+    case "empty":
+      return a === null || a === "" || Array.isArray(a) && a.length === 0 || typeof a === "number" && Number.isNaN(a);
+    case "format":
+      return text(a);
+    case "not":
+      return !truthy(a);
+    case "tonumber": {
+      if (a === null) return null;
+      if (isDate(a)) return a.getTime();
+      if (typeof a === "boolean") return a ? 1 : 0;
+      if (typeof a === "number") return a;
+      const n = Number(String(a).trim().replace(/,/g, ""));
+      return String(a).trim() && Number.isFinite(n) ? n : null;
+    }
+    case "round": {
+      const digits = b === void 0 ? 0 : Math.max(0, Math.min(10, Math.trunc(num(b, "round"))));
+      const f = 10 ** digits;
+      return Math.round(num(a, "round") * f) / f;
+    }
+    case "floor":
+      return Math.floor(num(a, "floor"));
+    case "ceil":
+      return Math.ceil(num(a, "ceil"));
+    case "abs":
+      return Math.abs(num(a, "abs"));
+    case "sqrt": {
+      const n = num(a, "sqrt");
+      if (n < 0) throw new FormulaError("sqrt() of a negative number");
+      return Math.sqrt(n);
+    }
+    case "min": {
+      const ns = numbers(args, "min");
+      return ns.length ? Math.min(...ns) : null;
+    }
+    case "max": {
+      const ns = numbers(args, "max");
+      return ns.length ? Math.max(...ns) : null;
+    }
+    case "sum":
+      return numbers(args, "sum").reduce((x, y) => x + y, 0);
+    case "average": {
+      const ns = numbers(args, "average");
+      return ns.length ? ns.reduce((x, y) => x + y, 0) / ns.length : null;
+    }
+    case "median": {
+      const ns = numbers(args, "median").sort((x, y) => x - y);
+      if (!ns.length) return null;
+      const m = Math.floor(ns.length / 2);
+      return ns.length % 2 ? ns[m] : (ns[m - 1] + ns[m]) / 2;
+    }
+    case "join":
+      return capText(list(a).map(text).join(b === void 0 ? ", " : text(b)));
+    case "at": {
+      const items = list(a);
+      const i = Math.trunc(num(b, "at()"));
+      return (_b = items[i < 0 ? items.length + i : i]) != null ? _b : null;
+    }
+    case "first":
+      return (_c = list(a)[0]) != null ? _c : null;
+    case "last": {
+      const items = list(a);
+      return (_d = items[items.length - 1]) != null ? _d : null;
+    }
+    case "sort":
+      return [...list(a)].sort((x, y) => {
+        if (x === null) return 1;
+        if (y === null) return -1;
+        if (typeof x === "number" && typeof y === "number") return x - y;
+        if (isDate(x) && isDate(y)) return x.getTime() - y.getTime();
+        return text(x).localeCompare(text(y), void 0, {
+          numeric: true,
+          sensitivity: "base"
+        });
+      });
+    case "reverse":
+      return Array.isArray(a) ? [...a].reverse() : [...text(a)].reverse().join("");
+    case "unique": {
+      const out = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const x of list(a)) {
+        const key = x === null ? "null" : typeof x !== "object" ? `${typeof x}:${String(x)}` : isDate(x) ? `date:${x.getTime()}` : void 0;
+        if (key !== void 0) {
+          if (seen.has(key)) continue;
+          seen.add(key);
+        } else if (out.some((y) => sameValue(x, y))) continue;
+        out.push(x);
+      }
+      return out;
+    }
+    case "includes":
+      return list(a).some((x) => sameValue(x, b) || typeof x === "string" && typeof b === "string" && x.toLowerCase() === b.toLowerCase());
+    case "slice": {
+      const start = Math.trunc(num(b, "slice()"));
+      const end = c === void 0 ? void 0 : Math.trunc(num(c, "slice()"));
+      return Array.isArray(a) ? a.slice(start, end) : text(a).slice(start, end);
+    }
+    case "split":
+      return capList(text(a).split(text(b)));
+    case "trim":
+      return text(a).trim();
+    case "replace":
+      return text(a).replace(text(b), () => text(c));
+    case "replaceall":
+      return capText(text(b) ? text(a).split(text(b)).join(text(c)) : text(a));
+    case "substring": {
+      const start = Math.trunc(num(b, "substring()"));
+      return c === void 0 ? text(a).substring(start) : text(a).substring(start, Math.trunc(num(c, "substring()")));
+    }
+    case "repeat": {
+      const n = Math.max(0, Math.trunc(num(b, "repeat()")));
+      if (text(a).length * n > MAX_TEXT) throw new FormulaError("Text is too long");
+      return text(a).repeat(n);
+    }
+    case "startswith":
+      return text(a).startsWith(text(b));
+    case "endswith":
+      return text(a).endsWith(text(b));
+    case "padstart": {
+      const n = Math.min(1e3, Math.max(0, Math.trunc(num(b, "padStart()"))));
+      return text(a).padStart(n, c === void 0 ? " " : text(c) || " ");
+    }
+    case "formatdate":
+      if (a === null) return null;
+      return formatDatePattern(date(a, "formatDate()"), text(b));
+    case "parsedate": {
+      if (a === null || text(a).trim() === "") return null;
+      const d = parseDateValue(text(a).trim());
+      if (!d) throw new FormulaError(`parseDate() can't read "${text(a)}"`);
+      return d;
+    }
+    case "year":
+      return a === null ? null : date(a, "year()").getFullYear();
+    case "month":
+      return a === null ? null : date(a, "month()").getMonth() + 1;
+    case "date":
+      return a === null ? null : date(a, "date()").getDate();
+    case "day":
+      return a === null ? null : date(a, "day()").getDay() || 7;
+    case "week":
+      return a === null ? null : isoWeek(date(a, "week()"));
+    case "hour":
+      return a === null ? null : date(a, "hour()").getHours();
+    case "minute":
+      return a === null ? null : date(a, "minute()").getMinutes();
+    case "timestamp":
+      return a === null ? null : date(a, "timestamp()").getTime();
+    case "tostring":
+      return text(a);
+    case "now":
+      return new Date(ctx.now.getTime());
+    case "today":
+      return new Date(ctx.now.getFullYear(), ctx.now.getMonth(), ctx.now.getDate());
+    case "datebetween":
+      if (a === null || b === null) return null;
+      return dateBetween(date(a, "dateBetween()"), date(b, "dateBetween()"), String(c));
+    case "dateadd":
+      if (a === null) return null;
+      return dateAdd(date(a, "dateAdd()"), num(b, "dateAdd()"), String(c));
+    default:
+      throw new FormulaError(`Unknown function "${name}"`);
+  }
+}
+function evaluateFormula(ast, ctx) {
+  var _a;
+  try {
+    const value = evalNode(ast, __spreadProps(__spreadValues({}, ctx), {
+      budget: (_a = ctx.budget) != null ? _a : {
+        left: MAX_STEPS
+      }
+    }));
+    if (typeof value === "number" && !Number.isFinite(value)) return {
+      ok: false,
+      error: "Result is not a number"
+    };
+    return {
+      ok: true,
+      value
+    };
+  } catch (e) {
+    if (e instanceof FormulaError) return {
+      ok: false,
+      error: e.message
+    };
+    if (e instanceof RangeError) return {
+      ok: false,
+      error: "Formula is too complex"
+    };
+    throw e;
+  }
+}
+function parseDateValue(value) {
+  const s = dateString(value);
+  if (!s) return null;
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
+  if (m) return new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]));
+  const d = new Date(s);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+function toFormulaValue(value, type) {
+  switch (type) {
+    case "number":
+      return numberValue(value);
+    case "checkbox":
+      return value === true || value === "true";
+    case "date":
+    case "created_time":
+    case "last_edited_time":
+      return parseDateValue(value);
+    case "formula":
+      return value === void 0 ? null : value;
+    case "connector":
+      return connectorCellValue(value);
+    case "multi_select":
+    case "person":
+      return multiSelectNames(value);
+    case "rollup":
+      if (Array.isArray(value)) return value.map((v) => v instanceof Date || typeof v !== "object" ? v : richTextToPlain(v));
+      if (typeof value === "number" || typeof value === "boolean" || value === null) return value;
+      if (value instanceof Date) return value;
+      return richTextToPlain(value);
+    case "select":
+    case "status":
+    case "files":
+    case "relation":
+      return cellDisplayText(value, type);
+    default:
+      return richTextToPlain(value);
+  }
+}
+const MAX_FORMULA_DEPTH = 8;
+function rowCellValue(row, column, columns, now = /* @__PURE__ */ new Date(), depth = 0, extra) {
+  var _a;
+  if (column.type !== "formula") {
+    const v = extra == null ? void 0 : extra(row, column);
+    return v !== void 0 ? v : baseCellValue(row, column);
+  }
+  const compiled = compileCached((_a = column.expression) != null ? _a : "");
+  if (!compiled.ok) return null;
+  if (depth === 0) {
+    try {
+      return rowCellValue(row, column, columns, now, 1, extra);
+    } catch (e) {
+      if (e instanceof FormulaCycleError) return null;
+      throw e;
+    }
+  }
+  const r = evaluateFormula(compiled.ast, {
+    now,
+    getProp: (name) => {
+      const c = columns.find((x) => x.name === name);
+      if (!c) throw new FormulaError(`Unknown property "${name}"`);
+      if (c.type === "formula" && depth + 1 > MAX_FORMULA_DEPTH) throw new FormulaCycleError("Circular reference");
+      return toFormulaValue(rowCellValue(row, c, columns, now, depth + 1, extra), c.type);
+    }
+  });
+  return r.ok ? r.value : null;
+}
+function makeCellGetter(columns, now = /* @__PURE__ */ new Date(), extra) {
+  const hasFormula = columns.some((c) => c.type === "formula");
+  if (!hasFormula && !extra) return baseCellValue;
+  return (row, column) => {
+    if (extra) {
+      const v = extra(row, column);
+      if (v !== void 0) return v;
+    }
+    return hasFormula ? rowCellValue(row, column, columns, now, 0, extra) : baseCellValue(row, column);
+  };
+}export{addMonthsClamped,compileCached,compileFormula,dateAdd,dateBetween,evaluateFormula,formatDatePattern,formatFormulaValue,makeCellGetter,rowCellValue,toFormulaValue};//# sourceMappingURL=databaseFormula.js.map