@ricsam/formula-engine 0.0.1

package/dist/mjs/core/managers/workbook-manager.mjs

@@ -0,0 +1,447 @@
+// src/core/managers/workbook-manager.ts
+import { getCellReference, parseCellReference } from "../utils.mjs";
+import { buildRangeEvalOrder } from "./range-eval-order-builder.mjs";
+import {
+  SheetNotFoundError,
+  WorkbookNotFoundError
+} from "src/evaluator/evaluation-error";
+import { normalizeSerializedCellValue } from "src/parser/formatter";
+
+class IndexEntryBinarySearch {
+  static findInsertionPoint(entries, target) {
+    let left = 0;
+    let right = entries.length;
+    while (left < right) {
+      const mid = Math.floor((left + right) / 2);
+      const midEntry = entries[mid];
+      if (midEntry && midEntry.number < target) {
+        left = mid + 1;
+      } else {
+        right = mid;
+      }
+    }
+    return left;
+  }
+  static findFirstGreaterOrEqual(entries, target) {
+    if (entries.length === 0)
+      return -1;
+    let left = 0;
+    let right = entries.length - 1;
+    let result = -1;
+    while (left <= right) {
+      const mid = Math.floor((left + right) / 2);
+      const midEntry = entries[mid];
+      if (midEntry && midEntry.number >= target) {
+        result = mid;
+        right = mid - 1;
+      } else {
+        left = mid + 1;
+      }
+    }
+    return result;
+  }
+  static findRightmostInsertionPoint(entries, target) {
+    return IndexEntryBinarySearch.findInsertionPoint(entries, target);
+  }
+}
+
+class WorkbookManager {
+  workbooks = new Map;
+  sheetIndexes = new Map;
+  getSheetIndexKey(workbookName, sheetName) {
+    return `${workbookName}|${sheetName}`;
+  }
+  getSheetIndexes(opts) {
+    const key = this.getSheetIndexKey(opts.workbookName, opts.sheetName);
+    let indexes = this.sheetIndexes.get(key);
+    if (!indexes) {
+      indexes = {
+        rowGroups: new Map,
+        colGroups: new Map,
+        cellsSortedByRow: [],
+        cellsSortedByCol: []
+      };
+      this.sheetIndexes.set(key, indexes);
+    }
+    return indexes;
+  }
+  getSheets(workbookName) {
+    const workbook = this.workbooks.get(workbookName);
+    if (!workbook) {
+      throw new WorkbookNotFoundError(workbookName);
+    }
+    return workbook.sheets;
+  }
+  getWorkbooks() {
+    return this.workbooks;
+  }
+  addWorkbook(workbookName) {
+    if (this.workbooks.has(workbookName)) {
+      throw new Error("Workbook already exists");
+    }
+    this.workbooks.set(workbookName, {
+      name: workbookName,
+      sheets: new Map
+    });
+  }
+  removeWorkbook(workbookName) {
+    const workbook = this.workbooks.get(workbookName);
+    if (!workbook) {
+      throw new WorkbookNotFoundError(workbookName);
+    }
+    for (const sheetName of workbook.sheets.keys()) {
+      const key = this.getSheetIndexKey(workbookName, sheetName);
+      this.sheetIndexes.delete(key);
+    }
+    this.workbooks.delete(workbookName);
+  }
+  isContentEmpty(content) {
+    return content === "" || content === undefined;
+  }
+  renameWorkbook(opts) {
+    const workbook = this.workbooks.get(opts.workbookName);
+    if (!workbook) {
+      throw new Error("Workbook not found");
+    }
+    for (const sheetName of workbook.sheets.keys()) {
+      const oldKey = this.getSheetIndexKey(opts.workbookName, sheetName);
+      const newKey = this.getSheetIndexKey(opts.newWorkbookName, sheetName);
+      const indexes = this.sheetIndexes.get(oldKey);
+      if (indexes) {
+        this.sheetIndexes.set(newKey, indexes);
+        this.sheetIndexes.delete(oldKey);
+      }
+    }
+    this.workbooks.set(opts.newWorkbookName, workbook);
+    this.workbooks.delete(opts.workbookName);
+    workbook.name = opts.newWorkbookName;
+  }
+  resetWorkbooks(workbooks) {
+    this.workbooks.clear();
+    this.sheetIndexes.clear();
+    workbooks.forEach((workbook, workbookName) => {
+      this.workbooks.set(workbookName, workbook);
+      workbook.sheets.forEach((sheet) => {
+        const indexes = this.getSheetIndexes({
+          workbookName,
+          sheetName: sheet.name
+        });
+        indexes.rowGroups.clear();
+        indexes.colGroups.clear();
+        indexes.cellsSortedByRow = [];
+        indexes.cellsSortedByCol = [];
+        sheet.content.forEach((value, key) => {
+          this.setCellContent({
+            workbookName,
+            sheetName: sheet.name,
+            colIndex: parseCellReference(key).colIndex,
+            rowIndex: parseCellReference(key).rowIndex
+          }, value, {
+            sheet,
+            buildingFromScratch: true
+          });
+        });
+      });
+    });
+  }
+  getSheet({
+    workbookName,
+    sheetName
+  }) {
+    const workbook = this.workbooks.get(workbookName);
+    const sheet = workbook?.sheets.get(sheetName);
+    return sheet;
+  }
+  addSheet({
+    workbookName,
+    sheetName
+  }) {
+    const workbook = this.workbooks.get(workbookName);
+    if (!workbook) {
+      throw new WorkbookNotFoundError(workbookName);
+    }
+    const sheet = {
+      name: sheetName,
+      index: workbook.sheets.size,
+      content: new Map
+    };
+    if (workbook.sheets.has(sheet.name)) {
+      throw new Error("Sheet already exists");
+    }
+    workbook.sheets.set(sheetName, sheet);
+    this.getSheetIndexes({ workbookName, sheetName });
+    return sheet;
+  }
+  removeSheet({
+    workbookName,
+    sheetName
+  }) {
+    const workbook = this.workbooks.get(workbookName);
+    if (!workbook) {
+      throw new WorkbookNotFoundError(workbookName);
+    }
+    const sheet = workbook.sheets.get(sheetName);
+    if (!sheet) {
+      throw new Error("Sheet not found");
+    }
+    workbook.sheets.delete(sheetName);
+    const key = this.getSheetIndexKey(workbookName, sheetName);
+    this.sheetIndexes.delete(key);
+    return sheet;
+  }
+  renameSheet({
+    workbookName,
+    sheetName,
+    newSheetName
+  }) {
+    const workbook = this.workbooks.get(workbookName);
+    if (!workbook) {
+      throw new WorkbookNotFoundError(workbookName);
+    }
+    const sheet = workbook.sheets.get(sheetName);
+    if (!sheet) {
+      throw new SheetNotFoundError(sheetName);
+    }
+    if (workbook.sheets.has(newSheetName)) {
+      throw new Error("Sheet with new name already exists");
+    }
+    sheet.name = newSheetName;
+    workbook.sheets.set(newSheetName, sheet);
+    workbook.sheets.delete(sheetName);
+    const oldKey = this.getSheetIndexKey(workbookName, sheetName);
+    const newKey = this.getSheetIndexKey(workbookName, newSheetName);
+    const indexes = this.sheetIndexes.get(oldKey);
+    if (indexes) {
+      this.sheetIndexes.set(newKey, indexes);
+      this.sheetIndexes.delete(oldKey);
+    }
+    return sheet;
+  }
+  updateAllFormulas(updateCallback) {
+    const update = (map) => {
+      map.forEach((sheet) => {
+        sheet.content.forEach((cell, key) => {
+          if (typeof cell === "string" && cell.startsWith("=")) {
+            const formula = cell.slice(1);
+            const updatedFormula = updateCallback(formula);
+            if (updatedFormula !== formula) {
+              sheet.content.set(key, `=${updatedFormula}`);
+            }
+          }
+        });
+      });
+    };
+    this.workbooks.forEach((workbook) => {
+      update(workbook.sheets);
+    });
+  }
+  getSheetSerialized({
+    workbookName,
+    sheetName
+  }) {
+    const workbook = this.workbooks.get(workbookName);
+    if (!workbook) {
+      throw new WorkbookNotFoundError(workbookName);
+    }
+    const sheet = workbook.sheets.get(sheetName);
+    if (!sheet) {
+      throw new SheetNotFoundError(sheetName);
+    }
+    return sheet.content;
+  }
+  addCellToGroups(indexes, rowIndex, colIndex, key) {
+    let rowGroup = indexes.rowGroups.get(rowIndex);
+    if (!rowGroup) {
+      rowGroup = [];
+      indexes.rowGroups.set(rowIndex, rowGroup);
+    }
+    const colEntry = { number: colIndex, key };
+    const colInsertIdx = this.findInsertIndex(rowGroup, colIndex);
+    rowGroup.splice(colInsertIdx, 0, colEntry);
+    let colGroup = indexes.colGroups.get(colIndex);
+    if (!colGroup) {
+      colGroup = [];
+      indexes.colGroups.set(colIndex, colGroup);
+    }
+    const rowEntry = { number: rowIndex, key };
+    const rowInsertIdx = this.findInsertIndex(colGroup, rowIndex);
+    colGroup.splice(rowInsertIdx, 0, rowEntry);
+    this.insertSorted(indexes.cellsSortedByRow, { number: rowIndex, key });
+    this.insertSorted(indexes.cellsSortedByCol, { number: colIndex, key });
+  }
+  removeCellFromGroups(indexes, rowIndex, colIndex, key) {
+    const rowGroup = indexes.rowGroups.get(rowIndex);
+    if (rowGroup) {
+      const filteredGroup = rowGroup.filter((e) => e.key !== key);
+      if (filteredGroup.length === 0) {
+        indexes.rowGroups.delete(rowIndex);
+      } else {
+        indexes.rowGroups.set(rowIndex, filteredGroup);
+      }
+    }
+    const colGroup = indexes.colGroups.get(colIndex);
+    if (colGroup) {
+      const filteredGroup = colGroup.filter((e) => e.key !== key);
+      if (filteredGroup.length === 0) {
+        indexes.colGroups.delete(colIndex);
+      } else {
+        indexes.colGroups.set(colIndex, filteredGroup);
+      }
+    }
+    indexes.cellsSortedByRow = indexes.cellsSortedByRow.filter((item) => item.key !== key);
+    indexes.cellsSortedByCol = indexes.cellsSortedByCol.filter((item) => item.key !== key);
+  }
+  findInsertIndex(entries, n) {
+    return IndexEntryBinarySearch.findInsertionPoint(entries, n);
+  }
+  insertSorted(array, item) {
+    const existingIndex = array.findIndex((existing) => existing.number === item.number && existing.key === item.key);
+    if (existingIndex !== -1) {
+      return;
+    }
+    const insertionPoint = IndexEntryBinarySearch.findInsertionPoint(array, item.number);
+    array.splice(insertionPoint, 0, item);
+  }
+  setCellContent(address, content, options) {
+    const sheet = options?.sheet || this.getSheet({
+      sheetName: address.sheetName,
+      workbookName: address.workbookName
+    });
+    if (!sheet) {
+      throw new SheetNotFoundError(address.sheetName);
+    }
+    const indexes = this.getSheetIndexes({
+      workbookName: address.workbookName,
+      sheetName: address.sheetName
+    });
+    const adr = getCellReference(address);
+    if (this.isContentEmpty(content)) {
+      if (!options?.buildingFromScratch) {
+        sheet.content.delete(adr);
+        this.removeCellFromGroups(indexes, address.rowIndex, address.colIndex, adr);
+      }
+    } else {
+      sheet.content.set(adr, content);
+      this.addCellToGroups(indexes, address.rowIndex, address.colIndex, adr);
+    }
+  }
+  setSheetContent(opts, newContent) {
+    const sheet = this.getSheet(opts);
+    if (!sheet) {
+      throw new SheetNotFoundError(opts.sheetName);
+    }
+    sheet.content.clear();
+    const key = this.getSheetIndexKey(opts.workbookName, opts.sheetName);
+    this.sheetIndexes.delete(key);
+    newContent.forEach((value, key2) => {
+      this.setCellContent({
+        workbookName: opts.workbookName,
+        sheetName: opts.sheetName,
+        colIndex: parseCellReference(key2).colIndex,
+        rowIndex: parseCellReference(key2).rowIndex
+      }, value, {
+        sheet,
+        buildingFromScratch: true
+      });
+    });
+  }
+  clearSpreadsheetRange(address) {
+    const sheet = this.getSheet(address);
+    if (!sheet) {
+      throw new SheetNotFoundError(address.sheetName);
+    }
+    const newContent = new Map(sheet.content);
+    for (const cellAddress of this.iterateCellsInRange(address)) {
+      const cellRef = getCellReference(cellAddress);
+      newContent.delete(cellRef);
+    }
+    this.setSheetContent(address, newContent);
+  }
+  *iterateCellsInRange(address) {
+    const sheet = this.getSheet(address);
+    if (!sheet) {
+      throw new SheetNotFoundError(address.sheetName);
+    }
+    const indexes = this.getSheetIndexes(address);
+    const range = address.range;
+    if (range.end.row.type === "number") {
+      const startIndex = IndexEntryBinarySearch.findFirstGreaterOrEqual(indexes.cellsSortedByRow, range.start.row);
+      if (startIndex === -1)
+        return;
+      for (let i = startIndex;i < indexes.cellsSortedByRow.length; i++) {
+        const cellEntry = indexes.cellsSortedByRow[i];
+        if (!cellEntry)
+          continue;
+        const parsed = parseCellReference(cellEntry.key);
+        if (parsed.rowIndex > range.end.row.value)
+          break;
+        if (parsed.colIndex < range.start.col)
+          continue;
+        if (range.end.col.type === "number" && parsed.colIndex > range.end.col.value) {
+          continue;
+        }
+        yield {
+          rowIndex: parsed.rowIndex,
+          colIndex: parsed.colIndex,
+          sheetName: address.sheetName,
+          workbookName: address.workbookName
+        };
+      }
+    } else {
+      const startIndex = IndexEntryBinarySearch.findFirstGreaterOrEqual(indexes.cellsSortedByRow, range.start.row);
+      if (startIndex === -1)
+        return;
+      for (let i = startIndex;i < indexes.cellsSortedByRow.length; i++) {
+        const cellEntry = indexes.cellsSortedByRow[i];
+        if (!cellEntry)
+          continue;
+        const parsed = parseCellReference(cellEntry.key);
+        if (parsed.colIndex < range.start.col)
+          continue;
+        if (range.end.col.type === "number" && parsed.colIndex > range.end.col.value) {
+          continue;
+        }
+        yield {
+          rowIndex: parsed.rowIndex,
+          colIndex: parsed.colIndex,
+          sheetName: address.sheetName,
+          workbookName: address.workbookName
+        };
+      }
+    }
+  }
+  getCellsInRange(address) {
+    return Array.from(this.iterateCellsInRange(address));
+  }
+  getCellContent(cellAddress) {
+    const sheet = this.getSheet(cellAddress);
+    if (!sheet) {
+      throw new SheetNotFoundError(cellAddress.sheetName);
+    }
+    return sheet.content.get(getCellReference(cellAddress));
+  }
+  getSerializedCellValue(cellAddress) {
+    const sheet = this.getSheet(cellAddress);
+    if (!sheet) {
+      throw new SheetNotFoundError(cellAddress.sheetName);
+    }
+    return normalizeSerializedCellValue(sheet.content.get(getCellReference(cellAddress)));
+  }
+  isCellEmpty(cellAddress) {
+    const content = this.getCellContent(cellAddress);
+    return content === undefined || typeof content === "string" && content === "";
+  }
+  isFormulaCell(cellAddress) {
+    const content = this.getCellContent(cellAddress);
+    return typeof content === "string" && content.startsWith("=");
+  }
+  buildRangeEvalOrder(lookupOrder, lookupRange) {
+    return buildRangeEvalOrder.call(this, lookupOrder, lookupRange);
+  }
+}
+export {
+  WorkbookManager,
+  IndexEntryBinarySearch
+};
+
+//# debugId=E1E484FC460C08CD64756E2164756E21

