@ricsam/formula-engine 0.0.1

package/dist/types/core/managers/dependency-manager.d.ts

@@ -0,0 +1,147 @@
+import { type ContextDependency } from "src/evaluator/evaluation-context";
+import { type CellAddress, type EvaluationOrder, type SpilledValue } from "../types";
+import { AstEvaluationNode } from "src/evaluator/dependency-nodes/ast-evaluation-node";
+import { CellValueNode } from "src/evaluator/dependency-nodes/cell-value-node";
+import { EmptyCellEvaluationNode } from "src/evaluator/dependency-nodes/empty-cell-evaluation-node";
+import { RangeEvaluationNode } from "src/evaluator/range-evaluation-node";
+import type { ASTNode } from "src/parser/ast";
+import { CacheManager } from "./cache-manager";
+import type { CellNodeKeyDictionary, CellNodeType, DependencyNode } from "./dependency-node";
+import { WorkbookManager } from "./workbook-manager";
+import { SpillMetaNode } from "src/evaluator/dependency-nodes/spill-meta-node";
+export interface DependencyTreeNode {
+    type: "cell" | "range" | "empty";
+    circular?: boolean;
+    key: string;
+    directDepsUpdated?: boolean;
+    resolved?: boolean;
+    canResolve: boolean;
+    resultType: "awaiting-evaluation" | "spilled-values" | "value" | "range" | "error" | "does-not-spill";
+    deps?: DependencyTreeNode[];
+    frontierDependencies?: DependencyTreeNode[];
+    self?: boolean;
+    _debug?: {
+        rawFrontierDependencies?: string[];
+        discardedFrontierDependencies?: string[];
+        activeFrontierDependencies?: string[];
+    };
+}
+/**
+ * The DependencyManager is responsible for storing the evaluated values and their dependencies.
+ */
+export declare class DependencyManager {
+    private cacheManager;
+    private workbookManager;
+    /**
+     * The dependency graph
+     */
+    private evaluatedNodes;
+    private spillMetaNodes;
+    private emptyCells;
+    /**
+     * registry of spilled values
+     */
+    private _spilledValues;
+    /**
+     * Key is workbook:sheetName:rangeKey, e.g. Workbook1:Sheet1:A1:D10, from rangeAddressToKey
+     */
+    private ranges;
+    constructor(cacheManager: CacheManager, workbookManager: WorkbookManager);
+    get spilledValues(): IterableIterator<SpilledValue>;
+    isSpillOrigin(cellAddress: CellAddress): boolean;
+    getSpillValue(cellAddress: CellAddress): SpilledValue | undefined;
+    getSpilledAddress(cellAddress: CellAddress, 
+    /**
+     * if the spilled value is already available, we can use it to get the source address
+     */
+    passedSpilledValue?: SpilledValue): {
+        address: CellAddress;
+        spillOffset: {
+            x: number;
+            y: number;
+        };
+    };
+    clearEvaluationCache(): void;
+    setSpilledValue(nodeKey: string, spilledValue: SpilledValue): void;
+    getSpilledValue(nodeKey: string): SpilledValue | undefined;
+    getEmptyCellNode(nodeKey: string): EmptyCellEvaluationNode;
+    getSpillMetaNode(nodeKey: string): SpillMetaNode;
+    getCellValueNode(nodeKey: string): CellValueNode;
+    getCellValueOrEmptyCellNode(nodeKey: string): CellValueNode | EmptyCellEvaluationNode;
+    getSpillMetaOrEmptySpillMetaNode(nodeKey: string): SpillMetaNode | EmptyCellEvaluationNode;
+    lookupCellNode<T extends CellNodeType>(nodeKey: string, types: T[]): CellNodeKeyDictionary[T][];
+    getRangeNode(rangeKey: string): RangeEvaluationNode;
+    asts: Map<
+    /**
+     * ast key
+     */
+    string, {
+        entries: Map<
+        /**
+         * context dependency key
+         */
+        string, {
+            evalNode: AstEvaluationNode;
+            contextDependency: ContextDependency;
+        }>;
+    }>;
+    getAstNode(ast: ASTNode, currentContext: Omit<Required<ContextDependency>, "tableName"> & {
+        tableName?: string;
+    }): AstEvaluationNode;
+    /**
+     * Once an AST node is evaluated, we know if it is context dependent
+     * and will thus save it under the correct cache key according to its
+     * contextDependency
+     *
+     * only resolved ast nodes can be saved
+     */
+    private saveAstNode;
+    getEvaluatedNodes(): Map<string, CellValueNode>;
+    /**
+     * Get transitive dependencies and transitive frontier dependencies
+     * This is only used by buildEvaluationOrder, so we'll optimize it there
+     */
+    getTransitiveDepsForEvalOrder(node: DependencyNode, visited?: Set<DependencyNode>): Set<DependencyNode>;
+    /**
+     * Build evaluation order for a cell using SCC-based condensation DAG approach
+     *
+     * Algorithm:
+     * 1. Discover all transitive dependencies (skipping resolved nodes)
+     * 2. Find SCCs using Tarjan's algorithm
+     * 3. Create condensation DAG from SCCs
+     * 4. Topologically sort the condensation DAG using Kahn's algorithm
+     * 5. For each SCC, create internal evaluation order with cycle breaking
+     * 6. Join the sorted SCC evaluation orders to create final evaluation order
+     */
+    buildEvaluationOrder(node: CellValueNode | EmptyCellEvaluationNode): EvaluationOrder;
+    /**
+     * Find strongly connected components using Tarjan's algorithm
+     * @param nodes - Map of nodes to analyze
+     * @param includeFrontier - If true, use getAllDependencies(); if false, use getDependencies()
+     * @returns Array of SCCs (each SCC is a Set of nodes)
+     */
+    private findSCCs;
+    /**
+     * Build evaluation order within a single SCC using DFS with cycle breaking
+     * Uses all dependencies (including frontier) for proper evaluation ordering
+     */
+    private buildSCCEvaluationOrder;
+    /**
+     * Compute hash representing the graph structure including SCC information
+     */
+    private computeGraphHash;
+    /**
+     * Compute a hash representing the current state of evaluated nodes
+     * This hash changes when dependencies, frontier dependencies, or discarded frontier dependencies change
+     */
+    private computeHash;
+    /**
+     * Get a hierarchical dependency tree for a node
+     */
+    getDependencyTree(node: DependencyNode): DependencyTreeNode;
+    markResolvedNodes(node: DependencyNode): void;
+    /**
+     * Update SCCs in cache to mark them as resolved if all their nodes are resolved
+     */
+    updateResolvedSCCs(evalOrder: EvaluationOrder): void;
+}

