@gridsheet/core 3.0.0-rc.8

package/dist/formula/evaluator.js

@@ -0,0 +1,585 @@
+import { a2p as x, buildIdentifiedRef as F, grantAddressAbsolute as S } from "../lib/coords.js";
+import { FormulaError as f } from "./formula-error.js";
+const m = (h, e = !0) => {
+  let t = h;
+  return e && t.startsWith("$") && (t = t.slice(1)), e && t.endsWith("$") && (t = t.slice(0, -1)), t.replace("#", "");
+};
+class w {
+  constructor(e) {
+    this.ids = [], this.value = e;
+  }
+}
+class N extends w {
+  evaluate() {
+    return this.value;
+  }
+}
+class T extends w {
+  evaluate() {
+    throw new f("#REF!", "Reference does not exist.");
+  }
+}
+class _ extends w {
+  evaluate() {
+    throw new f("#NAME?", `Invalid ref: ${this.value}`);
+  }
+}
+class b extends w {
+  constructor(e) {
+    super(e);
+  }
+  stringify() {
+    return this.value.toUpperCase();
+  }
+  evaluate({ sheet: e }) {
+    const t = R(this.value, { sheet: e, dependency: "" });
+    if (t.sheet == null)
+      throw new f("#REF!", `Unknown sheet: ${t.sheetName}`);
+    if (t.addresses.length === 0)
+      throw new f("#REF!", `Invalid address: ${this.value}`);
+    const { y: i, x: n } = x(t.addresses[0]);
+    return t.sheet.trim({ top: i, left: n, bottom: i, right: n });
+  }
+  identify(e) {
+    const { slideY: t = 0, slideX: i = 0 } = e, n = R(this.value, e);
+    if (n.sheet == null)
+      return this.value;
+    const s = n.addresses[0], { y: r, x: o, absX: l, absY: u } = x(s), p = {
+      y: r + t,
+      x: o + i,
+      absX: l,
+      absY: u
+    }, c = n.sheet.getId(p);
+    return c == null ? this.value : (this.ids = [c], `#${n.sheet.id}!${F(c, l, u)}`);
+  }
+}
+class P extends w {
+  stringify() {
+    return this.value.toUpperCase();
+  }
+  evaluate({ sheet: e }) {
+    const t = R(this.value, { sheet: e, dependency: "" });
+    if (t.sheet == null)
+      throw new f("#REF!", `Unknown sheet: ${t.sheetName}`);
+    if (t.addresses.length === 0)
+      throw new f("#REF!", `Invalid address: ${this.value}`);
+    const i = t.sheet.rangeToArea(t.addresses.join(":"));
+    return t.sheet.trim(i);
+  }
+  identify(e) {
+    const { slideY: t = 0, slideX: i = 0 } = e, n = R(this.value, e);
+    if (n.sheet == null)
+      return this.value;
+    const s = [];
+    for (let r = 0; r < n.addresses.length; r++) {
+      const o = n.addresses[r], { y: l, x: u, absX: p, absY: c } = x(o), E = {
+        y: l + t,
+        x: u + i,
+        absX: p,
+        absY: c
+      }, y = n.sheet.getId(E);
+      if (y == null)
+        return this.value;
+      this.ids.push(y), s.push(F(y, p, c));
+    }
+    return `#${n.sheet.id}!${s.join(":")}`;
+  }
+}
+class O extends w {
+  parse(e) {
+    if (this.value.indexOf("!") !== -1) {
+      const [t, i] = this.value.split("!"), n = Number(t.slice(1));
+      return { sheet: e.getSheetBySheetId(n), id: m(i, !1) };
+    }
+    return { sheet: e, id: m(this.value, !1) };
+  }
+  evaluate({ sheet: e }) {
+    const t = this.parse(e);
+    if (t.id === "?")
+      throw new f("#REF!", "Reference does not exist");
+    const { y: i, x: n } = t.sheet.getPointById(t.id), [s, r] = [Math.abs(i), Math.abs(n)];
+    return t.sheet.trim({
+      top: s,
+      left: r,
+      bottom: s,
+      right: r
+    });
+  }
+  display({ sheet: e, slideY: t = 0, slideX: i = 0 }) {
+    const n = this.parse(e), s = n.sheet.getAddressById(n.id, t, i);
+    return s ? n.sheet.id === e.id ? s : `${n.sheet.sheetPrefix()}${s}` : "#REF!";
+  }
+  identify(e) {
+    const { sheet: t, slideY: i = 0, slideX: n = 0 } = e, s = this.display({ sheet: t, slideY: i, slideX: n });
+    if (s == null || s.length < 2)
+      return "#?";
+    const { formula: r, ids: o } = R(s, e);
+    return this.ids = o, r || "#?";
+  }
+}
+class A extends w {
+  parse(e) {
+    const t = this.value;
+    if (t.indexOf("!") !== -1) {
+      const [i, n] = t.split("!"), s = Number(i.slice(1));
+      return { sheet: e.getSheetBySheetId(s), ids: n.split(":") };
+    }
+    return { sheet: e, ids: t.split(":") };
+  }
+  evaluate({ sheet: e }) {
+    const t = this.parse(e), i = t.ids.map((c) => m(c)), n = [];
+    for (let c = 0; c < i.length; c++) {
+      const E = i[c];
+      if (E === "?")
+        throw new f("#REF!", "Reference does not exist");
+      const y = t.sheet.getPointById(E);
+      n.push(y);
+    }
+    const [s, r] = n, [o, l, u, p] = [s.y, s.x, r.y || t.sheet.numRows, r.x || t.sheet.numCols];
+    return t.sheet.trim({ top: o, left: l, bottom: u, right: p });
+  }
+  display({ sheet: e, slideY: t = 0, slideX: i = 0 }) {
+    const n = this.parse(e), s = n.ids.map((r) => m(r, !1)).map((r) => n.sheet.getAddressById(r, t, i) || "#REF!").join(":");
+    return n.sheet.id === e.id ? s : `${n.sheet.sheetPrefix()}${s}`;
+  }
+  identify(e) {
+    const { sheet: t, slideY: i = 0, slideX: n = 0 } = e, s = this.display({ sheet: t, slideY: i, slideX: n }), { formula: r, ids: o } = R(s, e);
+    return this.ids = o, r ?? "";
+  }
+}
+class I {
+  constructor(e, t = 0, i = [], n) {
+    this.name = e, this.precedence = t, this.args = i, this.at = n;
+  }
+  evaluate({ sheet: e }) {
+    const t = this.name.toLowerCase(), i = e.getFunctionByName(t);
+    if (i == null)
+      throw new f("#NAME?", `Unknown function: ${t}`);
+    return new i({ args: this.args, sheet: e, at: this.at }).call();
+  }
+}
+const C = new N(0), U = {
+  "+": "add",
+  "-": "minus",
+  "/": "divide",
+  "*": "multiply",
+  "^": "power",
+  "&": "concat",
+  "=": "eq",
+  "<>": "ne",
+  ">": "gt",
+  ">=": "gte",
+  "<": "lt",
+  "<=": "lte"
+}, L = {
+  "-": "uminus"
+}, $ = /* @__PURE__ */ new Set([" ", `
+`, "\r", "	", "\f"]), X = /* @__PURE__ */ new Set([...$, "+", "-", "/", "*", "^", "&", "=", "<", ">", ")", ",", "%"]);
+class a {
+  constructor(e, t, i = 0, n, s = !0) {
+    this.type = e, this.entity = t, this.precedence = i, this.at = n, this.closed = s;
+  }
+  length() {
+    return this.type === "VALUE" && typeof this.entity == "string" ? this.entity.length + (this.closed ? 2 : 1) : new String(this.entity).length;
+  }
+  stringify() {
+    if (this.type === "VALUE") {
+      if (typeof this.entity == "string")
+        return this.closed ? `"${this.entity}"` : `"${this.entity}`;
+      if (typeof this.entity == "boolean")
+        return this.entity ? "TRUE" : "FALSE";
+    }
+    return this.entity;
+  }
+  convert() {
+    switch (this.type) {
+      case "VALUE":
+        return new N(this.entity);
+      case "ID":
+        return new O(this.entity);
+      case "ID_RANGE":
+        return new A(this.entity);
+      case "REF":
+        return new b(this.entity);
+      case "RANGE":
+        return new P(this.entity);
+      case "INFIX_OPERATOR": {
+        const e = U[this.entity];
+        return new I(e, this.precedence, void 0, this.at);
+      }
+      case "PREFIX_OPERATOR": {
+        const e = L[this.entity];
+        return new I(e, this.precedence, void 0, this.at);
+      }
+      case "FUNCTION":
+        return new I(this.entity, 0, [], this.at);
+      case "UNREFERENCED":
+        return new T(this.entity);
+      case "INVALID_REF":
+        return new _(this.entity);
+    }
+  }
+}
+const D = (h) => $.has(h), M = { true: !0, false: !1 }, v = new a("OPEN", "("), V = new a("CLOSE", ")"), B = new a("COMMA", ","), d = "INFIX_OPERATOR", j = "PREFIX_OPERATOR", G = "POSTFIX_OPERATOR";
+class Z {
+  constructor(e, t) {
+    this.tokens = [], this.foreign = !1, this.identifiedFormula = "", this.dependencyIds = [], this.formula = e, this.index = 0, this.tokens = [], this.at = t == null ? void 0 : t.at;
+  }
+  isWhiteSpace() {
+    return D(this.formula[this.index]);
+  }
+  next(e = 1) {
+    this.index += e;
+  }
+  get(e = 0) {
+    return this.formula[this.index + e];
+  }
+  getToken(e = 0) {
+    return this.tokens[this.tokens.length + e];
+  }
+  getTokenIndexByCharPosition(e) {
+    let t = 0, i = 0;
+    for (let n = 0; n < this.tokens.length; n++) {
+      const s = this.tokens[n];
+      if (i = t + s.length(), t <= e && e <= i)
+        return [n, e === t || e === i];
+      t = i;
+    }
+    return [-1, !1];
+  }
+  getTokenPositionRange(e, t = 1) {
+    let i = 0, n = 0;
+    for (let s = 0; s < e; s++)
+      i = n, n += this.tokens[s].length();
+    return [i + t, n + t];
+  }
+  stringify() {
+    return this.tokens.map((e) => e.stringify()).join("");
+  }
+  identify(e) {
+    const t = [], i = [];
+    for (const n of this.tokens)
+      switch (n.type) {
+        case "VALUE":
+          typeof n.entity == "number" || typeof n.entity == "boolean" ? t.push(String(n.entity)) : t.push(n.closed ? `"${n.entity}"` : `"${n.entity}`);
+          break;
+        case "ID": {
+          const s = new O(n.entity);
+          t.push(s.identify(e)), i.push(...s.ids);
+          break;
+        }
+        case "ID_RANGE": {
+          const s = new A(n.entity);
+          t.push(s.identify(e)), i.push(...s.ids);
+          break;
+        }
+        case "REF": {
+          const s = new b(n.entity);
+          t.push(s.identify(e)), i.push(...s.ids);
+          break;
+        }
+        case "RANGE": {
+          const s = new P(n.entity);
+          t.push(s.identify(e)), i.push(...s.ids);
+          break;
+        }
+        default:
+          t.push(n.entity);
+          break;
+      }
+    this.identifiedFormula = t.join(""), this.dependencyIds = i;
+  }
+  display({ sheet: e }) {
+    return this.tokens.map((t) => {
+      switch (t.type) {
+        case "VALUE":
+          return typeof t.entity == "number" || typeof t.entity == "boolean" ? t.entity : t.closed ? `"${t.entity}"` : `"${t.entity}`;
+        case "ID":
+          return new O(t.entity).display({ sheet: e });
+        case "ID_RANGE":
+          return new A(t.entity).display({ sheet: e });
+      }
+      return t.entity;
+    }).join("");
+  }
+  tokenize(e = {}) {
+    var t, i;
+    for (; this.index <= this.formula.length; ) {
+      this.skipSpaces();
+      let n = this.get();
+      switch (this.next(), n) {
+        case void 0:
+          return;
+        case "(":
+          this.tokens.push(v);
+          continue;
+        case ")":
+          this.tokens.push(V);
+          continue;
+        case ",":
+          this.tokens.push(B);
+          continue;
+        case "+":
+          this.tokens.push(new a(d, "+", 3, this.at));
+          continue;
+        case "-": {
+          const r = (t = this.getToken(-1)) == null ? void 0 : t.type, o = (i = this.getToken(-2)) == null ? void 0 : i.type;
+          r === d || r === "SPACE" && o === d ? this.tokens.push(new a(j, "-", 6, this.at)) : this.tokens.push(new a(d, "-", 3, this.at));
+          continue;
+        }
+        case "/":
+          this.tokens.push(new a(d, "/", 4, this.at));
+          continue;
+        case "*":
+          this.tokens.push(new a(d, "*", 4, this.at));
+          continue;
+        case "^":
+          this.tokens.push(new a(d, "^", 5, this.at));
+          continue;
+        case "&":
+          this.tokens.push(new a(d, "&", 4, this.at));
+          continue;
+        case "=":
+          this.tokens.push(new a(d, "=", 1, this.at));
+          continue;
+        case ">":
+          if (this.get() === "=") {
+            this.next(), this.tokens.push(new a(d, ">=", 2, this.at));
+            continue;
+          }
+          this.tokens.push(new a(d, ">", 2, this.at));
+          continue;
+        case "<":
+          if (this.get() === "=") {
+            this.next(), this.tokens.push(new a(d, "<=", 2, this.at));
+            continue;
+          }
+          if (this.get() === ">") {
+            this.next(), this.tokens.push(new a(d, "<>", 1, this.at));
+            continue;
+          }
+          this.tokens.push(new a(d, "<", 2, this.at));
+          continue;
+        case '"': {
+          const { buf: r, closed: o } = this.getString('"');
+          this.tokens.push(new a("VALUE", r, 0, this.at, o));
+          continue;
+        }
+        case "'": {
+          const { buf: r } = this.getString("'");
+          n = `'${r}'`;
+          break;
+        }
+        case "!": {
+          this.foreign = !0;
+          break;
+        }
+        case "%": {
+          this.tokens.push(new a(G, "%", 4, this.at));
+          continue;
+        }
+      }
+      let s = n;
+      for (; ; ) {
+        const r = this.get();
+        if (r === "(") {
+          this.tokens.push(new a("FUNCTION", s, 0, this.at), v), this.next();
+          break;
+        }
+        if (r == null || X.has(r)) {
+          if (s.length === 0)
+            break;
+          if (s.match(/^[+-]?(\d*[.])?\d+$/))
+            this.tokens.push(new a("VALUE", parseFloat(s), 0, this.at));
+          else {
+            const o = M[s.toLowerCase()];
+            o != null ? this.tokens.push(new a("VALUE", o, 0, this.at)) : s.startsWith("#") ? s.indexOf("#REF!") !== -1 ? this.tokens.push(new a("UNREFERENCED", s, 0, this.at)) : s.indexOf(":") !== -1 ? this.tokens.push(new a("ID_RANGE", W(s, e), 0, this.at)) : this.tokens.push(new a("ID", s, 0, this.at)) : s.indexOf(":") !== -1 ? this.tokens.push(new a("RANGE", s, 0, this.at)) : s.includes(".") && /[a-zA-Z]/.test(s) || isNaN(s[s.length - 1]) ? this.tokens.push(new a("INVALID_REF", s, 0, this.at)) : this.tokens.push(new a("REF", s, 0, this.at));
+          }
+          break;
+        }
+        s += r, this.next();
+      }
+    }
+  }
+  skipSpaces() {
+    let e = "";
+    for (; this.isWhiteSpace(); )
+      e += this.formula[this.index++];
+    e !== "" && this.tokens.push(new a("SPACE", e, 0, this.at));
+  }
+  getString(e = '"') {
+    let t = "";
+    for (; ; ) {
+      const i = this.get();
+      if (this.next(), i == null)
+        return { buf: t, closed: !1 };
+      if (i === e)
+        if (e === '"' && this.get() === e) {
+          t += e, this.next();
+          continue;
+        } else if (e === "'" && this.get() === e) {
+          t += i;
+          continue;
+        } else
+          return { buf: t, closed: !0 };
+      else
+        t += i;
+    }
+  }
+}
+const W = (h, e) => {
+  const [t, i] = h.split("!"), n = i.split(":"), s = /* @__PURE__ */ new Set();
+  return Object.keys(e).forEach((r) => {
+    const o = e[r], l = new RegExp(`(\\$)?#${r}\\b(\\$)?`);
+    for (let u = 0; u < n.length; u++) {
+      if (s.has(u))
+        continue;
+      const p = n[u], c = p.replace(l, (E, y, k) => `${y || ""}#${o}${k || ""}`);
+      c !== p && (n[u] = c, s.add(u));
+    }
+  }), `${t}!${n.join(":")}`;
+};
+class Y {
+  constructor(e) {
+    this.index = 0, this.depth = 0, this.tokens = e;
+  }
+  build() {
+    const { expr: e } = this.parse(!1);
+    return e;
+  }
+  parse(e) {
+    const t = [];
+    let i;
+    const n = (s = !1) => {
+      if (i) {
+        const r = t.pop();
+        i.args.push(r);
+      }
+      return { hasNext: s, expr: t.shift() };
+    };
+    for (; this.tokens.length > this.index; ) {
+      const s = this.tokens[this.index++];
+      if (s.type !== "SPACE") {
+        if (s.type === "COMMA") {
+          if (!e)
+            throw new f("#ERROR!", "Invalid comma");
+          return n(!0);
+        } else if (s.type === "VALUE" || s.type === "ID" || s.type === "ID_RANGE" || s.type === "REF" || s.type === "RANGE" || s.type === "UNREFERENCED" || s.type === "INVALID_REF") {
+          const r = s.convert();
+          t.push(r);
+        } else if (s.type === "POSTFIX_OPERATOR" && s.entity === "%") {
+          const r = t.pop();
+          if (!r)
+            throw new f("#ERROR!", "Missing expression before %");
+          const o = new I("divide", 4, [r, new N(100)]);
+          t.push(o);
+        } else if (s.type === "FUNCTION") {
+          this.index++, this.depth++;
+          const r = s.convert();
+          for (t.push(r); ; ) {
+            const { expr: o, hasNext: l } = this.parse(!0);
+            if (o && r.args.push(o), !l)
+              break;
+          }
+        } else if (s.type === "OPEN") {
+          this.depth++;
+          const { expr: r } = this.parse(!1);
+          t.push(r);
+        } else if (s.type === "CLOSE") {
+          if (this.depth-- === 0)
+            throw new f("#ERROR!", "Unexpected end paren");
+          return n();
+        } else if (s.type === "INFIX_OPERATOR") {
+          const r = s.convert();
+          let o = t.pop();
+          if (o == null)
+            if (r.name === "minus" || r.name === "add")
+              o = C;
+            else
+              throw new f("#ERROR!", "Missing left expression");
+          if (i == null)
+            r.args.push(o), t.unshift(r);
+          else if (r.precedence > i.precedence)
+            r.args.push(o), i.args.push(r), t.unshift(i);
+          else {
+            const l = t.shift();
+            r.args.push(l), i.args.push(o), t.unshift(r);
+          }
+          i = r;
+        } else if (s.type === "PREFIX_OPERATOR") {
+          const r = s.convert();
+          i ? i.args.push(r) : t.unshift(r), i = r;
+        }
+      }
+    }
+    return n();
+  }
+}
+const J = Y, Q = (h) => (h.charAt(0) === "'" && (h = h.slice(1)), h.charAt(h.length - 1) === "'" && (h = h.slice(0, -1)), h);
+function H(h) {
+  let e, t = [];
+  if (h.startsWith("'")) {
+    let i = 1, n = "";
+    for (; i < h.length; ) {
+      const r = h[i], o = h[i + 1];
+      if (r === "'")
+        if (o === "'")
+          n += "'", i += 2;
+        else if (o === "!") {
+          i += 2;
+          break;
+        } else
+          return { sheetName: void 0, addresses: [] };
+      else
+        n += r, i++;
+    }
+    e = n, t = h.slice(i).trim().split(":");
+  } else {
+    const i = h.indexOf("!");
+    i !== -1 ? (e = h.slice(0, i), t = h.slice(i + 1).trim().split(":")) : t = h.trim().split(":");
+  }
+  return { sheetName: e, addresses: t };
+}
+const R = (h, { sheet: e, operation: t, dependency: i }) => {
+  const { sheetName: n, addresses: s } = H(h), r = [];
+  if (n && (e = e.getSheetBySheetName(n), e == null))
+    return { sheet: e, sheetName: n, addresses: s, ids: r };
+  if (s.length === 0)
+    return { sheet: e, sheetName: n, addresses: s, ids: r };
+  const o = [];
+  for (let u = 0; u < s.length; u++) {
+    const p = s[u], { y: c, x: E, absX: y, absY: k } = x(p);
+    let g = e.getId({ y: c, x: E });
+    if (g === i && (t === "removeRows" ? g = e.getId({ y: c - 1, x: E }) : t === "removeCols" && (g = e.getId({ y: c, x: E - 1 }))), g == null) {
+      o.push(S(p, !!y, !!k) || "?");
+      continue;
+    }
+    r.push(g), o.push(`${y ? "$" : ""}#${g}${k ? "$" : ""}`);
+  }
+  let l = `#${e.id}!${o.join(":")}`;
+  return {
+    sheet: e,
+    sheetName: n,
+    addresses: s,
+    ids: r,
+    formula: l
+  };
+};
+export {
+  J as FormulaParser,
+  I as FunctionEntity,
+  O as IdEntity,
+  A as IdRangeEntity,
+  _ as InvalidRefEntity,
+  Z as Lexer,
+  Y as Parser,
+  P as RangeEntity,
+  b as RefEntity,
+  a as Token,
+  T as UnreferencedEntity,
+  N as ValueEntity,
+  R as parseRef,
+  H as splitRef,
+  Q as stripSheetName
+};
+//# sourceMappingURL=evaluator.js.map