package/dist/mjs/core/managers/workbook-manager.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/core/managers/workbook-manager.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellAddress,\n  type FiniteSpreadsheetRange,\n  type LocalCellAddress,\n  type SerializedCellValue,\n  type Sheet,\n  type SpreadsheetRange,\n  type Workbook,\n} from \"../types.mjs\";\nimport { getCellReference, parseCellReference } from \"../utils.mjs\";\n\nimport type { RangeAddress } from \"src/core/types\";\nimport { buildRangeEvalOrder } from \"./range-eval-order-builder.mjs\";\nimport {\n  EvaluationError,\n  SheetNotFoundError,\n  WorkbookNotFoundError,\n} from \"src/evaluator/evaluation-error\";\nimport { normalizeSerializedCellValue } from \"src/parser/formatter\";\n\ninterface IndexEntry {\n  number: number;\n  key: string;\n}\n\nexport interface SheetIndexes {\n  // lookup maps - cells grouped by row/column\n  rowGroups: Map<number, IndexEntry[]>; // row number -> cells in that row (sorted by col)\n  colGroups: Map<number, IndexEntry[]>; // col number -> cells in that col (sorted by row)\n\n  // Sorted flat indexes - for finding cells before a given row/col\n  cellsSortedByRow: IndexEntry[];\n  cellsSortedByCol: IndexEntry[];\n}\n\n/**\n * Utility class for binary search operations on IndexEntry arrays\n */\nexport class IndexEntryBinarySearch {\n  /**\n   * Find the insertion point for a number in a sorted IndexEntry array\n   * Returns the index where the number should be inserted to maintain sort order\n   */\n  static findInsertionPoint(entries: IndexEntry[], target: number): number {\n    let left = 0;\n    let right = entries.length;\n\n    while (left < right) {\n      const mid = Math.floor((left + right) / 2);\n      const midEntry = entries[mid];\n      if (midEntry && midEntry.number < target) {\n        left = mid + 1;\n      } else {\n        right = mid;\n      }\n    }\n\n    return left;\n  }\n\n  /**\n   * Find the first element >= target\n   * Returns the index of the first element, or -1 if not found\n   */\n  static findFirstGreaterOrEqual(\n    entries: IndexEntry[],\n    target: number\n  ): number {\n    if (entries.length === 0) return -1;\n\n    let left = 0;\n    let right = entries.length - 1;\n    let result = -1;\n\n    while (left <= right) {\n      const mid = Math.floor((left + right) / 2);\n      const midEntry = entries[mid];\n      if (midEntry && midEntry.number >= target) {\n        result = mid;\n        right = mid - 1;\n      } else {\n        left = mid + 1;\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Find the rightmost position where we could insert a target value\n   * Useful for finding elements that come before a target\n   */\n  static findRightmostInsertionPoint(\n    entries: IndexEntry[],\n    target: number\n  ): number {\n    return IndexEntryBinarySearch.findInsertionPoint(entries, target);\n  }\n}\n\nexport class WorkbookManager {\n  private workbooks: Map<string, Workbook> = new Map();\n\n  // Map from \"workbookName|sheetName\" to indexes\n  private sheetIndexes: Map<string, SheetIndexes> = new Map();\n\n  /**\n   * Generate a key for the sheet indexes map\n   */\n  private getSheetIndexKey(workbookName: string, sheetName: string): string {\n    return `${workbookName}|${sheetName}`;\n  }\n\n  /**\n   * Get or create indexes for a sheet\n   */\n  public getSheetIndexes(opts: {\n    workbookName: string;\n    sheetName: string;\n  }): SheetIndexes {\n    const key = this.getSheetIndexKey(opts.workbookName, opts.sheetName);\n    let indexes = this.sheetIndexes.get(key);\n\n    if (!indexes) {\n      indexes = {\n        rowGroups: new Map(),\n        colGroups: new Map(),\n        cellsSortedByRow: [],\n        cellsSortedByCol: [],\n      };\n      this.sheetIndexes.set(key, indexes);\n    }\n\n    return indexes;\n  }\n\n  getSheets(workbookName: string): Map<string, Sheet> {\n    const workbook = this.workbooks.get(workbookName);\n    if (!workbook) {\n      throw new WorkbookNotFoundError(workbookName);\n    }\n    return workbook.sheets;\n  }\n\n  getWorkbooks(): Map<string, Workbook> {\n    return this.workbooks;\n  }\n\n  addWorkbook(workbookName: string): void {\n    if (this.workbooks.has(workbookName)) {\n      throw new Error(\"Workbook already exists\");\n    }\n    this.workbooks.set(workbookName, {\n      name: workbookName,\n      sheets: new Map(),\n    });\n  }\n\n  removeWorkbook(workbookName: string): void {\n    const workbook = this.workbooks.get(workbookName);\n    if (!workbook) {\n      throw new WorkbookNotFoundError(workbookName);\n    }\n\n    // Clean up indexes for all sheets in this workbook\n    for (const sheetName of workbook.sheets.keys()) {\n      const key = this.getSheetIndexKey(workbookName, sheetName);\n      this.sheetIndexes.delete(key);\n    }\n\n    this.workbooks.delete(workbookName);\n  }\n\n  isContentEmpty(content: SerializedCellValue): boolean {\n    return content === \"\" || content === undefined;\n  }\n\n  renameWorkbook(opts: {\n    workbookName: string;\n    newWorkbookName: string;\n  }): void {\n    const workbook = this.workbooks.get(opts.workbookName);\n    if (!workbook) {\n      throw new Error(\"Workbook not found\");\n    }\n\n    // Update indexes for all sheets in this workbook\n    for (const sheetName of workbook.sheets.keys()) {\n      const oldKey = this.getSheetIndexKey(opts.workbookName, sheetName);\n      const newKey = this.getSheetIndexKey(opts.newWorkbookName, sheetName);\n      const indexes = this.sheetIndexes.get(oldKey);\n      if (indexes) {\n        this.sheetIndexes.set(newKey, indexes);\n        this.sheetIndexes.delete(oldKey);\n      }\n    }\n\n    this.workbooks.set(opts.newWorkbookName, workbook);\n    this.workbooks.delete(opts.workbookName);\n    workbook.name = opts.newWorkbookName;\n  }\n\n  resetWorkbooks(workbooks: Map<string, Workbook>): void {\n    this.workbooks.clear();\n    this.sheetIndexes.clear();\n\n    workbooks.forEach((workbook, workbookName) => {\n      this.workbooks.set(workbookName, workbook);\n      workbook.sheets.forEach((sheet) => {\n        // Initialize indexes for this sheet\n        const indexes = this.getSheetIndexes({\n          workbookName,\n          sheetName: sheet.name,\n        });\n        indexes.rowGroups.clear();\n        indexes.colGroups.clear();\n        indexes.cellsSortedByRow = [];\n        indexes.cellsSortedByCol = [];\n\n        sheet.content.forEach((value, key) => {\n          this.setCellContent(\n            {\n              workbookName,\n              sheetName: sheet.name,\n              colIndex: parseCellReference(key).colIndex,\n              rowIndex: parseCellReference(key).rowIndex,\n            },\n            value,\n            {\n              sheet,\n              buildingFromScratch: true,\n            }\n          );\n        });\n      });\n    });\n  }\n\n  getSheet({\n    workbookName,\n    sheetName,\n  }: {\n    workbookName: string;\n    sheetName: string;\n  }): Sheet | undefined {\n    const workbook = this.workbooks.get(workbookName);\n    const sheet = workbook?.sheets.get(sheetName);\n    return sheet;\n  }\n\n  addSheet({\n    workbookName,\n    sheetName,\n  }: {\n    workbookName: string;\n    sheetName: string;\n  }): Sheet {\n    const workbook = this.workbooks.get(workbookName);\n    if (!workbook) {\n      throw new WorkbookNotFoundError(workbookName);\n    }\n    const sheet = {\n      name: sheetName,\n      index: workbook.sheets.size,\n      content: new Map(),\n    };\n\n    if (workbook.sheets.has(sheet.name)) {\n      throw new Error(\"Sheet already exists\");\n    }\n\n    workbook.sheets.set(sheetName, sheet);\n\n    // Initialize empty indexes for this sheet\n    this.getSheetIndexes({ workbookName, sheetName });\n\n    return sheet;\n  }\n\n  removeSheet({\n    workbookName,\n    sheetName,\n  }: {\n    workbookName: string;\n    sheetName: string;\n  }): Sheet {\n    const workbook = this.workbooks.get(workbookName);\n    if (!workbook) {\n      throw new WorkbookNotFoundError(workbookName);\n    }\n    const sheet = workbook.sheets.get(sheetName);\n    if (!sheet) {\n      throw new Error(\"Sheet not found\");\n    }\n\n    // Remove the sheet\n    workbook.sheets.delete(sheetName);\n\n    // Clean up indexes for this sheet\n    const key = this.getSheetIndexKey(workbookName, sheetName);\n    this.sheetIndexes.delete(key);\n\n    return sheet;\n  }\n\n  renameSheet({\n    workbookName,\n    sheetName,\n    newSheetName,\n  }: {\n    workbookName: string;\n    sheetName: string;\n    newSheetName: string;\n  }): Sheet {\n    const workbook = this.workbooks.get(workbookName);\n    if (!workbook) {\n      throw new WorkbookNotFoundError(workbookName);\n    }\n    const sheet = workbook.sheets.get(sheetName);\n    if (!sheet) {\n      throw new SheetNotFoundError(sheetName);\n    }\n\n    if (workbook.sheets.has(newSheetName)) {\n      throw new Error(\"Sheet with new name already exists\");\n    }\n\n    // Update sheet name\n    sheet.name = newSheetName;\n\n    // Update sheets map\n    workbook.sheets.set(newSheetName, sheet);\n    workbook.sheets.delete(sheetName);\n\n    // Move indexes to new key\n    const oldKey = this.getSheetIndexKey(workbookName, sheetName);\n    const newKey = this.getSheetIndexKey(workbookName, newSheetName);\n    const indexes = this.sheetIndexes.get(oldKey);\n    if (indexes) {\n      this.sheetIndexes.set(newKey, indexes);\n      this.sheetIndexes.delete(oldKey);\n    }\n\n    return sheet;\n  }\n\n  updateAllFormulas(updateCallback: (formula: string) => string): void {\n    const update = (map: Map<string, Sheet>) => {\n      map.forEach((sheet) => {\n        sheet.content.forEach((cell, key) => {\n          if (typeof cell === \"string\" && cell.startsWith(\"=\")) {\n            const formula = cell.slice(1);\n            const updatedFormula = updateCallback(formula);\n\n            // Only update if the formula actually changed\n            if (updatedFormula !== formula) {\n              sheet.content.set(key, `=${updatedFormula}`);\n            }\n          }\n        });\n      });\n    };\n\n    this.workbooks.forEach((workbook) => {\n      update(workbook.sheets);\n    });\n  }\n\n  getSheetSerialized({\n    workbookName,\n    sheetName,\n  }: {\n    workbookName: string;\n    sheetName: string;\n  }): Map<string, SerializedCellValue> {\n    const workbook = this.workbooks.get(workbookName);\n    if (!workbook) {\n      throw new WorkbookNotFoundError(workbookName);\n    }\n    const sheet = workbook.sheets.get(sheetName);\n    if (!sheet) {\n      throw new SheetNotFoundError(sheetName);\n    }\n\n    return sheet.content;\n  }\n\n  /**\n   * Add a cell to the grouped indexes\n   */\n  private addCellToGroups(\n    indexes: SheetIndexes,\n    rowIndex: number,\n    colIndex: number,\n    key: string\n  ): void {\n    // Add to row group (cells in this row, sorted by column)\n    let rowGroup = indexes.rowGroups.get(rowIndex);\n    if (!rowGroup) {\n      rowGroup = [];\n      indexes.rowGroups.set(rowIndex, rowGroup);\n    }\n    const colEntry: IndexEntry = { number: colIndex, key };\n    const colInsertIdx = this.findInsertIndex(rowGroup, colIndex);\n    rowGroup.splice(colInsertIdx, 0, colEntry);\n\n    // Add to column group (cells in this column, sorted by row)\n    let colGroup = indexes.colGroups.get(colIndex);\n    if (!colGroup) {\n      colGroup = [];\n      indexes.colGroups.set(colIndex, colGroup);\n    }\n    const rowEntry: IndexEntry = { number: rowIndex, key };\n    const rowInsertIdx = this.findInsertIndex(colGroup, rowIndex);\n    colGroup.splice(rowInsertIdx, 0, rowEntry);\n\n    // Add to sorted flat indexes\n    this.insertSorted(indexes.cellsSortedByRow, { number: rowIndex, key });\n    this.insertSorted(indexes.cellsSortedByCol, { number: colIndex, key });\n  }\n\n  /**\n   * Remove a cell from the grouped indexes\n   */\n  private removeCellFromGroups(\n    indexes: SheetIndexes,\n    rowIndex: number,\n    colIndex: number,\n    key: string\n  ): void {\n    // Remove from row group\n    const rowGroup = indexes.rowGroups.get(rowIndex);\n    if (rowGroup) {\n      const filteredGroup = rowGroup.filter((e) => e.key !== key);\n      if (filteredGroup.length === 0) {\n        indexes.rowGroups.delete(rowIndex);\n      } else {\n        indexes.rowGroups.set(rowIndex, filteredGroup);\n      }\n    }\n\n    // Remove from column group\n    const colGroup = indexes.colGroups.get(colIndex);\n    if (colGroup) {\n      const filteredGroup = colGroup.filter((e) => e.key !== key);\n      if (filteredGroup.length === 0) {\n        indexes.colGroups.delete(colIndex);\n      } else {\n        indexes.colGroups.set(colIndex, filteredGroup);\n      }\n    }\n\n    // Remove from sorted flat indexes\n    indexes.cellsSortedByRow = indexes.cellsSortedByRow.filter(\n      (item) => item.key !== key\n    );\n    indexes.cellsSortedByCol = indexes.cellsSortedByCol.filter(\n      (item) => item.key !== key\n    );\n  }\n\n  /**\n   * Find insertion index in sorted array\n   */\n  private findInsertIndex(entries: IndexEntry[], n: number): number {\n    return IndexEntryBinarySearch.findInsertionPoint(entries, n);\n  }\n\n  /**\n   * Inserts an item into a sorted array by number, maintaining sort order.\n   * If an item with the same number and key already exists, it won't be added again.\n   */\n  private insertSorted(array: IndexEntry[], item: IndexEntry): void {\n    // Check if item already exists (same number and key)\n    const existingIndex = array.findIndex(\n      (existing) => existing.number === item.number && existing.key === item.key\n    );\n\n    if (existingIndex !== -1) {\n      // Item already exists, no need to add it again\n      return;\n    }\n\n    // Find the insertion point using binary search for efficiency\n    const insertionPoint = IndexEntryBinarySearch.findInsertionPoint(\n      array,\n      item.number\n    );\n\n    // Insert at the found position\n    array.splice(insertionPoint, 0, item);\n  }\n\n  setCellContent(\n    address: CellAddress,\n    content: SerializedCellValue,\n    options?: {\n      /**\n       * for extra performance, if the sheet is already known, it can be passed in\n       */\n      sheet?: Sheet;\n      /**\n       * if the sheet is being built from scratch, we can skip some checks\n       */\n      buildingFromScratch?: boolean;\n    }\n  ): void {\n    const sheet =\n      options?.sheet ||\n      this.getSheet({\n        sheetName: address.sheetName,\n        workbookName: address.workbookName,\n      });\n\n    if (!sheet) {\n      throw new SheetNotFoundError(address.sheetName);\n    }\n\n    const indexes = this.getSheetIndexes({\n      workbookName: address.workbookName,\n      sheetName: address.sheetName,\n    });\n    const adr = getCellReference(address);\n\n    if (this.isContentEmpty(content)) {\n      if (!options?.buildingFromScratch) {\n        sheet.content.delete(adr);\n        // Remove from all indexes\n        this.removeCellFromGroups(\n          indexes,\n          address.rowIndex,\n          address.colIndex,\n          adr\n        );\n      }\n    } else {\n      sheet.content.set(adr, content);\n      // Add to all indexes\n      this.addCellToGroups(indexes, address.rowIndex, address.colIndex, adr);\n    }\n  }\n\n  /**\n   * Replace all content for a sheet (safely, without breaking references)\n   * This method clears the existing Map and repopulates it rather than replacing the Map reference\n   */\n  setSheetContent(\n    opts: { sheetName: string; workbookName: string },\n    newContent: Map<string, SerializedCellValue>\n  ): void {\n    const sheet = this.getSheet(opts);\n    if (!sheet) {\n      throw new SheetNotFoundError(opts.sheetName);\n    }\n\n    // Clear existing content without breaking the Map reference\n    sheet.content.clear();\n\n    // Clean up indexes for this sheet\n    const key = this.getSheetIndexKey(opts.workbookName, opts.sheetName);\n    this.sheetIndexes.delete(key);\n\n    // Repopulate with new content\n    newContent.forEach((value, key) => {\n      this.setCellContent(\n        {\n          workbookName: opts.workbookName,\n          sheetName: opts.sheetName,\n          colIndex: parseCellReference(key).colIndex,\n          rowIndex: parseCellReference(key).rowIndex,\n        },\n        value,\n        {\n          sheet,\n          buildingFromScratch: true,\n        }\n      );\n    });\n  }\n\n  /**\n   * Removes the content in the spreadsheet that is inside the range.\n   * OPTIMIZED: Uses indexes to only process cells that actually exist.\n   * ENHANCED: Now supports infinite ranges.\n   */\n  clearSpreadsheetRange(address: RangeAddress) {\n    const sheet = this.getSheet(address);\n\n    if (!sheet) {\n      throw new SheetNotFoundError(address.sheetName);\n    }\n\n    // Get current sheet content and prepare new content with cleared cells\n    const newContent = new Map(sheet.content);\n\n    // Use iterateCellsInRange to only process cells that actually exist\n    // This handles both finite and infinite ranges efficiently\n    for (const cellAddress of this.iterateCellsInRange(address)) {\n      const cellRef = getCellReference(cellAddress);\n\n      // Remove from content\n      newContent.delete(cellRef);\n    }\n\n    // setSheetContent will rebuild indexes from scratch, so no need to manually update them\n    this.setSheetContent(address, newContent);\n  }\n\n  /**\n   * Optimized generator to iterate over cells defined in the content within a range\n   * Uses indexes to efficiently find and yield only cells that exist within the range\n   */\n  *iterateCellsInRange(address: RangeAddress): Generator<CellAddress> {\n    // First check if the sheet exists\n    const sheet = this.getSheet(address);\n    if (!sheet) {\n      throw new SheetNotFoundError(address.sheetName);\n    }\n\n    const indexes = this.getSheetIndexes(address);\n\n    const range = address.range;\n\n    // Use the sorted index to find only rows that actually contain cells\n    // This avoids iterating through empty rows regardless of finite/infinite bounds\n\n    if (range.end.row.type === \"number\") {\n      // Finite bounds: Use binary search to find the range of cells to check\n      const startIndex = IndexEntryBinarySearch.findFirstGreaterOrEqual(\n        indexes.cellsSortedByRow,\n        range.start.row\n      );\n\n      if (startIndex === -1) return; // No cells at or after start row\n\n      // Process cells from startIndex until we exceed the end row\n      for (let i = startIndex; i < indexes.cellsSortedByRow.length; i++) {\n        const cellEntry = indexes.cellsSortedByRow[i];\n        if (!cellEntry) continue;\n\n        const parsed = parseCellReference(cellEntry.key);\n\n        // Stop if we've gone beyond the row range\n        if (parsed.rowIndex > range.end.row.value) break;\n\n        // Check if cell is within column bounds\n        if (parsed.colIndex < range.start.col) continue;\n\n        if (\n          range.end.col.type === \"number\" &&\n          parsed.colIndex > range.end.col.value\n        ) {\n          continue; // Skip this cell but keep checking others in different rows\n        }\n\n        yield {\n          rowIndex: parsed.rowIndex,\n          colIndex: parsed.colIndex,\n          sheetName: address.sheetName,\n          workbookName: address.workbookName,\n        };\n      }\n    } else {\n      // Infinite row bounds: Use binary search to find starting point\n      const startIndex = IndexEntryBinarySearch.findFirstGreaterOrEqual(\n        indexes.cellsSortedByRow,\n        range.start.row\n      );\n\n      if (startIndex === -1) return; // No cells at or after start row\n\n      // Process all cells from startIndex to end\n      for (let i = startIndex; i < indexes.cellsSortedByRow.length; i++) {\n        const cellEntry = indexes.cellsSortedByRow[i];\n        if (!cellEntry) continue;\n\n        const parsed = parseCellReference(cellEntry.key);\n\n        // Check if cell is within column bounds\n        if (parsed.colIndex < range.start.col) continue;\n\n        if (\n          range.end.col.type === \"number\" &&\n          parsed.colIndex > range.end.col.value\n        ) {\n          continue; // Skip this cell but keep checking others in different rows\n        }\n\n        yield {\n          rowIndex: parsed.rowIndex,\n          colIndex: parsed.colIndex,\n          sheetName: address.sheetName,\n          workbookName: address.workbookName,\n        };\n      }\n    }\n  }\n\n  getCellsInRange(address: RangeAddress): CellAddress[] {\n    return Array.from(this.iterateCellsInRange(address));\n  }\n\n  private getCellContent(cellAddress: CellAddress): SerializedCellValue {\n    const sheet = this.getSheet(cellAddress);\n    if (!sheet) {\n      throw new SheetNotFoundError(cellAddress.sheetName);\n    }\n    return sheet.content.get(getCellReference(cellAddress));\n  }\n\n  public getSerializedCellValue(cellAddress: CellAddress): SerializedCellValue {\n    const sheet = this.getSheet(cellAddress);\n    if (!sheet) {\n      throw new SheetNotFoundError(cellAddress.sheetName);\n    }\n    return normalizeSerializedCellValue(\n      sheet.content.get(getCellReference(cellAddress))\n    );\n  }\n\n  public isCellEmpty(cellAddress: CellAddress): boolean {\n    const content = this.getCellContent(cellAddress);\n    return (\n      content === undefined || (typeof content === \"string\" && content === \"\")\n    );\n  }\n  public isFormulaCell(cellAddress: CellAddress): boolean {\n    const content = this.getCellContent(cellAddress);\n    return typeof content === \"string\" && content.startsWith(\"=\");\n  }\n\n  /**\n   * Build evaluation order for a range\n   * Delegates to the buildRangeEvalOrder function\n   */\n  public buildRangeEvalOrder(\n    lookupOrder: \"row-major\" | \"col-major\",\n    lookupRange: RangeAddress\n  ) {\n    // Import and call the function\n    return buildRangeEvalOrder.call(this, lookupOrder, lookupRange);\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "E1E484FC460C08CD64756E2164756E21",
+  "names": []
+}