package/dist/types/core/managers/dependency-node.d.ts

@@ -0,0 +1,13 @@
+import { AstEvaluationNode } from "src/evaluator/dependency-nodes/ast-evaluation-node";
+import { CellValueNode } from "src/evaluator/dependency-nodes/cell-value-node";
+import { EmptyCellEvaluationNode } from "src/evaluator/dependency-nodes/empty-cell-evaluation-node";
+import { SpillMetaNode } from "src/evaluator/dependency-nodes/spill-meta-node";
+import { RangeEvaluationNode } from "src/evaluator/range-evaluation-node";
+export type DependencyNode = CellValueNode | RangeEvaluationNode | EmptyCellEvaluationNode | AstEvaluationNode | SpillMetaNode;
+export type CellNodeType = "cell-value" | "empty" | "spill-meta";
+export type CellNodeKey = `${CellNodeType}:${string}`;
+export type CellNodeKeyDictionary = {
+    "cell-value": CellValueNode;
+    empty: EmptyCellEvaluationNode;
+    "spill-meta": SpillMetaNode;
+};

package/dist/types/core/managers/evaluation-manager.d.ts

@@ -0,0 +1,30 @@
+import { CellValueNode } from "src/evaluator/dependency-nodes/cell-value-node";
+import { RangeEvaluationNode } from "src/evaluator/range-evaluation-node";
+import { FormulaEvaluator } from "../../evaluator/formula-evaluator";
+import { type CellAddress, type CellValue, type SerializedCellValue, type SingleEvaluationResult, type SpreadsheetRange } from "../types";
+import type { DependencyManager } from "./dependency-manager";
+import type { WorkbookManager } from "./workbook-manager";
+import { SpillMetaNode } from "src/evaluator/dependency-nodes/spill-meta-node";
+import { EmptyCellEvaluationNode } from "src/evaluator/dependency-nodes/empty-cell-evaluation-node";
+import type { TableManager } from "./table-manager";
+export declare class EvaluationManager {
+    private workbookManager;
+    private tableManager;
+    private formulaEvaluator;
+    private dependencyManager;
+    private isEvaluating;
+    constructor(workbookManager: WorkbookManager, tableManager: TableManager, formulaEvaluator: FormulaEvaluator, dependencyManager: DependencyManager);
+    clearEvaluationCache(): void;
+    evaluationResultToSerializedValue(evaluation: SingleEvaluationResult, cellAddress: CellAddress, debug?: boolean): SerializedCellValue;
+    evaluateEmptyCell(node: EmptyCellEvaluationNode): void;
+    evaluateRangeNode(node: RangeEvaluationNode): void;
+    evaluateCellNode(node: CellValueNode | SpillMetaNode): void;
+    evaluateDependencyNode(dependencyKey: string): void;
+    /**
+     * Evaluates a cell by building the evaluation order and evaluating the dependencies in order
+     */
+    evaluateCell(node: CellValueNode | EmptyCellEvaluationNode): void;
+    convertScalarValueToCellValue(val: SerializedCellValue): CellValue;
+    canSpill(spillCandidate: CellAddress, spillArea: SpreadsheetRange): boolean;
+    getCellEvaluationResult(cellAddress: CellAddress): SingleEvaluationResult | undefined;
+}

