@gridsheet/core 3.0.0-rc.8

package/dist/formula/functions/uminus.d.ts

@@ -0,0 +1,9 @@
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
+export declare class UminusFunction extends BaseFunction {
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(v1: any): number;
+}
+//# sourceMappingURL=uminus.d.ts.map

package/dist/formula/functions/uminus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uminus.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/uminus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAKtF,qBAAa,cAAe,SAAQ,YAAY;IAC9C,OAAO,SAAe;IACtB,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAEhC;IACF,QAAQ,EAAE,gBAAgB,CAAU;IAEpC,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG;CAGvB"}

package/dist/formula/functions/uminus.js

@@ -0,0 +1,17 @@
+import { BaseFunction as t } from "./__base.js";
+import { ensureNumber as r } from "./__utils.js";
+const s = "Returns a number with positive and negative values reversed.";
+class u extends t {
+  constructor() {
+    super(...arguments), this.example = "UMINUS(4)", this.description = s, this.defs = [
+      { name: "value1", description: "A number that will be subtracted.", acceptedTypes: ["number"] }
+    ], this.category = "math";
+  }
+  main(e) {
+    return -r(e);
+  }
+}
+export {
+  u as UminusFunction
+};
+//# sourceMappingURL=uminus.js.map

package/dist/formula/functions/uminus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uminus.js","sources":["../../../src/formula/functions/uminus.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { ensureNumber } from './__utils';\n\nconst description = `Returns a number with positive and negative values reversed.`;\n\nexport class UminusFunction extends BaseFunction {\n  example = 'UMINUS(4)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    { name: 'value1', description: 'A number that will be subtracted.', acceptedTypes: ['number'] },\n  ];\n  category: FunctionCategory = 'math';\n\n  protected main(v1: any) {\n    return -ensureNumber(v1);\n  }\n}\n"],"names":["description","UminusFunction","BaseFunction","v1","ensureNumber"],"mappings":";;AAGA,MAAMA,IAAc;AAEb,MAAMC,UAAuBC,EAAa;AAAA,EAA1C,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,aACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC,EAAE,MAAM,UAAU,aAAa,qCAAqC,eAAe,CAAC,QAAQ,EAAE;AAAA,IAChG,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,KAAKG,GAAS;AACf,WAAA,CAACC,EAAaD,CAAE;AAAA,EAAA;AAE3B;"}

package/dist/formula/mapping.d.ts

@@ -0,0 +1,11 @@
+import { FunctionCategory, FunctionMapping, FunctionArgumentDefinition } from './functions/__base';
+export declare const functions: FunctionMapping;
+export type FunctionHelp = {
+    name: string;
+    category: FunctionCategory;
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+};
+export declare const getFunctionHelps: (customFunctions?: FunctionMapping) => FunctionHelp[];
+//# sourceMappingURL=mapping.d.ts.map

package/dist/formula/mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapping.d.ts","sourceRoot":"","sources":["../../src/formula/mapping.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAExG,eAAO,MAAM,SAAS,EAAE,eAyCvB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,0BAA0B,EAAE,CAAC;CACpC,CAAC;AAIF,eAAO,MAAM,gBAAgB,GAAI,kBAAiB,eAA2B,KAAG,YAAY,EAiB3F,CAAC"}

package/dist/formula/mapping.js

@@ -0,0 +1,82 @@
+import { AddFunction as p } from "./functions/add.js";
+import { MinusFunction as c } from "./functions/minus.js";
+import { MultiplyFunction as u } from "./functions/multiply.js";
+import { DivideFunction as f } from "./functions/divide.js";
+import { SumFunction as a } from "./functions/sum.js";
+import { ConcatFunction as F } from "./functions/concat.js";
+import { EqFunction as s } from "./functions/eq.js";
+import { NeFunction as l } from "./functions/ne.js";
+import { GtFunction as d } from "./functions/gt.js";
+import { GteFunction as g } from "./functions/gte.js";
+import { LtFunction as w } from "./functions/lt.js";
+import { LteFunction as y } from "./functions/lte.js";
+import { NowFunction as x } from "./functions/now.js";
+import { AndFunction as A } from "./functions/and.js";
+import { OrFunction as M } from "./functions/or.js";
+import { IfFunction as v } from "./functions/if.js";
+import { IfErrorFunction as C } from "./functions/iferror.js";
+import { NotFunction as b } from "./functions/not.js";
+import { CountFunction as h } from "./functions/count.js";
+import { AbsFunction as L } from "./functions/abs.js";
+import { PowerFunction as m } from "./functions/power.js";
+import { CountaFunction as N } from "./functions/counta.js";
+import { AverageFunction as U } from "./functions/average.js";
+import { MaxFunction as _ } from "./functions/max.js";
+import { MinFunction as k } from "./functions/min.js";
+import { LenFunction as q } from "./functions/len.js";
+import { UminusFunction as E } from "./functions/uminus.js";
+import { ArrayformulaFunction as G } from "./functions/arrayformula.js";
+const H = {
+  // Arithmetic & Comparison
+  add: p,
+  minus: c,
+  uminus: E,
+  multiply: u,
+  divide: f,
+  pow: m,
+  power: m,
+  concat: F,
+  eq: s,
+  ne: l,
+  gt: d,
+  gte: g,
+  lt: w,
+  lte: y,
+  // Logical
+  if: v,
+  iferror: C,
+  and: A,
+  or: M,
+  not: b,
+  arrayformula: G,
+  // Statistics & Aggregation
+  sum: a,
+  max: _,
+  min: k,
+  average: U,
+  count: h,
+  counta: N,
+  // Text
+  len: q,
+  // Math
+  abs: L,
+  // Time
+  now: x
+}, e = /* @__PURE__ */ new Map(), uo = (o = H) => {
+  let n = e.get(o);
+  return n || (n = Object.keys(o).map((i) => {
+    const t = o[i], r = new t({ args: [], sheet: {} });
+    return {
+      name: i.toUpperCase(),
+      category: r.category,
+      example: r.example ?? (t == null ? void 0 : t.__name) ?? "Unknown",
+      description: r.description ?? "",
+      defs: r.defs || []
+    };
+  }), e.set(o, n)), n;
+};
+export {
+  H as functions,
+  uo as getFunctionHelps
+};
+//# sourceMappingURL=mapping.js.map

package/dist/formula/mapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapping.js","sources":["../../src/formula/mapping.ts"],"sourcesContent":["import { AddFunction } from './functions/add';\nimport { MinusFunction } from './functions/minus';\nimport { MultiplyFunction } from './functions/multiply';\nimport { DivideFunction } from './functions/divide';\nimport { SumFunction } from './functions/sum';\nimport { ConcatFunction } from './functions/concat';\nimport { EqFunction } from './functions/eq';\nimport { NeFunction } from './functions/ne';\nimport { GtFunction } from './functions/gt';\nimport { GteFunction } from './functions/gte';\nimport { LtFunction } from './functions/lt';\nimport { LteFunction } from './functions/lte';\nimport { NowFunction } from './functions/now';\nimport { AndFunction } from './functions/and';\nimport { OrFunction } from './functions/or';\nimport { IfFunction } from './functions/if';\nimport { IfErrorFunction } from './functions/iferror';\nimport { NotFunction } from './functions/not';\nimport { CountFunction } from './functions/count';\nimport { AbsFunction } from './functions/abs';\nimport { PowerFunction } from './functions/power';\nimport { CountaFunction } from './functions/counta';\nimport { AverageFunction } from './functions/average';\nimport { MaxFunction } from './functions/max';\nimport { MinFunction } from './functions/min';\nimport { LenFunction } from './functions/len';\nimport { UminusFunction } from './functions/uminus';\nimport { ArrayformulaFunction } from './functions/arrayformula';\nimport type { FunctionCategory, FunctionMapping, FunctionArgumentDefinition } from './functions/__base';\n\nexport const functions: FunctionMapping = {\n  // Arithmetic & Comparison\n  add: AddFunction,\n  minus: MinusFunction,\n  uminus: UminusFunction,\n  multiply: MultiplyFunction,\n  divide: DivideFunction,\n  pow: PowerFunction,\n  power: PowerFunction,\n  concat: ConcatFunction,\n  eq: EqFunction,\n  ne: NeFunction,\n  gt: GtFunction,\n  gte: GteFunction,\n  lt: LtFunction,\n  lte: LteFunction,\n\n  // Logical\n  if: IfFunction,\n  iferror: IfErrorFunction,\n  and: AndFunction,\n  or: OrFunction,\n  not: NotFunction,\n  arrayformula: ArrayformulaFunction,\n\n  // Statistics & Aggregation\n  sum: SumFunction,\n  max: MaxFunction,\n  min: MinFunction,\n  average: AverageFunction,\n  count: CountFunction,\n  counta: CountaFunction,\n\n  // Text\n  len: LenFunction,\n\n  // Math\n  abs: AbsFunction,\n\n  // Time\n  now: NowFunction,\n};\n\nexport type FunctionHelp = {\n  name: string;\n  category: FunctionCategory;\n  example: string;\n  description: string;\n  defs: FunctionArgumentDefinition[];\n};\n\nconst _functionHelpsCache = new Map<FunctionMapping, FunctionHelp[]>();\n\nexport const getFunctionHelps = (customFunctions: FunctionMapping = functions): FunctionHelp[] => {\n  let helps = _functionHelpsCache.get(customFunctions);\n  if (!helps) {\n    helps = Object.keys(customFunctions).map((name) => {\n      const FnClass = customFunctions[name];\n      const instance = new FnClass({ args: [], sheet: {} as any });\n      return {\n        name: name.toUpperCase(),\n        category: instance.category,\n        example: instance.example ?? FnClass?.__name ?? 'Unknown',\n        description: instance.description ?? '',\n        defs: instance.defs || [],\n      };\n    });\n    _functionHelpsCache.set(customFunctions, helps);\n  }\n  return helps;\n};\n"],"names":["functions","AddFunction","MinusFunction","UminusFunction","MultiplyFunction","DivideFunction","PowerFunction","ConcatFunction","EqFunction","NeFunction","GtFunction","GteFunction","LtFunction","LteFunction","IfFunction","IfErrorFunction","AndFunction","OrFunction","NotFunction","ArrayformulaFunction","SumFunction","MaxFunction","MinFunction","AverageFunction","CountFunction","CountaFunction","LenFunction","AbsFunction","NowFunction","_functionHelpsCache","getFunctionHelps","customFunctions","helps","name","FnClass","instance"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BO,MAAMA,IAA6B;AAAA;AAAA,EAExC,KAAKC;AAAA,EACL,OAAOC;AAAA,EACP,QAAQC;AAAA,EACR,UAAUC;AAAA,EACV,QAAQC;AAAA,EACR,KAAKC;AAAA,EACL,OAAOA;AAAA,EACP,QAAQC;AAAA,EACR,IAAIC;AAAA,EACJ,IAAIC;AAAA,EACJ,IAAIC;AAAA,EACJ,KAAKC;AAAA,EACL,IAAIC;AAAA,EACJ,KAAKC;AAAA;AAAA,EAGL,IAAIC;AAAA,EACJ,SAASC;AAAA,EACT,KAAKC;AAAA,EACL,IAAIC;AAAA,EACJ,KAAKC;AAAA,EACL,cAAcC;AAAA;AAAA,EAGd,KAAKC;AAAA,EACL,KAAKC;AAAA,EACL,KAAKC;AAAA,EACL,SAASC;AAAA,EACT,OAAOC;AAAA,EACP,QAAQC;AAAA;AAAA,EAGR,KAAKC;AAAA;AAAA,EAGL,KAAKC;AAAA;AAAA,EAGL,KAAKC;AACP,GAUMC,wBAA0B,IAAqC,GAExDC,KAAmB,CAACC,IAAmC/B,MAA8B;AAC5F,MAAAgC,IAAQH,EAAoB,IAAIE,CAAe;AACnD,SAAKC,MACHA,IAAQ,OAAO,KAAKD,CAAe,EAAE,IAAI,CAACE,MAAS;AAC3C,UAAAC,IAAUH,EAAgBE,CAAI,GAC9BE,IAAW,IAAID,EAAQ,EAAE,MAAM,IAAI,OAAO,CAAA,GAAW;AACpD,WAAA;AAAA,MACL,MAAMD,EAAK,YAAY;AAAA,MACvB,UAAUE,EAAS;AAAA,MACnB,SAASA,EAAS,YAAWD,KAAA,gBAAAA,EAAS,WAAU;AAAA,MAChD,aAAaC,EAAS,eAAe;AAAA,MACrC,MAAMA,EAAS,QAAQ,CAAA;AAAA,IACzB;AAAA,EAAA,CACD,GACmBN,EAAA,IAAIE,GAAiBC,CAAK,IAEzCA;AACT;"}

package/dist/formula/solver.d.ts

@@ -0,0 +1,39 @@
+import { Sheet } from '../lib/sheet';
+import { Id, MatrixType, PointType, Resolution } from '../types';
+export type SolveOptions = {
+    raise?: boolean;
+    resolution?: Resolution;
+};
+type SolveFormulaProps = {
+    value: any;
+    sheet: Sheet;
+    point: PointType;
+    raise?: boolean;
+    resolution?: Resolution;
+    at?: Id;
+};
+/**
+ * Evaluates a single cell value (formula or literal) within the context of a sheet.
+ * Handles caching, circular reference detection, spilling, and async pending states.
+ * Returns the resolved scalar value (or error) for the given cell.
+ */
+export declare const solveFormula: ({ value, sheet, point, raise, resolution, at }: SolveFormulaProps) => any;
+export type SolveSheetProps = {
+    sheet: Sheet;
+    raise?: boolean;
+    at?: Id;
+};
+/**
+ * Evaluates all cells in a Sheet and returns the results as a 2D array (MatrixType).
+ * Each cell formula is resolved in order, with caching to avoid redundant computation.
+ * Use this when you need the full evaluated contents of a range.
+ */
+export declare const solveSheet: ({ sheet, raise, at }: SolveSheetProps) => MatrixType;
+export type StripSheetProps = {
+    value: any;
+    at?: Id;
+    raise?: boolean;
+};
+export declare const stripSheet: ({ value, at, raise }: StripSheetProps) => any;
+export {};
+//# sourceMappingURL=solver.d.ts.map

package/dist/formula/solver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solver.d.ts","sourceRoot":"","sources":["../../src/formula/solver.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,KAAK,EAAE,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAItE,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB,CAAC;AAEF,KAAK,iBAAiB,GAAG;IACvB,KAAK,EAAE,GAAG,CAAC;IACX,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,EAAE,CAAC,EAAE,EAAE,CAAC;CACT,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,gDAAoE,iBAAiB,QA+DjH,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,EAAE,CAAC,EAAE,EAAE,CAAC;CACT,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,sBAA6B,eAAe,KAAG,UAgCzE,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,GAAG,CAAC;IACX,EAAE,CAAC,EAAE,EAAE,CAAC;IACR,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,sBAA6B,eAAe,KAAG,GAKzE,CAAC"}

package/dist/formula/solver.js

@@ -0,0 +1,71 @@
+import { SOLVING as u, Spilling as R, Pending as g } from "../sentinels.js";
+import { Sheet as w } from "../lib/sheet.js";
+import { Lexer as d, Parser as x } from "./evaluator.js";
+import { FormulaError as E } from "./formula-error.js";
+const y = ({ value: r, sheet: n, point: o, raise: s = !0, resolution: l = "RESOLVED", at: S }) => {
+  var a, m;
+  const [h, c] = n.getSolvedCache(o);
+  if (h && r == null && !u.is(c))
+    return c;
+  if (typeof r != "string" || l === "SYSTEM")
+    return r;
+  if (r.charAt(0) === "'")
+    return l === "RAW" ? r : r.substring(1);
+  if (r.charAt(0) !== "=")
+    return r;
+  if (l === "RAW") {
+    const e = new d(r.substring(1), { at: S });
+    return e.tokenize(), "=" + e.display({ sheet: n });
+  }
+  let t = r;
+  if (h && !u.is(c))
+    t = c;
+  else
+    try {
+      const e = new d(r.substring(1), { at: S });
+      e.tokenize();
+      const i = new x(e.tokens).build();
+      t = (a = i == null ? void 0 : i.evaluate) == null ? void 0 : a.call(i, { sheet: n });
+    } catch (e) {
+      if (s)
+        throw n.finishSolvedCache(o, e), e;
+      return e;
+    }
+  return l === "RESOLVED" && t instanceof w && (t = (m = p({ sheet: t, raise: s, at: S })[0]) == null ? void 0 : m[0]), R.is(t) ? t = n.spill(o, t.matrix) : n.finishSolvedCache(o, t), g.is(t) && n.finishSolvedCache(o, t), t;
+}, p = ({ sheet: r, raise: n = !0, at: o }) => {
+  const s = r.area;
+  return r._toValueMatrix({ area: s, at: o, resolution: "SYSTEM" }).map((S, h) => {
+    const c = s.top + h;
+    return S.map((t, a) => {
+      const m = s.left + a, e = { y: c, x: m }, [C, i] = r.getSolvedCache(e);
+      try {
+        if (u.is(i))
+          throw new E("#REF!", "References are circulating.", new Error(t));
+        if (g.is(i))
+          return i;
+        if (E.is(i))
+          throw i;
+        if (i != null)
+          return i;
+        r.setSolvingCache(e);
+        const f = y({ value: t, sheet: r, point: e, raise: n, at: o, resolution: "RESOLVED" });
+        return r.finishSolvedCache(e, f), f;
+      } catch (f) {
+        if (r.finishSolvedCache(e, f), n)
+          throw f;
+        return f;
+      }
+    });
+  });
+}, O = ({ value: r, at: n, raise: o = !0 }) => {
+  var s;
+  for (; r instanceof w; )
+    r = (s = p({ sheet: r, raise: o, at: n })[0]) == null ? void 0 : s[0];
+  return r;
+};
+export {
+  y as solveFormula,
+  p as solveSheet,
+  O as stripSheet
+};
+//# sourceMappingURL=solver.js.map

package/dist/formula/solver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solver.js","sources":["../../src/formula/solver.ts"],"sourcesContent":["import { Pending, SOLVING, Spilling } from '../sentinels';\nimport { Sheet } from '../lib/sheet';\nimport type { Id, MatrixType, PointType, Resolution } from '../types';\nimport { Lexer, Parser } from './evaluator';\nimport { FormulaError } from './formula-error';\n\nexport type SolveOptions = {\n  raise?: boolean;\n  resolution?: Resolution;\n};\n\ntype SolveFormulaProps = {\n  value: any;\n  sheet: Sheet;\n  point: PointType;\n  raise?: boolean;\n  resolution?: Resolution;\n  at?: Id;\n};\n\n/**\n * Evaluates a single cell value (formula or literal) within the context of a sheet.\n * Handles caching, circular reference detection, spilling, and async pending states.\n * Returns the resolved scalar value (or error) for the given cell.\n */\nexport const solveFormula = ({ value, sheet, point, raise = true, resolution = 'RESOLVED', at }: SolveFormulaProps) => {\n  const [hit, cache] = sheet.getSolvedCache(point);\n  if (hit && value == null && !SOLVING.is(cache)) {\n    // spilled value\n    return cache;\n  }\n\n  if (typeof value !== 'string') {\n    return value;\n  }\n  if (resolution === 'SYSTEM') {\n    return value;\n  }\n  if (value.charAt(0) === \"'\") {\n    return resolution === 'RAW' ? value : value.substring(1);\n  }\n  if (value.charAt(0) !== '=') {\n    return value;\n  }\n  if (resolution === 'RAW') {\n    const lexer = new Lexer(value.substring(1), { at });\n    lexer.tokenize();\n    return '=' + lexer.display({ sheet });\n  }\n\n  let solved: any = value;\n  if (hit && !SOLVING.is(cache)) {\n    solved = cache;\n  } else {\n    try {\n      const lexer = new Lexer(value.substring(1), { at });\n      lexer.tokenize();\n      const parser = new Parser(lexer.tokens);\n      const expr = parser.build();\n      solved = expr?.evaluate?.({ sheet });\n    } catch (e) {\n      if (raise) {\n        sheet.finishSolvedCache(point, e);\n        throw e;\n      }\n      return e;\n    }\n  }\n\n  if (resolution === 'RESOLVED' && solved instanceof Sheet) {\n    // Unwrap to scalar (top-left cell of the sheet's area).\n    // NOTE: We intentionally call solveSheet directly here instead of stripSheet,\n    // to avoid a three-way cycle: solveFormula → stripSheet → solveSheet → solveFormula.\n    // The mutual recursion between solveFormula and solveSheet is unavoidable by design,\n    // but routing through stripSheet would make the call graph harder to follow and reason about.\n    solved = solveSheet({ sheet: solved, raise, at })[0]?.[0];\n  }\n  // 'EVALUATED' resolution: keep Sheet objects intact (range formulas return Sheet, not scalar).\n\n  if (Spilling.is(solved)) {\n    solved = sheet.spill(point, solved.matrix);\n  } else {\n    sheet.finishSolvedCache(point, solved);\n  }\n  if (Pending.is(solved)) {\n    sheet.finishSolvedCache(point, solved);\n  }\n  return solved;\n};\n\nexport type SolveSheetProps = {\n  sheet: Sheet;\n  raise?: boolean;\n  at?: Id;\n};\n\n/**\n * Evaluates all cells in a Sheet and returns the results as a 2D array (MatrixType).\n * Each cell formula is resolved in order, with caching to avoid redundant computation.\n * Use this when you need the full evaluated contents of a range.\n */\nexport const solveSheet = ({ sheet, raise = true, at }: SolveSheetProps): MatrixType => {\n  const area = sheet.area;\n  const matrix = sheet._toValueMatrix({ area, at, resolution: 'SYSTEM' });\n  return matrix.map((row, i) => {\n    const y = area.top + i;\n    return row.map((value, j) => {\n      const x = area.left + j;\n      const point = { y, x };\n      const [hit, cache] = sheet.getSolvedCache(point);\n      try {\n        if (SOLVING.is(cache)) {\n          throw new FormulaError('#REF!', 'References are circulating.', new Error(value as string));\n        } else if (Pending.is(cache)) {\n          return cache;\n        } else if (FormulaError.is(cache)) {\n          throw cache;\n        } else if (cache != null) {\n          return cache;\n        }\n        sheet.setSolvingCache(point);\n        const solved = solveFormula({ value, sheet, point, raise, at, resolution: 'RESOLVED' });\n        sheet.finishSolvedCache(point, solved);\n        return solved;\n      } catch (e) {\n        sheet.finishSolvedCache(point, e);\n        if (raise) {\n          throw e;\n        }\n        return e;\n      }\n    });\n  });\n};\n\nexport type StripSheetProps = {\n  value: any;\n  at?: Id;\n  raise?: boolean;\n};\n\nexport const stripSheet = ({ value, at, raise = true }: StripSheetProps): any => {\n  while (value instanceof Sheet) {\n    value = solveSheet({ sheet: value, raise, at })[0]?.[0];\n  }\n  return value;\n};\n"],"names":["solveFormula","value","sheet","point","raise","resolution","at","hit","cache","SOLVING","lexer","Lexer","solved","expr","Parser","_a","Sheet","_b","solveSheet","Spilling","Pending","area","row","i","y","j","x","FormulaError","e","stripSheet"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export { oa2aa, aa2oa, buildInitialCells, buildInitialCellsFromOrigin, zoneToArea, areaToZone, areaToRange, matrixShape, addressesToAreas, addressesToCols, addressesToRows, } from './lib/spatial';
+export { Time } from './lib/time';
+export { x2c, c2x, y2r, r2y, p2a, a2p, rh, ch } from './lib/coords';
+export type { CSSPropertiesLike, RefLike, Resolution, Y, X, Height, Width, ShapeType, RectType, MatrixType, CursorStateType, FeedbackType, ModeType, HeadersType, AsyncCache, System, FilterConditionMethod, FilterCondition, FilterConfig, CellType, RawCellType, CellPatchType, CellFilter, CellsByAddressType, CellsByIdType, SystemsByIdType, RangeType, PointType, ExtraPointType, PositionType, ZoneType, AreaType, WriterType, Id, Ids, IdMatrix, Address, MatricesByAddress, StorePatchType, HistoryUpdateType, MoveRelation, MoveRelations, HistoryMoveType, HistoryInsertRowsType, HistoryRemoveRowsType, HistoryInsertColsType, HistoryRemoveColsType, HistorySortRowsType, HistoryType, Virtualization, OperatorType, OperationType, Dispatcher, StoreDispatchType, ContextsBySheetId, SheetIdsByName, RefPaletteType, EditorEvent, } from './types';
+export type { BookType, BookProps, RegistryProps, TransmitProps } from './lib/book';
+export { Registry, createBook, createRegistry, createBinding } from './lib/book';
+export { Sheet, type UserSheet, type SheetLimits } from './lib/sheet';
+export { toValueMatrix, toValueObject, toValueRows, toValueCols, toCellMatrix, toCellObject, toCellRows, toCellCols, type ToValueMatrixProps, type ToValueObjectProps, type ToValueRowsProps, type ToValueColsProps, type ToCellMatrixProps, type ToCellObjectProps, type ToCellRowsProps, type ToCellColsProps, } from './lib/sheet_utils';
+export { BaseFunction, BaseFunctionAsync } from './formula/functions/__base';
+export type { FunctionProps, FunctionArgumentDefinition, FunctionCategory, FunctionMapping, } from './formula/functions/__base';
+export { Lexer, FormulaParser, RefEntity, ValueEntity, RangeEntity } from './formula/evaluator';
+export { FormulaError } from './formula/formula-error';
+export { ensureString, ensureNumber, ensureBoolean, ensureDate, check, eachMatrix, createBooleanMask, } from './formula/functions/__utils';
+export type { EnsureNumberOptions, EnsureBooleanOptions } from './formula/functions/__utils';
+export { conditionArg, stripMatrix } from './formula/functions/__base';
+export { Policy } from './policy/core';
+export type { PolicyType, AutocompleteOption, PolicyMixinType, RenderProps, SerializeProps, SelectProps, SelectFallbackProps, SerializeForClipboardProps, } from './policy/core';
+export { ThousandSeparatorPolicyMixin } from './policy/thousand_separator';
+export * as operations from './lib/operation';
+export { DEFAULT_HISTORY_LIMIT } from './constants';
+export { Pending, Spilling } from './sentinels';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,74 @@
+import { aa2oa as t, addressesToAreas as a, addressesToCols as i, addressesToRows as s, areaToRange as l, areaToZone as n, buildInitialCells as p, buildInitialCellsFromOrigin as x, matrixShape as m, oa2aa as c, zoneToArea as u } from "./lib/spatial.js";
+import { Time as d } from "./lib/time.js";
+import { a2p as g, c2x as y, ch as C, p2a as R, r2y as h, rh as M, x2c as b, y2r as B } from "./lib/coords.js";
+import { Registry as S, createBinding as A, createBook as E, createRegistry as I } from "./lib/book.js";
+import { Sheet as O } from "./lib/sheet.js";
+import { toCellCols as k, toCellMatrix as w, toCellObject as L, toCellRows as _, toValueCols as j, toValueMatrix as D, toValueObject as z, toValueRows as H } from "./lib/sheet_utils.js";
+import { BaseFunction as U, BaseFunctionAsync as Y, conditionArg as Z, stripMatrix as q } from "./formula/functions/__base.js";
+import { FormulaParser as G, Lexer as J, RangeEntity as K, RefEntity as Q, ValueEntity as W } from "./formula/evaluator.js";
+import { FormulaError as $ } from "./formula/formula-error.js";
+import { check as oe, createBooleanMask as re, eachMatrix as te, ensureBoolean as ae, ensureDate as ie, ensureNumber as se, ensureString as le } from "./formula/functions/__utils.js";
+import { Policy as pe } from "./policy/core.js";
+import { ThousandSeparatorPolicyMixin as me } from "./policy/thousand_separator.js";
+import * as e from "./lib/operation.js";
+import { DEFAULT_HISTORY_LIMIT as ue } from "./constants.js";
+import { Pending as de, Spilling as Te } from "./sentinels.js";
+export {
+  U as BaseFunction,
+  Y as BaseFunctionAsync,
+  ue as DEFAULT_HISTORY_LIMIT,
+  $ as FormulaError,
+  G as FormulaParser,
+  J as Lexer,
+  de as Pending,
+  pe as Policy,
+  K as RangeEntity,
+  Q as RefEntity,
+  S as Registry,
+  O as Sheet,
+  Te as Spilling,
+  me as ThousandSeparatorPolicyMixin,
+  d as Time,
+  W as ValueEntity,
+  g as a2p,
+  t as aa2oa,
+  a as addressesToAreas,
+  i as addressesToCols,
+  s as addressesToRows,
+  l as areaToRange,
+  n as areaToZone,
+  p as buildInitialCells,
+  x as buildInitialCellsFromOrigin,
+  y as c2x,
+  C as ch,
+  oe as check,
+  Z as conditionArg,
+  A as createBinding,
+  E as createBook,
+  re as createBooleanMask,
+  I as createRegistry,
+  te as eachMatrix,
+  ae as ensureBoolean,
+  ie as ensureDate,
+  se as ensureNumber,
+  le as ensureString,
+  m as matrixShape,
+  c as oa2aa,
+  e as operations,
+  R as p2a,
+  h as r2y,
+  M as rh,
+  q as stripMatrix,
+  k as toCellCols,
+  w as toCellMatrix,
+  L as toCellObject,
+  _ as toCellRows,
+  j as toValueCols,
+  D as toValueMatrix,
+  z as toValueObject,
+  H as toValueRows,
+  b as x2c,
+  B as y2r,
+  u as zoneToArea
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;"}

package/dist/lib/autofill.d.ts

@@ -0,0 +1,22 @@
+import { AreaType, CSSPropertiesLike, PointType, RefLike, ZoneType } from '../types';
+import { Sheet } from './sheet';
+type AutofillStore = {
+    sheetReactive: RefLike<Sheet>;
+    choosing: PointType;
+    selectingZone: ZoneType;
+};
+export declare class Autofill {
+    private readonly src;
+    private readonly dst;
+    private readonly direction;
+    private readonly sheet;
+    constructor(store: AutofillStore, draggingTo: PointType);
+    get applied(): Sheet;
+    get wholeArea(): AreaType;
+    getCellStyle(target: PointType): CSSPropertiesLike;
+    private getDestinationArea;
+    private suggestDirection;
+    private getChangePatterns;
+}
+export {};
+//# sourceMappingURL=autofill.d.ts.map

package/dist/lib/autofill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autofill.d.ts","sourceRoot":"","sources":["../../src/lib/autofill.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAgC,iBAAiB,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACxH,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAKhC,KAAK,aAAa,GAAG;IACnB,aAAa,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IAC9B,QAAQ,EAAE,SAAS,CAAC;IACpB,aAAa,EAAE,QAAQ,CAAC;CACzB,CAAC;AAgBF,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAW;IAC/B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAW;IAC/B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IACtC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;gBAClB,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,SAAS;IAYvD,IAAW,OAAO,IAAI,KAAK,CAiE1B;IAED,IAAW,SAAS,aAEnB;IAEM,YAAY,CAAC,MAAM,EAAE,SAAS;IAmErC,OAAO,CAAC,kBAAkB;IAgB1B,OAAO,CAAC,gBAAgB;IA8BxB,OAAO,CAAC,iBAAiB;CA4F1B"}