package/dist/mjs/core/map-serializer.mjs

@@ -0,0 +1,39 @@
+// src/core/map-serializer.ts
+function replacer(key, value) {
+  if (value instanceof Set) {
+    return {
+      __type: "Set",
+      values: Array.from(value)
+    };
+  }
+  if (value instanceof Map) {
+    return {
+      __type: "Map",
+      entries: Array.from(value.entries())
+    };
+  }
+  return value;
+}
+function reviver(key, value) {
+  if (value && value.__type === "Set") {
+    return new Set(value.values);
+  }
+  if (value && value.__type === "Map") {
+    return new Map(value.entries);
+  }
+  return value;
+}
+var serialize = (data) => {
+  return JSON.stringify(data, replacer);
+};
+var deserialize = (data) => {
+  return JSON.parse(data, reviver);
+};
+export {
+  serialize,
+  reviver,
+  replacer,
+  deserialize
+};
+
+//# debugId=DEE0C7936D75D10864756E2164756E21

package/dist/mjs/core/map-serializer.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/map-serializer.ts"],
+  "sourcesContent": [
+    "// Replacer: used with JSON.stringify\nexport function replacer(key: string, value: any): any {\n  if (value instanceof Set) {\n    return {\n      __type: \"Set\",\n      values: Array.from(value),\n    };\n  }\n  if (value instanceof Map) {\n    return {\n      __type: \"Map\",\n      entries: Array.from(value.entries()),\n    };\n  }\n  return value;\n}\n\n// Reviver: used with JSON.parse\nexport function reviver(key: string, value: any): any {\n  if (value && value.__type === \"Set\") {\n    return new Set(value.values);\n  }\n  if (value && value.__type === \"Map\") {\n    return new Map(value.entries);\n  }\n  return value;\n}\n\nexport const serialize = (data: unknown): string => {\n  return JSON.stringify(data, replacer);\n};\n\nexport const deserialize = (data: string): unknown => {\n  return JSON.parse(data, reviver);\n};\n"
+  ],
+  "mappings": ";AACO,SAAS,QAAQ,CAAC,KAAa,OAAiB;AAAA,EACrD,IAAI,iBAAiB,KAAK;AAAA,IACxB,OAAO;AAAA,MACL,QAAQ;AAAA,MACR,QAAQ,MAAM,KAAK,KAAK;AAAA,IAC1B;AAAA,EACF;AAAA,EACA,IAAI,iBAAiB,KAAK;AAAA,IACxB,OAAO;AAAA,MACL,QAAQ;AAAA,MACR,SAAS,MAAM,KAAK,MAAM,QAAQ,CAAC;AAAA,IACrC;AAAA,EACF;AAAA,EACA,OAAO;AAAA;AAIF,SAAS,OAAO,CAAC,KAAa,OAAiB;AAAA,EACpD,IAAI,SAAS,MAAM,WAAW,OAAO;AAAA,IACnC,OAAO,IAAI,IAAI,MAAM,MAAM;AAAA,EAC7B;AAAA,EACA,IAAI,SAAS,MAAM,WAAW,OAAO;AAAA,IACnC,OAAO,IAAI,IAAI,MAAM,OAAO;AAAA,EAC9B;AAAA,EACA,OAAO;AAAA;AAGF,IAAM,YAAY,CAAC,SAA0B;AAAA,EAClD,OAAO,KAAK,UAAU,MAAM,QAAQ;AAAA;AAG/B,IAAM,cAAc,CAAC,SAA0B;AAAA,EACpD,OAAO,KAAK,MAAM,MAAM,OAAO;AAAA;",
+  "debugId": "DEE0C7936D75D10864756E2164756E21",
+  "names": []
+}