package/dist/types/core/managers/event-manager.d.ts

@@ -0,0 +1,8 @@
+export declare class EventManager {
+    private updateListeners;
+    /**
+     * Register listener for batched sheet updates. Returns an unsubscribe function.
+     */
+    onUpdate(listener: () => void): () => void;
+    emitUpdate(): void;
+}

package/dist/types/core/managers/frontier-dependency-manager.d.ts

@@ -0,0 +1,69 @@
+import { CellValueNode } from "src/evaluator/dependency-nodes/cell-value-node";
+import type { CellAddress, CellInRangeResult, RangeAddress } from "../types";
+import type { DependencyManager } from "./dependency-manager";
+import type { DependencyNode } from "./dependency-node";
+import type { WorkbookManager } from "./workbook-manager";
+import type { SpillMetaNode } from "src/evaluator/dependency-nodes/spill-meta-node";
+type EvalOrderEntry = {
+    type: "value";
+    address: CellAddress;
+    node: CellValueNode;
+} | {
+    type: "empty_cell";
+    address: CellAddress;
+    candidates: SpillMetaNode[];
+} | {
+    type: "empty_range";
+    address: RangeAddress;
+    candidates: SpillMetaNode[];
+};
+export declare class FrontierDependencyManager {
+    private frontierRange;
+    protected workbookManager: WorkbookManager;
+    protected evaluationManager: DependencyManager;
+    private evalOrder;
+    private _resolved;
+    private _directDepsUpdated;
+    constructor(frontierRange: RangeAddress, workbookManager: WorkbookManager, evaluationManager: DependencyManager);
+    /**
+     * frontierDependencies is the set of dependency node keys that could spill values onto the target range (if evaluationResult is spilled-values)
+     * Key is from cellAddressToKey
+     *
+     * soft edge dependencies, which can not cause cycles in the dependency graph
+     */
+    private _frontierDependencies;
+    /**
+     * discardedFrontierDependencies is the set of dependency node keys that were discarded as frontier dependencies because
+     * they they do not produce spilled values that spill onto the target range
+     * Key is from cellAddressToKey
+     */
+    private _discardedFrontierDependencies;
+    /**
+     * hard edge dependencies, which can cause cycles in the dependency graph
+     */
+    private _dependencies;
+    /**
+     * cache, should maybe be stored in the cache manager
+     */
+    get iterateAllCells(): undefined | Iterable<CellInRangeResult>;
+    getRangeEvalOrder(): EvalOrderEntry[];
+    get frontierDependencies(): Set<SpillMetaNode>;
+    get discardedFrontierDependencies(): Set<SpillMetaNode>;
+    maybeDiscardFrontierDependency(dependency: SpillMetaNode): void;
+    maybeUpgradeFrontierDependency(dependency: SpillMetaNode): void;
+    /**
+     * a range is considered resolved when the dependencies has been established
+     */
+    resolve(): void;
+    canResolve(): boolean;
+    get resolved(): boolean;
+    get directDepsUpdated(): boolean;
+    resetDirectDepsUpdated(): void;
+    getDependencies(): Set<DependencyNode>;
+    getFrontierDependencies(): Set<SpillMetaNode>;
+    getAllDependencies(): Set<DependencyNode>;
+    getDiscardedFrontierDependencies(): Set<SpillMetaNode>;
+    addDependency(dependency: DependencyNode): void;
+    upgradeFrontierDependencies(): void;
+}
+export {};

