@sheetxl/studio-vanilla 0.4.13 → 0.4.14

package/browser/esm/HyTvrvH0vItPFnFG.mjs

@@ -0,0 +1,472 @@
+import { $ as he } from "./BXABqQEa6kQQcjmt.mjs";
+/**
+ * @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.4.14
+ *
+ * (C) 2025-present SheetXL Inc. & Michael T. Ford
+ * License: The license can be found at https://www.sheetxl.com/license.
+ */
+var se, q, r;
+(q = se || (se = {})).Orientation = { Column: "column", Row: "row" }, q.Orientations = { ...q.Orientation, Both: "both" }, q.Direction = { Up: "up", Down: "down", Left: "left", Right: "right" }, ((e) => {
+  e.Code = { Parse: 0, Null: 1, Div0: 2, Value: 3, Ref: 4, Name: 5, Num: 6, NA: 7, GettingData: 8, Spill: 9, Connect: 10, Blocked: 11, Unknown: 12, Field: 13, Calc: 14, Busy: 16, Python: 19, Timeout: 20 }, e.Label = { Parse: "#PARSE!", Null: "#NULL!", Div0: "#DIV/0!", Value: "#VALUE!", Ref: "#REF!", Name: "#NAME?", Num: "#NUM!", NA: "#N/A", GettingData: "#GETTING_DATA", Spill: "#SPILL!", Connect: "#CONNECT!", Blocked: "#BLOCKED!", Unknown: "#UNKNOWN!", Field: "#FIELD!", Calc: "#CALC!", Busy: "#BUSY!", Python: "#PYTHON!", Timeout: "#TIMEOUT!" };
+  class a extends Error {
+    constructor(n, i, S, J) {
+      super(S, J), this._label = i, this._code = n, this.details = J;
+    }
+    static {
+      this.code = e.Code.Unknown;
+    }
+    get isFormulaError() {
+      return !0;
+    }
+    getLabel() {
+      return this._label;
+    }
+    getCode() {
+      return this._code;
+    }
+    equals(n) {
+      return !!n && (this._code === n._code || this._code === n.code);
+    }
+    get [Symbol.toStringTag]() {
+      return "[FormulaError]";
+    }
+    toString() {
+      return this.message || this._label;
+    }
+  }
+  e.Known = a;
+  class T extends a {
+    constructor(n, i) {
+      super(e.Code.Parse, e.Label.Parse, n, i);
+    }
+    static {
+      this.code = e.Code.Parse;
+    }
+    getDetails() {
+      const n = this.details;
+      return { line: n?.line ?? 1, column: n?.column ?? 1, offset: n?.offset ?? 0, length: n?.length ?? 0 };
+    }
+  }
+  e.Parse = T;
+  class x extends a {
+    constructor(n, i) {
+      super(e.Code.Null, e.Label.Null, n, i);
+    }
+    static {
+      this.code = e.Code.Null;
+    }
+  }
+  e.Null = x;
+  class j extends a {
+    constructor(n, i) {
+      super(e.Code.Div0, e.Label.Div0, n, i);
+    }
+    static {
+      this.code = e.Code.Div0;
+    }
+  }
+  e.Div0 = j;
+  class X extends a {
+    constructor(n, i) {
+      super(e.Code.Value, e.Label.Value, n, i);
+    }
+    static {
+      this.code = e.Code.Value;
+    }
+  }
+  e.Value = X;
+  class s extends a {
+    constructor(n, i) {
+      super(e.Code.Ref, e.Label.Ref, n, i);
+    }
+    static {
+      this.code = e.Code.Ref;
+    }
+  }
+  e.Ref = s;
+  class K extends a {
+    constructor(n, i) {
+      super(e.Code.Name, e.Label.Name, n, i);
+    }
+    static {
+      this.code = e.Code.Name;
+    }
+  }
+  e.Name = K;
+  class U extends a {
+    constructor(n, i) {
+      super(e.Code.Num, e.Label.Num, n, i);
+    }
+    static {
+      this.code = e.Code.Num;
+    }
+  }
+  e.Num = U;
+  class z extends a {
+    constructor(n, i) {
+      super(e.Code.NA, e.Label.NA, n, i);
+    }
+    static {
+      this.code = e.Code.NA;
+    }
+  }
+  e.NA = z;
+  class Y extends a {
+    constructor(n, i) {
+      super(e.Code.GettingData, e.Label.GettingData, n, i);
+    }
+    static {
+      this.code = e.Code.GettingData;
+    }
+  }
+  e.GettingData = Y;
+  class M extends a {
+    constructor(n, i) {
+      super(e.Code.Spill, e.Label.Spill, n, i);
+    }
+    static {
+      this.code = e.Code.Spill;
+    }
+  }
+  e.Spill = M;
+  class I extends a {
+    constructor(n, i) {
+      super(e.Code.Connect, e.Label.Connect, n, i);
+    }
+    static {
+      this.code = e.Code.Connect;
+    }
+  }
+  e.Connect = I;
+  class G extends a {
+    constructor(n, i) {
+      super(e.Code.Blocked, e.Label.Blocked, n, i);
+    }
+    static {
+      this.code = e.Code.Blocked;
+    }
+  }
+  e.Blocked = G;
+  class _ extends a {
+    constructor(n, i) {
+      super(e.Code.Unknown, e.Label.Unknown, n, i);
+    }
+    static {
+      this.code = e.Code.Unknown;
+    }
+  }
+  e.Unknown = _;
+  class F extends a {
+    constructor(n, i) {
+      super(e.Code.Field, e.Label.Field, n, i);
+    }
+    static {
+      this.code = e.Code.Field;
+    }
+  }
+  e.Field = F;
+  class Q extends a {
+    constructor(n, i) {
+      super(e.Code.Calc, e.Label.Calc, n, i);
+    }
+    static {
+      this.code = e.Code.Calc;
+    }
+  }
+  e.Calc = Q;
+  class O extends a {
+    constructor(n, i) {
+      super(e.Code.Busy, e.Label.Busy, n, i);
+    }
+    static {
+      this.code = e.Code.Busy;
+    }
+  }
+  e.Busy = O;
+  class P extends a {
+    constructor(n, i) {
+      super(e.Code.Python, e.Label.Python, n, i);
+    }
+    static {
+      this.code = e.Code.Python;
+    }
+  }
+  e.Python = P;
+  class Z extends a {
+    constructor(n, i) {
+      super(e.Code.Timeout, e.Label.Timeout, n, i);
+    }
+    static {
+      this.code = e.Code.Timeout;
+    }
+  }
+  e.Timeout = Z;
+})(r || (r = {}));
+const f = {};
+f[r.Code.Parse] = r.Parse, f[r.Code.Null] = r.Null, f[r.Code.Div0] = r.Div0, f[r.Code.Value] = r.Value, f[r.Code.Ref] = r.Ref, f[r.Code.Name] = r.Name, f[r.Code.Num] = r.Num, f[r.Code.NA] = r.NA, f[r.Code.GettingData] = r.GettingData, f[r.Code.Spill] = r.Spill, f[r.Code.Connect] = r.Connect, f[r.Code.Blocked] = r.Blocked, f[r.Code.Unknown] = r.Unknown, f[r.Code.Field] = r.Field, f[r.Code.Calc] = r.Calc, f[r.Code.Busy] = r.Busy, f[r.Code.Python] = r.Python, f[r.Code.Timeout] = r.Timeout;
+const ce = /* @__PURE__ */ new Map(), ie = /* @__PURE__ */ new Map(), de = /* @__PURE__ */ new Map(), ue = /* @__PURE__ */ new Map(), le = Object.keys(f);
+for (let e = 0; e < le.length; e++) {
+  const a = le[e], T = f[a];
+  de.set(r.Label[a], T), ue.set(r.Code[a], T);
+  const x = new T();
+  ce.set(x.getLabel(), x), ie.set(x.getCode(), x);
+}
+const ge = ie.get(r.Code.Unknown);
+var p;
+(p = r || (r = {})).BuiltIn = { Parse: new p.Parse(), Null: new p.Null(), Div0: new p.Div0(), Value: new p.Value(), Ref: new p.Ref(), Name: new p.Name(), Num: new p.Num(), NA: new p.NA(), GettingData: new p.GettingData(), Spill: new p.Spill(), Connect: new p.Connect(), Blocked: new p.Blocked(), Unknown: new p.Unknown(), Field: new p.Field(), Calc: new p.Calc(), Busy: new p.Busy(), Python: new p.Python(), Timeout: new p.Timeout() }, p.getBuiltInByLabel = (e) => ce.get(e), p.newTypedError = (e, a, T) => {
+  let x;
+  return x = typeof e == "string" ? de.get(e) : ue.get(e), x || (x = p.Unknown), new x(a, T);
+}, p.getBuiltInById = (e) => ie.get(e) || ge;
+let A = null, H = null;
+const we = { compilerOptions: { target: "esnext" } }, Ce = async () => `
+  interface FirstTest {
+    isTrue?: boolean;
+  }
+`, pe = /* @__PURE__ */ new Map([["IReferenceRange", "r"], ["IRange", "l"]]), me = /* @__PURE__ */ new Map([["IWorkbook", "workbook"], ["ISheet", "sheet"], ["ICellRanges", "ranges"], ["ICellRange", "range"], ["IFormulaContext", "context"]]), ne = (e, a) => {
+  Array.from(a.keys()).forEach((T) => {
+    const x = a.get(T);
+    a.set(`${e}.${T}`, x);
+  });
+}, xe = /* @__PURE__ */ new Map([["Scalar", "*"], ["FormulaError.Known", "e"], ["Date", "Date"], ["JSON", "JSON"]]), be = /* @__PURE__ */ new Map([]), oe = "SheetXL";
+ne(oe, pe), ne(oe, me), ne(oe, be);
+const ke = /* @__PURE__ */ new Map([["Promise", () => ({ async: !0 })], ["Observable", () => ({ stream: !0 })]]);
+let W = null;
+async function Te() {
+  if (W) return W;
+  try {
+    return await (await import("./CcARDY0PFSWkqsG9.mjs")).initialize();
+  } catch (e) {
+    throw W = null, e;
+  } finally {
+    W = null;
+  }
+}
+async function Se(e) {
+  const a = e?.source ?? null;
+  if (!a) return null;
+  const T = (e.disableBundle || e.declarationsOnly) ?? !1, x = [Ce(), Te()], j = await Promise.all(x), X = j[0], s = j[1];
+  let K = "", U = null;
+  const z = [], Y = { allowJs: !0, declaration: !1, sourceMap: !1, inlineSourceMap: !1, inlineSources: !1, isolatedModules: !0, preserveConstEnums: !1, module: 99, noResolve: !0, emitDeclarationOnly: !1, target: s.ScriptTarget.ES2020 }, M = "script", I = `${M}.ts`, G = "lib.d.ts", _ = "global.d.ts", F = { [I]: a, [G]: `
+/**
+ * Represents the completion of an asynchronous operation
+ */
+interface Promise<T> {
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): Promise<T>;
+}
+`, [_]: X }, Q = { getSourceFile: (t, d, E, l) => s.createSourceFile(t, F[t], s.ScriptTarget.Latest, !0), fileExists: (t) => F[t] !== void 0, readFile: (t) => F[t], writeFile: (t, d) => {
+    F[t] = d;
+  }, getCurrentDirectory: () => "./", getCanonicalFileName: (t) => t, useCaseSensitiveFileNames: () => !0, getDefaultLibFileName: (t) => G, getNewLine: () => `
+` }, O = s.createProgram([I, _], Y, Q), P = O.getTypeChecker(), Z = O.getSourceFile(I), y = O.emit();
+  y.diagnostics.length > 0 && console.warn(y.diagnostics), K = F[`${M}.js`];
+  const n = (t, d, E, l) => {
+    if (t) {
+      if (t.kind === s.SyntaxKind.NumberKeyword) d.scalar = "n";
+      else if (t.kind === s.SyntaxKind.StringKeyword) d.scalar = "s";
+      else if (t.kind === s.SyntaxKind.BooleanKeyword) d.scalar = "b";
+      else if (t.kind === s.SyntaxKind.UndefinedKeyword || t.kind === s.SyntaxKind.NullKeyword || t.kind === s.SyntaxKind.VoidKeyword) {
+        if (l) return void S(t, new Error(`'undefined' is not a valid type for input: '${t?.parent?.name?.escapedText}'.`));
+        d.scalar = "z";
+      } else if (t.kind === s.SyntaxKind.BigIntKeyword) d.scalar = "n";
+      else if (t.kind === s.SyntaxKind.AnyKeyword) d.scalar = "z";
+      else if (t.kind === s.SyntaxKind.ArrayType) {
+        const c = t.elementType;
+        if (!c) return void S(t, new Error(`'Array' must be typed: '${t?.parent?.name?.escapedText}'.`));
+        d.arrayDepth = (d.arrayDepth ?? 0) + 1, n(c, d, E, l);
+      } else if (t.kind !== s.SyntaxKind.TupleType && t.kind === s.SyntaxKind.TypeReference) {
+        const c = t.typeName?.getText?.() ?? null, N = pe.get(c);
+        let k = !1;
+        N && (d.range = N, k = !0);
+        const D = xe.get(c);
+        if (D && (d.scalar = D), D !== void 0 && (k = !0), l) {
+          const g = me.get(c);
+          if (g) return g;
+        } else {
+          const g = ke.get(c);
+          if (g) {
+            const m = { ...d, ...g() };
+            let o = 0;
+            if (m.async && o++, m.stream && o++, o > 1) return void S(t, new Error(`'${c}' cannot have multiple modifiers: '${t?.parent?.name?.escapedText}'.`));
+            d = m, k = !0;
+          }
+        }
+        if (!k) return void S("node", new Error(`'${c}' is not a valid type: '${t?.parent?.name?.escapedText}'.`));
+        const b = t.typeArguments;
+        if (b) {
+          if (b.length !== 1) return void S(t, new Error(`'${c}' must be typed with exactly 1 type: '${t?.parent?.name?.escapedText}'.`));
+          n(b[0], d, E, l);
+        }
+      }
+    } else S(t, new Error(`Type is not defined for '${d?.name ?? "return"}'.`));
+  }, i = [], S = (t, d) => {
+    i.push(d);
+  };
+  if (s.forEachChild(Z, (t) => {
+    if (E = t, (s.getCombinedModifierFlags(E) & s.ModifierFlags.Export) !== 0 && s.isFunctionDeclaration(t)) {
+      const l = {}, c = { parameters: {} }, N = t?.name?.getText();
+      try {
+        l.name = N;
+        const k = P.getSymbolAtLocation(t.name).getDocumentationComment(P);
+        if (k && k.length > 0 && k[0].text) {
+          let m = k[0].text;
+          m = m.replace(/[\r\n]+/g, "\\n").trim(), c.summary = m;
+        }
+        const D = {};
+        n(t.type, D, l, !1), l.returnType = D;
+        const b = {};
+        d = t, (s.getCombinedModifierFlags(d) & s.ModifierFlags.Default) !== 0 && (b.default = !0, U = N), Object.keys(b).length > 0 && (l.behavior = b), l.parameters = [];
+        const g = /* @__PURE__ */ new Map();
+        for (let m = 0; m < t.parameters.length; m++) {
+          const o = t.parameters[m], h = {};
+          h.name = o.name?.getText();
+          const $ = n(o.type, h, l, !0);
+          if ($) {
+            if (l.parameters.length !== 0) {
+              const B = t?.parent, C = B?.name?.getText();
+              return void S(t, new Error(`'${l.name}' contexts must be the first parameter: '${C}'.`));
+            }
+            l.context = $;
+            continue;
+          }
+          let L;
+          if ((o.initializer !== void 0 && o.initializer !== null || o.questionToken !== void 0 && o.questionToken !== null) && (h.optional = !0, o.initializer)) try {
+            L = o.initializer.kind === s.SyntaxKind.StringLiteral ? o.initializer.text : o.initializer.kind === s.SyntaxKind.NumericLiteral ? parseFloat(o.initializer.text) : o.initializer.kind === s.SyntaxKind.TrueKeyword || o.initializer.kind === s.SyntaxKind.FalseKeyword ? o.initializer.kind === s.SyntaxKind.TrueKeyword : o.initializer.kind === s.SyntaxKind.NullKeyword ? null : o.initializer.kind === s.SyntaxKind.ObjectLiteralExpression || o.initializer.kind === s.SyntaxKind.ArrayLiteralExpression ? o.initializer.getText() : o.initializer.getText?.();
+          } catch (B) {
+            console.warn(`Couldn't extract default value for parameter '${h.name}'`, B);
+          }
+          o.dotDotDotToken && (h.rest = !0), l.parameters.push(h);
+          const w = { description: "" };
+          c.parameters[h.name] = w;
+          const u = P.getSymbolAtLocation(o.name).getDocumentationComment(P);
+          u && u.length > 0 && u[0].text && (w.description = u[0].text), L !== void 0 && (w.defaultValue = L), g.set(h.name, h);
+        }
+        if (t.jsDoc && t.jsDoc.length > 0) {
+          const m = t.jsDoc;
+          for (let o = 0; o < m.length; o++) {
+            const h = m[o]?.tags;
+            if (h) for (let $ = 0; $ < h.length; $++) {
+              const L = h[$];
+              let w = L?.tagName?.text;
+              if (!w) continue;
+              w = w.toLowerCase();
+              let u = L.comment;
+              const B = w === "hidden";
+              if ((typeof u == "string" || B) && (typeof u == "string" && (u = u.replace(/[\r\n]+/g, "\\n").trim()), B || !u || (u = u.split(/\\n/)[0], u && u.length !== 0))) {
+                if (u && typeof u == "string") {
+                  const C = /\{@link(code|plain)?\s+([^}|]+)(?:\s*\|\s*([^}]+))?\}/g;
+                  let v, R = u, V = [];
+                  for (; (v = C.exec(u)) !== null; ) {
+                    const [ee, te, ye, ae] = v, fe = [ye.trim()];
+                    ae && fe.push(ae.trim());
+                  }
+                  u = R, V.length > 0 && w === "see" && (c.links || (c.links = []), c.links.push(...V));
+                }
+                if (w === "name") {
+                  const C = u;
+                  C !== N && (c.name = C);
+                } else if (w !== "description") {
+                  if (w === "summary") {
+                    const C = u;
+                    C && (c.summary = C);
+                  } else if (w === "param") {
+                    const C = L.name?.text, v = g.get(C);
+                    if (!v) {
+                      i.push(new Error(`Parameter '${C}' not found in function '${N}'.`));
+                      continue;
+                    }
+                    if (L.typeExpression && L.typeExpression.type) try {
+                      const R = L.typeExpression.type;
+                      if (R.kind === s.SyntaxKind.UnionType) {
+                        const V = [];
+                        v.enums = V, R.types.forEach((ee) => {
+                          if (ee.kind === s.SyntaxKind.LiteralType) {
+                            const te = ee.literal.text;
+                            te && V.push(te);
+                          }
+                        });
+                      }
+                    } catch (R) {
+                      console.warn("Error parsing JSDoc type expression:", R);
+                    }
+                  } else if (w === "returns" || w === "return") l.returnType.description = u;
+                  else if (w === "category") c.category = u;
+                  else if (w === "hidden") {
+                    let C = !0;
+                    const v = u?.toLowerCase();
+                    v === "false" ? C = !1 : v !== "true" && (C = u), C !== !1 && (c.hidden = C ?? !0);
+                  }
+                }
+              }
+            }
+          }
+        }
+        Object.keys(l.returnType).length === 0 && delete l.returnType, z.push([l, c]);
+      } catch (k) {
+        S(t, new Error(`'${N}': ${k.message}`));
+      }
+    }
+    var d, E;
+  }), i.length > 0) throw console.warn(i), new Error("There were compilation errors.", { cause: i });
+  if (z.length === 0) throw new Error("No exported functions.");
+  const J = `${he.uuidV4()}-script`;
+  try {
+    T || i.length !== 0 || (K = await async function(t, d, E = "/script.js", l = "__SHEETXL") {
+      try {
+        const c = await async function() {
+          if (A) return A;
+          if (H) {
+            if (await H, !A) throw new Error("ESBuild initialization promise resolved, but instance is not available.");
+            return A;
+          }
+          let g, m;
+          H = new Promise((o, h) => {
+            g = o, m = h;
+          });
+          try {
+            const { initialize: o } = await import("./B8TNpfJ8ymQcPriE.mjs");
+            return A = await o(), g(), A;
+          } catch (o) {
+            throw console.error("Failed to import or initialize esbuild:", o), H = null, m(o), o;
+          }
+        }(), N = "@sheetxl/primitives", k = `
+      export const FormulaContext = globalThis.${l}?.FormulaContext;
+      export const ScalarType = globalThis.${l}?.ScalarType;
+      export const Observable = globalThis.${l}?.Observable;
+      export const IRange = globalThis.${l}?.IRange;
+      export const FormulaError = globalThis.${l}?.FormulaError;
+      // Add more exports as needed
+    `, D = { name: "sheetxl-esbuild-in-memory", setup(g) {
+          const m = "sheetxl-" + (/* @__PURE__ */ new Date()).getTime();
+          g.onResolve({ filter: new RegExp(`^(${E.replace("/", "\\/")}|${N})$`) }, (o) => ({ path: o.path, namespace: m })), g.onResolve({ filter: /.*/ }, (o) => {
+            if (o.namespace !== m) return console.warn(`esbuild: Treating import "${o.path}" as external.`), { path: o.path, external: !0 };
+          }), g.onLoad({ filter: /.*/, namespace: m }, (o) => {
+            let h;
+            if (o.path === E) h = d;
+            else {
+              if (o.path !== N) return { errors: [{ text: `Cannot load unknown path in ${m}: ${o.path}` }] };
+              h = k;
+            }
+            return { contents: h, loader: "ts" };
+          });
+        } }, b = await c.build({ entryPoints: [E], bundle: !0, write: !1, format: "esm", plugins: [D], sourcemap: "inline", tsconfigRaw: we, minify: !0, platform: "neutral" });
+        if (b.outputFiles && b.outputFiles.length > 0) return b.outputFiles[0].text;
+        throw b.errors && b.errors.length > 0 ? new Error(`esbuild bundling failed: ${b.errors.map((g) => g.text).join(`
+`)}`) : new Error("esbuild did not produce an output file.");
+      } catch (c) {
+        throw console.error("esbuild bundling process failed:", c), c;
+      }
+    }(0, K, M));
+  } catch {
+    console.warn("Error bundling script");
+  }
+  const re = { functions: z, commitId: J, source: a, name: "Script", language: "typescript", compiled: K };
+  return U && (re.autoRun = U), re;
+}
+export {
+  Se as compileModule
+};