package/dist/mjs/core/named-expression-renamer.mjs

@@ -0,0 +1,58 @@
+// src/core/named-expression-renamer.ts
+import { parseFormula } from "../parser/parser.mjs";
+import { astToString } from "../parser/formatter.mjs";
+import { transformAST } from "./ast-traverser.mjs";
+function renameNamedExpressionInFormula(formula, oldName, newName) {
+  try {
+    const ast = parseFormula(formula);
+    const transformedAST = transformAST(ast, (node) => {
+      if (node.type === "named-expression" && node.name === oldName) {
+        return {
+          ...node,
+          name: newName
+        };
+      }
+      return node;
+    });
+    return astToString(transformedAST);
+  } catch (error) {
+    return formula;
+  }
+}
+function formulaReferencesNamedExpression(formula, namedExpressionName) {
+  try {
+    const ast = parseFormula(formula);
+    let hasReference = false;
+    transformAST(ast, (node) => {
+      if (node.type === "named-expression" && node.name === namedExpressionName) {
+        hasReference = true;
+      }
+      return node;
+    });
+    return hasReference;
+  } catch (error) {
+    return false;
+  }
+}
+function getReferencedNamedExpressionNames(formula) {
+  try {
+    const ast = parseFormula(formula);
+    const namedExpressionNames = new Set;
+    transformAST(ast, (node) => {
+      if (node.type === "named-expression" && node.name) {
+        namedExpressionNames.add(node.name);
+      }
+      return node;
+    });
+    return Array.from(namedExpressionNames);
+  } catch (error) {
+    return [];
+  }
+}
+export {
+  renameNamedExpressionInFormula,
+  getReferencedNamedExpressionNames,
+  formulaReferencesNamedExpression
+};
+
+//# debugId=0C5BD428E9EB519464756E2164756E21