package/dist/types/core/managers/index.d.ts

@@ -0,0 +1,7 @@
+export { WorkbookManager } from "./workbook-manager";
+export { NamedExpressionManager } from "./named-expression-manager";
+export { TableManager } from "./table-manager";
+export { EventManager } from "./event-manager";
+export { EvaluationManager } from "./evaluation-manager";
+export { DependencyManager } from "./dependency-manager";
+export { buildRangeEvalOrder, type LookupOrder, type RangeEvalOrderEntry, } from "./range-eval-order-builder";

package/dist/types/core/managers/isDependencyNode.d.ts

@@ -0,0 +1,2 @@
+import type { DependencyNode } from "./dependency-node";
+export declare function isDependencyNode(node: any): node is DependencyNode;

package/dist/types/core/managers/named-expression-manager.d.ts

@@ -0,0 +1,101 @@
+import type { NamedExpression } from "../types";
+import type { NamedExpressionNode } from "src/parser/ast";
+import type { EvaluationContext } from "src/evaluator/evaluation-context";
+export declare class NamedExpressionManager {
+    sheetExpressions: Map<string, Map<string, Map<string, NamedExpression>>>;
+    workbookExpressions: Map<string, Map<string, NamedExpression>>;
+    globalExpressions: Map<string, NamedExpression>;
+    addNamedExpression({ expression, expressionName, sheetName, workbookName, }: {
+        expression: string;
+        expressionName: string;
+        sheetName?: string;
+        workbookName?: string;
+    }): void;
+    removeNamedExpression({ expressionName, sheetName, workbookName, }: {
+        expressionName: string;
+        sheetName?: string;
+        workbookName?: string;
+    }): boolean;
+    updateNamedExpression({ expression, expressionName, sheetName, workbookName, }: {
+        expression: string;
+        expressionName: string;
+        sheetName?: string;
+        workbookName?: string;
+    }): void;
+    renameNamedExpression({ expressionName, sheetName, workbookName, newName, }: {
+        expressionName: string;
+        sheetName?: string;
+        workbookName?: string;
+        newName: string;
+    }): boolean;
+    updateAllNamedExpressions(updateCallback: (formula: string) => string): void;
+    /**
+     * Replace all named expressions
+     */
+    setNamedExpressions(opts: ({
+        type: "global";
+    } | {
+        type: "sheet";
+        sheetName: string;
+        workbookName: string;
+    } | {
+        type: "workbook";
+        workbookName: string;
+    }) & {
+        expressions: Map<string, NamedExpression>;
+    }): void;
+    getNamedExpression(depNode: {
+        name: string;
+        scope: {
+            type: "global";
+        } | {
+            type: "workbook";
+            workbookName: string;
+        } | {
+            type: "sheet";
+            workbookName: string;
+            sheetName: string;
+        };
+    }): NamedExpression | undefined;
+    resolveNamedExpression(namedExpression: Pick<NamedExpressionNode, "name" | "sheetName" | "workbookName">, context: EvaluationContext): string | undefined;
+    getNamedExpressions(): {
+        sheetExpressions: Map<string, Map<string, Map<string, NamedExpression>>>;
+        workbookExpressions: Map<string, Map<string, NamedExpression>>;
+        globalExpressions: Map<string, NamedExpression>;
+    };
+    resetNamedExpressions(namedExpressions: ReturnType<typeof this.getNamedExpressions>): void;
+    /**
+     * When adding a sheet, we need to initialize the new maps
+     */
+    addSheet(opts: {
+        workbookName: string;
+        sheetName: string;
+    }): void;
+    /**
+     * When adding a workbook, we need to initialize the new maps
+     */
+    addWorkbook(workbookName: string): void;
+    /**
+     * When removing a workbook, we need to remove the workbook from the sheet level
+     */
+    removeWorkbook(workbookName: string): void;
+    /**
+     * When removing a sheet, we need to remove the sheet from the workbook level
+     */
+    removeSheet(opts: {
+        workbookName: string;
+        sheetName: string;
+    }): void;
+    /**
+     * Rename a sheet's named expressions, mainly used when renaming a sheet
+     */
+    renameSheet(options: {
+        sheetName: string;
+        newSheetName: string;
+        workbookName: string;
+    }): void;
+    renameWorkbook(opts: {
+        workbookName: string;
+        newWorkbookName: string;
+    }): void;
+}

package/dist/types/core/managers/range-eval-order-builder.d.ts

@@ -0,0 +1,33 @@
+import { type CellAddress, type RangeAddress } from "../types";
+import { type WorkbookManager } from "./workbook-manager";
+export type LookupOrder = "row-major" | "col-major";
+export type RangeEvalOrderEntryDict = {
+    value: {
+        type: "value";
+        address: CellAddress;
+    };
+    empty_cell: {
+        type: "empty_cell";
+        address: CellAddress;
+        candidates: CellAddress[];
+    };
+    empty_range: {
+        type: "empty_range";
+        address: RangeAddress;
+        candidates: CellAddress[];
+    };
+};
+export type RangeEvalOrderEntry = RangeEvalOrderEntryDict["value"] | RangeEvalOrderEntryDict["empty_cell"] | RangeEvalOrderEntryDict["empty_range"];
+/**
+ * Build a deterministic, ordered list describing every cell inside a lookup range.
+ * This function analyzes the range and classifies each cell/range as either:
+ * - A value-like cell (occupied)
+ * - An empty cell with 0-2 frontier candidates
+ * - An empty range with 0-2 frontier candidates
+ *
+ * @param this - WorkbookManager instance
+ * @param lookupOrder - "row-major" or "col-major" iteration order
+ * @param lookupRange - The range to analyze
+ * @returns Ordered array of entries describing the range
+ */
+export declare function buildRangeEvalOrder(this: WorkbookManager, lookupOrder: LookupOrder, lookupRange: RangeAddress): RangeEvalOrderEntry[];

package/dist/types/core/managers/table-manager.d.ts