package/dist/mjs/core/named-expression-renamer.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/named-expression-renamer.ts"],
+  "sourcesContent": [
+    "import { parseFormula } from \"../parser/parser.mjs\";\nimport { astToString } from \"../parser/formatter.mjs\";\nimport { transformAST } from \"./ast-traverser.mjs\";\n\n/**\n * Renames named expression references in a formula string\n * @param formula - The formula string (without the leading =)\n * @param oldName - The current named expression name to replace\n * @param newName - The new named expression name\n * @returns The updated formula string, or the original if no changes were made\n */\nexport function renameNamedExpressionInFormula(\n  formula: string,\n  oldName: string,\n  newName: string\n): string {\n  try {\n    const ast = parseFormula(formula);\n    \n    const transformedAST = transformAST(ast, (node) => {\n      if (node.type === \"named-expression\" && node.name === oldName) {\n        return {\n          ...node,\n          name: newName\n        };\n      }\n      return node;\n    });\n\n    return astToString(transformedAST);\n  } catch (error) {\n    // If parsing fails, return the original formula\n    return formula;\n  }\n}\n\n/**\n * Checks if a formula contains references to a specific named expression\n * @param formula - The formula string (without the leading =)\n * @param namedExpressionName - The named expression name to search for\n * @returns True if the formula contains references to the named expression\n */\nexport function formulaReferencesNamedExpression(formula: string, namedExpressionName: string): boolean {\n  try {\n    const ast = parseFormula(formula);\n    let hasReference = false;\n\n    transformAST(ast, (node) => {\n      if (node.type === \"named-expression\" && node.name === namedExpressionName) {\n        hasReference = true;\n      }\n      return node;\n    });\n\n    return hasReference;\n  } catch (error) {\n    // If parsing fails, assume no reference\n    return false;\n  }\n}\n\n/**\n * Gets all named expression names referenced in a formula\n * @param formula - The formula string (without the leading =)\n * @returns Array of unique named expression names referenced in the formula\n */\nexport function getReferencedNamedExpressionNames(formula: string): string[] {\n  try {\n    const ast = parseFormula(formula);\n    const namedExpressionNames = new Set<string>();\n\n    transformAST(ast, (node) => {\n      if (node.type === \"named-expression\" && node.name) {\n        namedExpressionNames.add(node.name);\n      }\n      return node;\n    });\n\n    return Array.from(namedExpressionNames);\n  } catch (error) {\n    // If parsing fails, return empty array\n    return [];\n  }\n}\n"
+  ],
+  "mappings": ";AAAA;AACA;AACA;AASO,SAAS,8BAA8B,CAC5C,SACA,SACA,SACQ;AAAA,EACR,IAAI;AAAA,IACF,MAAM,MAAM,aAAa,OAAO;AAAA,IAEhC,MAAM,iBAAiB,aAAa,KAAK,CAAC,SAAS;AAAA,MACjD,IAAI,KAAK,SAAS,sBAAsB,KAAK,SAAS,SAAS;AAAA,QAC7D,OAAO;AAAA,aACF;AAAA,UACH,MAAM;AAAA,QACR;AAAA,MACF;AAAA,MACA,OAAO;AAAA,KACR;AAAA,IAED,OAAO,YAAY,cAAc;AAAA,IACjC,OAAO,OAAO;AAAA,IAEd,OAAO;AAAA;AAAA;AAUJ,SAAS,gCAAgC,CAAC,SAAiB,qBAAsC;AAAA,EACtG,IAAI;AAAA,IACF,MAAM,MAAM,aAAa,OAAO;AAAA,IAChC,IAAI,eAAe;AAAA,IAEnB,aAAa,KAAK,CAAC,SAAS;AAAA,MAC1B,IAAI,KAAK,SAAS,sBAAsB,KAAK,SAAS,qBAAqB;AAAA,QACzE,eAAe;AAAA,MACjB;AAAA,MACA,OAAO;AAAA,KACR;AAAA,IAED,OAAO;AAAA,IACP,OAAO,OAAO;AAAA,IAEd,OAAO;AAAA;AAAA;AASJ,SAAS,iCAAiC,CAAC,SAA2B;AAAA,EAC3E,IAAI;AAAA,IACF,MAAM,MAAM,aAAa,OAAO;AAAA,IAChC,MAAM,uBAAuB,IAAI;AAAA,IAEjC,aAAa,KAAK,CAAC,SAAS;AAAA,MAC1B,IAAI,KAAK,SAAS,sBAAsB,KAAK,MAAM;AAAA,QACjD,qBAAqB,IAAI,KAAK,IAAI;AAAA,MACpC;AAAA,MACA,OAAO;AAAA,KACR;AAAA,IAED,OAAO,MAAM,KAAK,oBAAoB;AAAA,IACtC,OAAO,OAAO;AAAA,IAEd,OAAO,CAAC;AAAA;AAAA;",
+  "debugId": "0C5BD428E9EB519464756E2164756E21",
+  "names": []
+}