@@ -0,0 +1,84 @@
+import type { CellAddress, SerializedCellValue, SpreadsheetRangeEnd, TableDefinition } from "../types";
+import type { WorkbookManager } from "./workbook-manager";
+export declare class TableManager {
+    tables: Map<
+    /**
+     * workbook name -> table name -> table definition
+     */
+    string, Map<string, TableDefinition>>;
+    private workbookManager;
+    constructor(workbookManager: WorkbookManager);
+    getTables(workbookName: string): Map<string, TableDefinition>;
+    getTable(opts: {
+        workbookName: string;
+        name: string;
+    }): TableDefinition | undefined;
+    makeTable({ tableName, sheetName, workbookName, start, numRows, numCols, getCellValue, }: {
+        tableName: string;
+        sheetName: string;
+        start: string;
+        numRows: SpreadsheetRangeEnd;
+        numCols: number;
+        workbookName: string;
+        getCellValue: (cellAddress: CellAddress) => SerializedCellValue;
+    }): TableDefinition;
+    copyTable(from: {
+        workbookName: string;
+        tableName: string;
+    }, to: {
+        workbookName: string;
+        tableName: string;
+    }): void;
+    addTable(props: {
+        tableName: string;
+        sheetName: string;
+        start: string;
+        numRows: SpreadsheetRangeEnd;
+        numCols: number;
+        workbookName: string;
+        getCellValue: (cellAddress: CellAddress) => SerializedCellValue;
+    }): TableDefinition;
+    renameTable(workbookName: string, names: {
+        oldName: string;
+        newName: string;
+    }): void;
+    updateTable({ tableName, sheetName, start, numRows, numCols, workbookName, getCellValue, }: {
+        tableName: string;
+        sheetName?: string;
+        start?: string;
+        numRows?: SpreadsheetRangeEnd;
+        workbookName: string;
+        numCols?: number;
+        getCellValue: (cellAddress: CellAddress) => SerializedCellValue;
+    }): void;
+    removeTable({ tableName, workbookName, }: {
+        tableName: string;
+        workbookName: string;
+    }): boolean;
+    updateTablesForSheetRename(options: {
+        sheetName: string;
+        newSheetName: string;
+        workbookName: string;
+    }): void;
+    updateTablesForWorkbookRename(options: {
+        workbookName: string;
+        newWorkbookName: string;
+    }): void;
+    resetTables(newTables: Map<string, Map<string, TableDefinition>>): void;
+    /**
+     * When adding a workbook, we need to initialize the new maps
+     */
+    addWorkbook(workbookName: string): void;
+    /**
+     * When removing a workbook, we need to remove the maps
+     */
+    removeWorkbook(workbookName: string): void;
+    /**
+     * When removing a sheet, we need to remove the tables that belong to the sheet
+     */
+    removeSheet(opts: {
+        sheetName: string;
+        workbookName: string;
+    }): void;
+    isCellInTable(cellAddress: CellAddress): TableDefinition | undefined;
+}

package/dist/types/core/managers/workbook-manager.d.ts

@@ -0,0 +1,136 @@
+import { type CellAddress, type SerializedCellValue, type Sheet, type Workbook } from "../types";
+import type { RangeAddress } from "src/core/types";
+interface IndexEntry {
+    number: number;
+    key: string;
+}
+export interface SheetIndexes {
+    rowGroups: Map<number, IndexEntry[]>;
+    colGroups: Map<number, IndexEntry[]>;
+    cellsSortedByRow: IndexEntry[];
+    cellsSortedByCol: IndexEntry[];
+}
+/**
+ * Utility class for binary search operations on IndexEntry arrays
+ */
+export declare class IndexEntryBinarySearch {
+    /**
+     * Find the insertion point for a number in a sorted IndexEntry array
+     * Returns the index where the number should be inserted to maintain sort order
+     */
+    static findInsertionPoint(entries: IndexEntry[], target: number): number;
+    /**
+     * Find the first element >= target
+     * Returns the index of the first element, or -1 if not found
+     */
+    static findFirstGreaterOrEqual(entries: IndexEntry[], target: number): number;
+    /**
+     * Find the rightmost position where we could insert a target value
+     * Useful for finding elements that come before a target
+     */
+    static findRightmostInsertionPoint(entries: IndexEntry[], target: number): number;
+}
+export declare class WorkbookManager {
+    private workbooks;
+    private sheetIndexes;
+    /**
+     * Generate a key for the sheet indexes map
+     */
+    private getSheetIndexKey;
+    /**
+     * Get or create indexes for a sheet
+     */
+    getSheetIndexes(opts: {
+        workbookName: string;
+        sheetName: string;
+    }): SheetIndexes;
+    getSheets(workbookName: string): Map<string, Sheet>;
+    getWorkbooks(): Map<string, Workbook>;
+    addWorkbook(workbookName: string): void;
+    removeWorkbook(workbookName: string): void;
+    isContentEmpty(content: SerializedCellValue): boolean;
+    renameWorkbook(opts: {
+        workbookName: string;
+        newWorkbookName: string;
+    }): void;
+    resetWorkbooks(workbooks: Map<string, Workbook>): void;
+    getSheet({ workbookName, sheetName, }: {
+        workbookName: string;
+        sheetName: string;
+    }): Sheet | undefined;
+    addSheet({ workbookName, sheetName, }: {
+        workbookName: string;
+        sheetName: string;
+    }): Sheet;
+    removeSheet({ workbookName, sheetName, }: {
+        workbookName: string;
+        sheetName: string;
+    }): Sheet;
+    renameSheet({ workbookName, sheetName, newSheetName, }: {
+        workbookName: string;
+        sheetName: string;
+        newSheetName: string;
+    }): Sheet;
+    updateAllFormulas(updateCallback: (formula: string) => string): void;
+    getSheetSerialized({ workbookName, sheetName, }: {
+        workbookName: string;
+        sheetName: string;
+    }): Map<string, SerializedCellValue>;
+    /**
+     * Add a cell to the grouped indexes
+     */
+    private addCellToGroups;
+    /**
+     * Remove a cell from the grouped indexes
+     */
+    private removeCellFromGroups;
+    /**
+     * Find insertion index in sorted array
+     */
+    private findInsertIndex;
+    /**
+     * Inserts an item into a sorted array by number, maintaining sort order.
+     * If an item with the same number and key already exists, it won't be added again.
+     */
+    private insertSorted;
+    setCellContent(address: CellAddress, content: SerializedCellValue, options?: {
+        /**
+         * for extra performance, if the sheet is already known, it can be passed in
+         */
+        sheet?: Sheet;
+        /**
+         * if the sheet is being built from scratch, we can skip some checks
+         */
+        buildingFromScratch?: boolean;
+    }): void;
+    /**
+     * Replace all content for a sheet (safely, without breaking references)
+     * This method clears the existing Map and repopulates it rather than replacing the Map reference
+     */
+    setSheetContent(opts: {
+        sheetName: string;
+        workbookName: string;
+    }, newContent: Map<string, SerializedCellValue>): void;
+    /**
+     * Removes the content in the spreadsheet that is inside the range.
+     * OPTIMIZED: Uses indexes to only process cells that actually exist.
+     * ENHANCED: Now supports infinite ranges.
+     */
+    clearSpreadsheetRange(address: RangeAddress): void;
+    /**
+     * Optimized generator to iterate over cells defined in the content within a range
+     * Uses indexes to efficiently find and yield only cells that exist within the range
+     */
+    iterateCellsInRange(address: RangeAddress): Generator<CellAddress>;
+    getCellsInRange(address: RangeAddress): CellAddress[];
+    private getCellContent;
+    getSerializedCellValue(cellAddress: CellAddress): SerializedCellValue;
+    isCellEmpty(cellAddress: CellAddress): boolean;
+    isFormulaCell(cellAddress: CellAddress): boolean;
+    /**
+     * Build evaluation order for a range
+     * Delegates to the buildRangeEvalOrder function
+     */
+    buildRangeEvalOrder(lookupOrder: "row-major" | "col-major", lookupRange: RangeAddress): import("./range-eval-order-builder").RangeEvalOrderEntry[];
+}
+export {};

package/dist/types/core/map-serializer.d.ts

@@ -0,0 +1,4 @@
+export declare function replacer(key: string, value: any): any;
+export declare function reviver(key: string, value: any): any;
+export declare const serialize: (data: unknown) => string;
+export declare const deserialize: (data: string) => unknown;

package/dist/types/core/named-expression-renamer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Renames named expression references in a formula string
+ * @param formula - The formula string (without the leading =)
+ * @param oldName - The current named expression name to replace
+ * @param newName - The new named expression name
+ * @returns The updated formula string, or the original if no changes were made
+ */
+export declare function renameNamedExpressionInFormula(formula: string, oldName: string, newName: string): string;
+/**
+ * Checks if a formula contains references to a specific named expression
+ * @param formula - The formula string (without the leading =)
+ * @param namedExpressionName - The named expression name to search for
+ * @returns True if the formula contains references to the named expression
+ */
+export declare function formulaReferencesNamedExpression(formula: string, namedExpressionName: string): boolean;
+/**
+ * Gets all named expression names referenced in a formula
+ * @param formula - The formula string (without the leading =)
+ * @returns Array of unique named expression names referenced in the formula
+ */
+export declare function getReferencedNamedExpressionNames(formula: string): string[];