@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/interface/spreadsheet-interface.js

@@ -0,0 +1,2442 @@
+import { tokenize as defaultTokenizer } from "@rowsncolumns/calculator";
+import { isCellCoordinate, isCellNode, isCellRangeNode, isStaticNode, } from "@rowsncolumns/dag";
+import { FormulaError } from "@rowsncolumns/fast-formula-parser";
+import { defaultSpreadsheetTheme, } from "@rowsncolumns/spreadsheet";
+import { addressToCell, canUseDOM, cellToAddress, DEFAULT_ACTIVE_CELL, DEFAULT_COLUMN_COUNT, DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_COUNT, DEFAULT_ROW_HEIGHT, generateSelectionsFromFormula, getCellEffectiveFormat, getCellEffectiveValue, getCellFormattedValue, getCellUserEnteredFormat, getCellUserEnteredValue, getColumnIndexFromColumnName, getExtendedValueBool, getExtendedValueError, getExtendedValueFormula, getExtendedValueNumber, getExtendedValueString, isAreasEqual, isCellWithinBounds, isNil, iterateCellsInRange, pointToPixel, } from "@rowsncolumns/utils";
+import { enableMapSet, enablePatches, produceWithPatches } from "immer";
+import { buildConditionalFormatExpression } from "../api/conditional-format";
+import { isConditionalFormatFormulaRule } from "../api/conditional-format";
+import { buildDataValidationExpression } from "../api/data-validation";
+import { isDataValidationFormulaRule } from "../api/data-validation";
+import { getAutoFillValues } from "../api/fill";
+import { formulaToRelativeReference } from "../api/formula";
+import { createSheetDraft, deriveCellFromPrecedents } from "../api/immer-utils";
+import { defaultCellCoords, isStyleReference, SheetCell } from "../sheet-cell";
+import { CellXfsRegistry } from "../cellxfs-registry";
+import { SharedStringRegistry } from "../shared-string-registry";
+import { getSharedStringRuns, getSharedStringText } from "../types";
+import { applyFill } from "./apply-fill";
+import { autoResize } from "./auto-resize";
+import { CalculationInterface } from "./calculation-interface";
+import { changeBatch } from "./change-batch";
+import { changeBatchStream } from "./change-batch-stream";
+import { changeBorder } from "./change-border";
+import { changeCalculatedColumn } from "./change-calculated-column";
+import { changeDecimals } from "./change-decimals";
+import { changeFormatting } from "./change-formatting";
+import { changeSheetTabcolor } from "./change-sheet-tabcolor";
+import { changeTableColumn } from "./change-table-column";
+import { changeTheme } from "./change-theme";
+import { isChartsAvailable, safeCreateChart, safeDeleteChart, safeMoveChart, safeResizeChart, safeUpdateChart, } from "./chart-extensions";
+import { createBatchCitations, createCitation, deleteCitation, removeCitationFromCell, updateCitation, } from "./citations";
+import { clearFormatting } from "./clear-formatting";
+import { createConditionalFormattingRule, deleteConditionalFormattingRule, previewConditionalFormattingRule, updateConditionalFormattingRule, } from "./conditional-formatting-rules";
+import { createTable } from "./create-table";
+import { createDataValidationRule, deleteDataValidationRule, deleteDataValidationRules, updateDataValidationRule, } from "./data-validation-rules";
+import { deleteCells } from "./delete-cells";
+import { deleteCellsShiftLeft } from "./delete-cells-shift-left";
+import { deleteCellsShiftUp } from "./delete-cells-shift-up";
+import { deleteColumn } from "./delete-column";
+import { deleteRow } from "./delete-row";
+import { deleteSheet } from "./delete-sheet";
+import { deleteTableColumn } from "./delete-table-column";
+import { deleteTableRow } from "./delete-table-row";
+import { duplicateSheet } from "./duplicate-sheet";
+import { createEmbed, deleteEmbed, moveEmbed, resizeEmbed, updateEmbed, } from "./embeds";
+import { freezeColumn, freezeRow } from "./freeze";
+import { hideColumns } from "./hide-column";
+import { hideRows } from "./hide-row";
+import { decreaseIndent, increaseIndent } from "./indent";
+import { insertColumn, insertTableColumn } from "./insert-column";
+import { insertNote } from "./insert-note";
+import { insertRow } from "./insert-row";
+import { insertTableRow } from "./insert-table-row";
+import { createNamedRange, deleteNamedRange } from "./named-range-operations";
+import { createNewSheet } from "./new-sheet";
+import { safeCreatePivotTable, safeDeletePivotTable } from "./pivot-extensions";
+import { removeTable } from "./remove-table";
+import { removeDuplicates } from "./remove-duplicates";
+import { resize } from "./resize";
+import { updateSheet } from "./update-sheet";
+import { updateTable } from "./update-table";
+// Enable patches
+enablePatches();
+enableMapSet();
+// lib/canvas-adapter.ts
+let canvasLib = null;
+export const createCanvas = (width, height) => {
+    if (canUseDOM) {
+        // Browser environment (Storybook)
+        const canvas = document.createElement("canvas");
+        canvas.width = width;
+        canvas.height = height;
+        return canvas;
+    }
+    else {
+        // Node environment
+        if (!canvasLib) {
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                canvasLib = require("canvas");
+            }
+            catch (e) {
+                // Fallback: return a minimal mock canvas for SSR/build compatibility
+                console.warn("canvas not available, using mock canvas");
+                return {
+                    width,
+                    height,
+                    getContext: () => ({
+                        font: "",
+                        measureText: () => ({ width: 0 }),
+                    }),
+                };
+            }
+        }
+        return canvasLib.createCanvas(width, height);
+    }
+};
+/**
+ * Backend auto-sizer for measuring text dimensions in Node.js
+ */
+class BackendAutoSizer {
+    canvas = createCanvas(0, 0);
+    ctx = this.canvas.getContext("2d");
+    currentFontSize = 12;
+    setFont({ fontFamily = "Arial", fontSize = 12, fontWeight = "", fontStyle = "", scale = 1, }) {
+        this.currentFontSize = fontSize * scale;
+        const font = `${fontStyle} ${fontWeight} ${this.currentFontSize}px ${fontFamily}`
+            .trim()
+            .replace(/\s+/g, " ");
+        this.ctx.font = font;
+    }
+    reset() {
+        this.setFont({});
+    }
+    measureText(text, shouldWrap = false, maxWidth) {
+        if (!text)
+            return null;
+        const metrics = this.ctx.measureText(text);
+        let width = metrics.width;
+        let height = this.currentFontSize * 1.2; // Line height approximation
+        if (shouldWrap && maxWidth && width > maxWidth) {
+            // Simple word wrapping calculation
+            const words = text.split(" ");
+            let lines = 1;
+            let currentLineWidth = 0;
+            for (const word of words) {
+                const wordWidth = this.ctx.measureText(word + " ").width;
+                if (currentLineWidth + wordWidth > maxWidth) {
+                    lines++;
+                    currentLineWidth = wordWidth;
+                }
+                else {
+                    currentLineWidth += wordWidth;
+                }
+            }
+            height = this.currentFontSize * 1.2 * lines;
+            width = maxWidth;
+        }
+        return { width, height };
+    }
+}
+// Generic state change function
+const stateChangeFunction = (getter, setter) => (action) => {
+    if (typeof action === "function") {
+        // If action is a function, call it with current state
+        setter(action(getter()));
+    }
+    else {
+        // If action is a value, set it directly
+        setter(action);
+    }
+};
+/**
+ * Spreadsheet Interface for SSR
+ *
+ * const spreadsheet = new Spreadsheet()
+ */
+export class Spreadsheet {
+    _sheets = [];
+    _sheetData = {};
+    _tables = [];
+    _charts = [];
+    _embeds = [];
+    _pivotTables = [];
+    _citations = [];
+    _namedRanges = [];
+    _dataValidations = [];
+    _conditionalFormats = [];
+    _locale = "en";
+    _patches = [];
+    _cellXfs = new Map();
+    _activeSheetId = 1;
+    _autoSizer = new BackendAutoSizer();
+    scale = 1;
+    skipDag = false;
+    cellHorizontalSpacing = 5;
+    cellVerticalSpacing = 5;
+    resizeStrategy = "full";
+    minRowDimension = DEFAULT_ROW_HEIGHT;
+    minColumnDimension = DEFAULT_COLUMN_WIDTH;
+    _calculationInterface;
+    _sharedStrings = new Map();
+    _getEffectiveStructuredValue;
+    constructor(options) {
+        this._getEffectiveStructuredValue = options?.getEffectiveStructuredValue;
+        this._calculationInterface = new CalculationInterface({
+            locale: this.locale,
+            createWorker: options?.createCalculationWorker,
+            iterativeCalculation: options?.iterativeCalculation,
+            clientOnlyFunctionPattern: options?.clientOnlyFunctionPattern,
+            getSheetName: this.getSheetName,
+            getSheetId: (sheetName) => this.getSheetId(sheetName, { fallbackToActiveSheet: false }),
+            getSheets: () => this.sheets,
+            getTables: () => this.tables,
+            getNamedRanges: () => this.namedRanges,
+            getFinalUserEnteredValue: this.getFinalUserEnteredValue,
+            getEffectiveValue: this.getEffectiveValueForCalculation,
+            getEffectiveStructuredValue: options?.getEffectiveStructuredValue,
+            onResults: this.applyCalculationResults,
+        });
+        this.enqueueCalculation = (operation) => {
+            this._calculationInterface.enqueueCalculation(operation);
+        };
+        this.enqueueGraphOperation = (operation) => {
+            this._calculationInterface.enqueueGraphOperation(operation);
+        };
+        this.enqueueStructureChange = (change) => {
+            this._calculationInterface.enqueueStructureChange(change);
+        };
+    }
+    rebuildGraph() {
+        if (this.skipDag) {
+            return;
+        }
+        this._calculationInterface.rebuildGraph(this.collectFormulaOperations());
+        this.addConditionalFormattingToGraph();
+        this.addDataValidationsToGraph();
+    }
+    /**
+     * Add conditional formatting rules to the dependency graph.
+     * @param sheetId - Optional sheet ID to restrict to a specific sheet
+     */
+    addConditionalFormattingToGraph(sheetId) {
+        const restrictToSheet = typeof sheetId === "number";
+        for (const rule of this.conditionalFormats ?? []) {
+            if (rule.enabled === false) {
+                continue;
+            }
+            if (isConditionalFormatFormulaRule(rule)) {
+                for (const range of rule.ranges) {
+                    if (restrictToSheet && range.sheetId !== sheetId) {
+                        continue;
+                    }
+                    for (const [rowIndex, columnIndex] of iterateCellsInRange(range)) {
+                        this.enqueueGraphOperation({
+                            position: {
+                                rowIndex,
+                                columnIndex,
+                                sheetId: range.sheetId,
+                                conditionalFormatId: rule.id,
+                            },
+                            type: "add",
+                        });
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Add data validation rules to the dependency graph.
+     * @param sheetId - Optional sheet ID to restrict to a specific sheet
+     */
+    addDataValidationsToGraph(sheetId) {
+        const restrictToSheet = typeof sheetId === "number";
+        for (const rule of this.dataValidations ?? []) {
+            if (isDataValidationFormulaRule(rule)) {
+                for (const range of rule.ranges) {
+                    if (restrictToSheet && range.sheetId !== sheetId) {
+                        continue;
+                    }
+                    for (const [rowIndex, columnIndex] of iterateCellsInRange(range)) {
+                        this.enqueueGraphOperation({
+                            position: {
+                                rowIndex,
+                                columnIndex,
+                                sheetId: range.sheetId,
+                                dataValidationId: rule.id,
+                            },
+                            type: "add",
+                        });
+                    }
+                }
+            }
+        }
+    }
+    set sharedStrings(value) {
+        this._sharedStrings = value;
+    }
+    get sharedStrings() {
+        return this._sharedStrings;
+    }
+    get activeSheetId() {
+        return this._activeSheetId;
+    }
+    set activeSheetId(value) {
+        this._activeSheetId = value;
+    }
+    get sheets() {
+        return this._sheets;
+    }
+    set sheets(value) {
+        this._sheets = value;
+        this._calculationInterface.markMetadataDirty();
+    }
+    get charts() {
+        return this._charts;
+    }
+    set charts(value) {
+        this._charts = value;
+    }
+    get embeds() {
+        return this._embeds;
+    }
+    set embeds(value) {
+        this._embeds = value;
+    }
+    get pivotTables() {
+        return this._pivotTables;
+    }
+    set pivotTables(value) {
+        this._pivotTables = value;
+    }
+    get citations() {
+        return this._citations;
+    }
+    set citations(value) {
+        this._citations = value;
+    }
+    get namedRanges() {
+        return this._namedRanges;
+    }
+    set namedRanges(value) {
+        this._namedRanges = value;
+        this._calculationInterface.markMetadataDirty();
+    }
+    get dataValidations() {
+        return this._dataValidations;
+    }
+    set dataValidations(value) {
+        this._dataValidations = value;
+    }
+    get conditionalFormats() {
+        return this._conditionalFormats;
+    }
+    set conditionalFormats(value) {
+        this._conditionalFormats = value;
+    }
+    get sheetData() {
+        return this._sheetData;
+    }
+    set sheetData(sheetData) {
+        this._sheetData = sheetData;
+    }
+    get tables() {
+        return this._tables;
+    }
+    set tables(value) {
+        this._tables = value;
+        this._calculationInterface.markMetadataDirty();
+    }
+    set locale(value) {
+        this._locale = value;
+        this._calculationInterface.markMetadataDirty();
+    }
+    get locale() {
+        return this._locale;
+    }
+    set cellXfs(value) {
+        this._cellXfs = value;
+    }
+    get cellXfs() {
+        return this._cellXfs;
+    }
+    set patches(value) {
+        this._patches = value;
+    }
+    get patches() {
+        return this._patches;
+    }
+    clearPatches() {
+        this._patches = [];
+    }
+    onChangeSheets = stateChangeFunction(() => this.sheets, // Getter function
+    (value) => (this.sheets = value));
+    onChangeSheetData = stateChangeFunction(() => this.sheetData, (value) => (this.sheetData = value));
+    onChangeTables = stateChangeFunction(() => this.tables, (value) => (this.tables = value));
+    onChangeCharts = stateChangeFunction(() => this.charts, (value) => (this.charts = value));
+    onChangeEmbeds = stateChangeFunction(() => this.embeds, (value) => (this.embeds = value));
+    onChangeNamedRanges = stateChangeFunction(() => this.namedRanges, (value) => (this.namedRanges = value));
+    onChangeSharedStrings = stateChangeFunction(() => this.sharedStrings, (value) => (this.sharedStrings = value));
+    onChangeDataValidations = stateChangeFunction(() => this.dataValidations, (value) => (this.dataValidations = value));
+    onChangeConditionalFormats = stateChangeFunction(() => this.conditionalFormats, (value) => (this.conditionalFormats = value));
+    onChangeCellXfs = stateChangeFunction(() => this.cellXfs, (value) => {
+        this.cellXfs = value;
+    });
+    get cellXfsRegistry() {
+        return new CellXfsRegistry(this.cellXfs, this.onChangeCellXfs);
+    }
+    get sharedStringRegistry() {
+        return new SharedStringRegistry(this.sharedStrings, this.onChangeSharedStrings);
+    }
+    onChangeActiveSheet = stateChangeFunction(() => this.activeSheetId, (value) => (this.activeSheetId = value));
+    onChangePivotTables = stateChangeFunction(() => this.pivotTables, // Getter function
+    (value) => (this.pivotTables = value));
+    onChangeCitations = stateChangeFunction(() => this.citations, (value) => (this.citations = value));
+    createHistory = () => (patches) => {
+        this._patches.push(patches);
+    };
+    enqueueCalculation = (_operation) => { };
+    enqueueGraphOperation = (_operation) => { };
+    enqueueStructureChange = (_change) => { };
+    onRequestCalculate = async () => {
+        return [];
+    };
+    getActiveCell = () => defaultCellCoords;
+    getSelections = () => [];
+    getDependents = (source, includeSource) => {
+        return this._calculationInterface.getDependents(source).filter((node) => {
+            if (isStaticNode(node)) {
+                return true;
+            }
+            if (!includeSource && isCellRangeNode(node)) {
+                return !isAreasEqual(node.position, source);
+            }
+            if (!includeSource && isCellCoordinate(source) && isCellNode(node)) {
+                const cellNode = node;
+                return (cellNode.position.rowIndex !== source.rowIndex ||
+                    cellNode.position.columnIndex !== source.columnIndex);
+            }
+            return true;
+        });
+    };
+    onChangeSelections = () => [];
+    getContentfulRangeAroundCell = (sheetId, startCell) => {
+        return {
+            startRowIndex: startCell.rowIndex,
+            endRowIndex: startCell.rowIndex,
+            startColumnIndex: startCell.columnIndex,
+            endColumnIndex: startCell.columnIndex,
+        };
+    };
+    onChangeActiveCell = () => [];
+    getSharedStringValue(cellData) {
+        if (cellData?.ss == null) {
+            return undefined;
+        }
+        const value = this.sharedStrings.get(String(cellData.ss));
+        if (value == null) {
+            return undefined;
+        }
+        // Entries may be plain strings OR rich `{text, runs}` objects — mirror the
+        // hooks' getSharedStringValue, which resolves the rich form's text.
+        return getSharedStringText(value);
+    }
+    getEffectiveValue = (sheetId, rowIndex, columnIndex, _property) => {
+        const cellData = this.sheetData?.[sheetId]?.[rowIndex]?.values?.[columnIndex];
+        // Check for shared strings
+        const sharedStringValue = this.getSharedStringValue(cellData);
+        if (sharedStringValue !== undefined) {
+            return sharedStringValue;
+        }
+        const effectiveValue = getCellEffectiveValue(cellData);
+        if (!effectiveValue) {
+            return undefined;
+        }
+        return (getExtendedValueBool(effectiveValue) ??
+            getExtendedValueNumber(effectiveValue) ??
+            getExtendedValueString(effectiveValue));
+    };
+    getHyperLink(sheetId, rowIndex, columnIndex) {
+        return this.getCellData(sheetId, rowIndex, columnIndex)?.hyperlink;
+    }
+    getHyperlinkText(hyperlink) {
+        if (!hyperlink) {
+            return undefined;
+        }
+        if (typeof hyperlink === "string") {
+            return hyperlink;
+        }
+        if (hyperlink.kind === "external") {
+            return hyperlink.url;
+        }
+        return hyperlink.location;
+    }
+    getEffectiveValueForCalculation = (sheetId, rowIndex, columnIndex, property) => {
+        const cellData = this.getCellData(sheetId, rowIndex, columnIndex);
+        if (property) {
+            return this._getEffectiveStructuredValue?.(getCellEffectiveValue(cellData)?.structuredValue, property);
+        }
+        const effectiveValue = getCellEffectiveValue(cellData);
+        const errorValue = getExtendedValueError(effectiveValue);
+        if (errorValue) {
+            return new FormulaError(errorValue.name, errorValue.message);
+        }
+        const hyperlink = this.getHyperlinkText(this.getHyperLink(sheetId, rowIndex, columnIndex));
+        return (hyperlink ??
+            this.getEffectiveValue(sheetId, rowIndex, columnIndex) ??
+            hyperlink ??
+            this._getEffectiveStructuredValue?.(effectiveValue?.structuredValue) ??
+            effectiveValue?.structuredValue);
+    };
+    getCellData(sheetId, rowIndex, columnIndex) {
+        return this.sheetData?.[sheetId]?.[rowIndex]?.values?.[columnIndex];
+    }
+    getUserEnteredValue = (sheetId, rowIndex, columnIndex) => {
+        const cellData = this.getCellData(sheetId, rowIndex, columnIndex);
+        const sharedStringValue = this.getSharedStringValue(cellData);
+        if (sharedStringValue !== undefined) {
+            return { sv: sharedStringValue };
+        }
+        return getCellUserEnteredValue(cellData);
+    };
+    getUserEnteredStringValue = (sheetId, rowIndex, columnIndex) => {
+        const formulaValue = this.getFormulaValue(sheetId, rowIndex, columnIndex);
+        if (formulaValue) {
+            return formulaValue;
+        }
+        const userEnteredValue = this.getUserEnteredValue(sheetId, rowIndex, columnIndex);
+        const stringValue = getExtendedValueString(userEnteredValue);
+        if (stringValue) {
+            return stringValue;
+        }
+        return undefined;
+    };
+    getFormulaValue = (sheetId, rowIndex, columnIndex) => {
+        const userEnteredValue = this.getUserEnteredValue(sheetId, rowIndex, columnIndex);
+        return getExtendedValueFormula(userEnteredValue);
+    };
+    getFormattedValue = (sheetId, rowIndex, columnIndex) => {
+        const cellData = this.getCellData(sheetId, rowIndex, columnIndex);
+        const sharedStringValue = this.getSharedStringValue(cellData);
+        if (sharedStringValue !== undefined) {
+            return sharedStringValue;
+        }
+        return getCellFormattedValue(cellData);
+    };
+    /**
+     * Get sheet
+     * @param sheetId
+     * @returns
+     */
+    getSheet(sheetId) {
+        const sheet = this.sheets.find((sheet) => sheet.sheetId === sheetId);
+        return new SheetInterface(sheet);
+    }
+    getSheetId = (sheetName, options) => {
+        const fallbackToActiveSheet = options?.fallbackToActiveSheet ?? true;
+        const sheet = this.sheets.find((sheet) => sheet.title === sheetName);
+        if (sheet) {
+            return sheet.sheetId;
+        }
+        return fallbackToActiveSheet ? this.activeSheetId : undefined;
+    };
+    getSheetIdOrActive = (sheetName) => {
+        return (this.getSheetId(sheetName, { fallbackToActiveSheet: true }) ??
+            this.activeSheetId);
+    };
+    getSheetName = (sheetId) => {
+        return this.getSheet(sheetId)?.name;
+    };
+    getDataValidationById = (id) => {
+        return this.dataValidations?.find((rule) => rule.id === id);
+    };
+    getConditionalFormatFormula = (sheetId, rowIndex, columnIndex, conditionalFormatId) => {
+        const rule = this.conditionalFormats?.find((candidate) => candidate.id === conditionalFormatId);
+        if (!rule) {
+            return undefined;
+        }
+        const formulaValue = isConditionalFormatFormulaRule(rule)
+            ? buildConditionalFormatExpression(rule, cellToAddress({
+                rowIndex: rule?.ranges?.[0]?.startRowIndex ?? 1,
+                columnIndex: rule?.ranges?.[0]?.startColumnIndex ?? 1,
+            }, false, false) ?? "A1", this.locale)
+            : undefined;
+        if (!formulaValue || !rule.ranges.length) {
+            return formulaValue;
+        }
+        const masterCell = {
+            rowIndex: rule.ranges[0].startRowIndex,
+            columnIndex: rule.ranges[0].startColumnIndex,
+        };
+        const activeSheetName = this.getSheetName(sheetId) ?? "";
+        for (const range of rule.ranges) {
+            if (sheetId === range.sheetId &&
+                isCellWithinBounds({ rowIndex, columnIndex }, range)) {
+                return (formulaToRelativeReference(formulaValue, masterCell, { rowIndex, columnIndex }, activeSheetName, {
+                    ignoreCircular: true,
+                    preserveAbsolutes: true,
+                    ignoreReferenceError: true,
+                }) ?? "");
+            }
+        }
+    };
+    getDataValidationFormula = (sheetId, rowIndex, columnIndex) => {
+        const cellData = this.getCellData(sheetId, rowIndex, columnIndex);
+        let dataValidation = cellData?.dataValidation;
+        if (typeof dataValidation === "string" ||
+            typeof dataValidation === "number") {
+            dataValidation = this.getDataValidationById(dataValidation);
+        }
+        const record = dataValidation;
+        const formulaValue = isDataValidationFormulaRule(record)
+            ? buildDataValidationExpression(record, cellToAddress({
+                rowIndex: record?.ranges?.[0]?.startRowIndex ?? 1,
+                columnIndex: record?.ranges?.[0]?.startColumnIndex ?? 1,
+            }, false, false) ?? "A1", this.locale)
+            : undefined;
+        if (formulaValue && record?.ranges?.length) {
+            const masterCell = {
+                rowIndex: record.ranges[0].startRowIndex,
+                columnIndex: record.ranges[0].startColumnIndex,
+            };
+            const activeSheetName = this.getSheetName(sheetId) ?? "";
+            return (formulaToRelativeReference(formulaValue, masterCell, { rowIndex, columnIndex }, activeSheetName, {
+                ignoreCircular: true,
+                preserveAbsolutes: true,
+                ignoreReferenceError: true,
+            }) ?? "");
+        }
+        return formulaValue;
+    };
+    getFinalUserEnteredValue = (position) => {
+        const { conditionalFormatId, dataValidationId } = position;
+        if (!isNil(conditionalFormatId)) {
+            return this.getConditionalFormatFormula(position.sheetId, position.rowIndex, position.columnIndex, conditionalFormatId);
+        }
+        if (!isNil(dataValidationId)) {
+            return this.getDataValidationFormula(position.sheetId, position.rowIndex, position.columnIndex);
+        }
+        return this.getFormulaValue(position.sheetId, position.rowIndex, position.columnIndex);
+    };
+    getPrecedents = (source, includeSource) => {
+        return this._calculationInterface.getPrecedents(source).filter((node) => {
+            if (isStaticNode(node)) {
+                return true;
+            }
+            if (!includeSource &&
+                isCellCoordinate(node.position) &&
+                isCellCoordinate(source)) {
+                return (node.position.rowIndex !== source.rowIndex ||
+                    node.position.columnIndex !== source.columnIndex);
+            }
+            if (includeSource &&
+                !isCellCoordinate(node.position) &&
+                !isCellCoordinate(source)) {
+                return !isAreasEqual(node.position, source);
+            }
+            return true;
+        });
+    };
+    collectFormulaOperations = () => {
+        const operations = [];
+        const sheetCell = new SheetCell();
+        for (const sheetIdKey in this.sheetData) {
+            const sheetId = Number(sheetIdKey);
+            for (const [rowIndex, value] of this.sheetData[sheetId]?.entries() ??
+                []) {
+                for (const [columnIndex, cellData] of value?.values?.entries() ?? []) {
+                    if (!cellData) {
+                        continue;
+                    }
+                    sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData);
+                    if (sheetCell.formula) {
+                        operations.push({
+                            type: "add",
+                            position: { sheetId, rowIndex, columnIndex },
+                            value: sheetCell.formula,
+                        });
+                    }
+                }
+            }
+        }
+        return operations;
+    };
+    getEffectiveValuesFromRange = (address) => {
+        const [sheetToken, rangeToken] = address.split("!");
+        const hasExplicitSheet = Boolean(rangeToken);
+        const sheetName = hasExplicitSheet ? sheetToken : undefined;
+        const sheetId = sheetName ? this.getSheetId(sheetName) : this.activeSheetId;
+        const rangeAddress = hasExplicitSheet ? rangeToken : sheetToken;
+        if (!sheetId || !rangeAddress) {
+            return [];
+        }
+        const sheet = this.getSheet(sheetId);
+        const [startRef, endRef] = rangeAddress.split(":");
+        const startCell = addressToCell(startRef, {
+            position: "start",
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+        });
+        const endCell = addressToCell(endRef ?? startRef, {
+            position: "end",
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+        });
+        if (!startCell || !endCell) {
+            return [];
+        }
+        const values = [];
+        for (let row = startCell.rowIndex; row <= endCell.rowIndex; row += 1) {
+            for (let col = startCell.columnIndex; col <= endCell.columnIndex; col += 1) {
+                const value = this.getEffectiveValue(sheetId, row, col);
+                values.push({
+                    userEnteredValue: value == null ? "" : String(value),
+                });
+            }
+        }
+        return values;
+    };
+    applyCalculationResults = (results) => {
+        const sheetCell = new SheetCell();
+        const saveHistory = this.createHistory();
+        const cellXfsRegisry = this.cellXfsRegistry;
+        this.onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                for (const [position, result, formatting] of results) {
+                    const { rowIndex, columnIndex, sheetId, conditionalFormatId, dataValidationId, } = position;
+                    const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    const cellData = currentSheet[rowIndex].values?.[columnIndex];
+                    sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
+                        getRangeValues: this.getEffectiveValuesFromRange,
+                        locale: this.locale,
+                        cellXfsRegistry: cellXfsRegisry,
+                        getDataValidationById: this.getDataValidationById,
+                    });
+                    sheetCell.hideLoading();
+                    if (!isNil(conditionalFormatId)) {
+                        sheetCell.setConditionalFormatResult(conditionalFormatId, result);
+                    }
+                    else if (!isNil(dataValidationId)) {
+                        sheetCell.setDataValidationResult(result);
+                    }
+                    else {
+                        const preserveStringLiteral = typeof result === "string";
+                        sheetCell.setEffectiveValue(result, false, preserveStringLiteral);
+                        // Calculator-supplied formatting (e.g. spilled FILTER results)
+                        // is persisted as user-entered so the renderer respects it
+                        // without walking precedents. Effective number format from
+                        // precedents is derived at render time and not written here.
+                        if (formatting) {
+                            for (const type in formatting) {
+                                sheetCell.setUserEnteredFormat(type, formatting[type]);
+                            }
+                        }
+                        const derivedCell = deriveCellFromPrecedents(sheetCell.formula, this.getPrecedents(position), draft, sheetId, this.locale, this.cellXfsRegistry);
+                        if (derivedCell) {
+                            sheetCell.processDerivedCell(derivedCell);
+                        }
+                    }
+                    currentSheet[rowIndex].values[columnIndex] =
+                        sheetCell.getCellData();
+                    cellXfsRegisry?.registerCellXfs(sheetCell);
+                }
+            });
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                disableRecalc: true,
+            });
+            return nextState;
+        });
+        cellXfsRegisry?.getPatches(saveHistory);
+    };
+    async flushCalculations() {
+        await this._calculationInterface.flush();
+    }
+    async calculateAll() {
+        const operations = this.collectFormulaOperations();
+        if (!operations.length) {
+            return [];
+        }
+        return this._calculationInterface.calculate(operations);
+    }
+    async calculatePending() {
+        return this._calculationInterface.flushWithResults();
+    }
+    /**
+     * Get text format for a cell (for auto-sizing)
+     */
+    /**
+     * Rich-text runs for a cell, read off the SharedStrings entry the cell
+     * points at via `ss` (same source as the hooks' `getTextFormatRuns`).
+     */
+    getCellTextFormatRuns(sheetId, rowIndex, columnIndex) {
+        const cellData = this.getCellData(sheetId, rowIndex, columnIndex);
+        if (cellData?.ss == null)
+            return undefined;
+        return getSharedStringRuns(this.sharedStrings.get(String(cellData.ss)));
+    }
+    getCellTextFormat(sheetId, rowIndex, columnIndex) {
+        const cellData = this.getCellData(sheetId, rowIndex, columnIndex);
+        // `ef` is no longer persisted on cellData. Read `uf` first, fall back to
+        // legacy `ef` for older saved data.
+        let effectiveFormat = getCellUserEnteredFormat(cellData) ?? getCellEffectiveFormat(cellData);
+        // Registry
+        if (isStyleReference(effectiveFormat)) {
+            effectiveFormat = this.cellXfsRegistry.getCellXfsFromStyleId(effectiveFormat.sid ?? effectiveFormat.styleId);
+        }
+        return {
+            bold: effectiveFormat?.textFormat?.bold,
+            fontSize: effectiveFormat?.textFormat?.fontSize,
+            fontFamily: effectiveFormat?.textFormat?.fontFamily,
+            italic: effectiveFormat?.textFormat?.italic,
+            shouldWrap: effectiveFormat?.wrapStrategy === "wrap",
+        };
+    }
+    shouldWrapCell(sheetId, rowIndex, columnIndex) {
+        const cellFormat = this.getCellTextFormat(sheetId, rowIndex, columnIndex);
+        return cellFormat?.shouldWrap;
+    }
+    /**
+     * Get column width from sheet metadata (stored width)
+     */
+    getStoredColumnWidth(sheetId, columnIndex) {
+        const sheet = this.sheets.find((s) => s.sheetId === sheetId);
+        return sheet?.columnMetadata?.[columnIndex]?.size ?? DEFAULT_COLUMN_WIDTH;
+    }
+    /**
+     * Check if a column is hidden
+     */
+    isHiddenColumn(sheetId, columnIndex) {
+        const sheet = this.sheets.find((s) => s.sheetId === sheetId);
+        const metadata = sheet?.columnMetadata?.[columnIndex];
+        return metadata?.hiddenByUser ?? metadata?.hiddenByFilter ?? false;
+    }
+    /**
+     * Check if a row is hidden
+     */
+    isHiddenRow(sheetId, rowIndex) {
+        const sheet = this.sheets.find((s) => s.sheetId === sheetId);
+        const metadata = sheet?.rowMetadata?.[rowIndex];
+        return metadata?.hiddenByUser ?? metadata?.hiddenByFilter ?? false;
+    }
+    /**
+     * Get dimension of a single cell
+     * Similar to use-sizer.ts getCellDimensions
+     */
+    getCellDimensions = (sheetId, rowIndex, columnIndex, axis = "y", options) => {
+        const { textOverride, textFormatOverride, shouldWrapOverride } = options ?? {};
+        const text = textOverride ?? this.getFormattedValue(sheetId, rowIndex, columnIndex);
+        if (!text)
+            return { width: 0, height: 0 };
+        const textFormat = textFormatOverride ??
+            this.getCellTextFormat(sheetId, rowIndex, columnIndex);
+        // Rich-text runs carry their own font sizes; the tallest run sets the
+        // line box (Excel scales a row to the largest glyph in a mixed line).
+        // Headless heuristic, mirroring the Rust engine's refit: the whole cell
+        // measures under the tallest font rather than per-segment metrics.
+        const runs = textFormatOverride == null
+            ? this.getCellTextFormatRuns(sheetId, rowIndex, columnIndex)
+            : undefined;
+        const maxRunFontSize = runs?.reduce((acc, run) => "format" in run ? Math.max(acc, run.format?.fontSize ?? 0) : acc, 0);
+        const fitFontSize = Math.max(textFormat.fontSize ?? 10, maxRunFontSize ?? 0);
+        // Reset and set font
+        this._autoSizer.reset();
+        const textFontSize = pointToPixel(fitFontSize);
+        this._autoSizer.setFont({
+            fontFamily: textFormat?.fontFamily ?? "Arial",
+            fontSize: textFontSize,
+            fontWeight: textFormat?.bold ? "bold" : "",
+            fontStyle: textFormat?.italic ? "italic" : "",
+            scale: this.scale,
+        });
+        const shouldWrap = shouldWrapOverride ?? this.shouldWrapCell(sheetId, rowIndex, columnIndex);
+        const columnWidth = this.getStoredColumnWidth(sheetId, columnIndex);
+        const metrics = this._autoSizer.measureText(text, shouldWrap, columnWidth - this.cellHorizontalSpacing);
+        if (!metrics)
+            return { width: 0, height: 0 };
+        return {
+            width: Math.ceil(metrics.width) + this.cellHorizontalSpacing,
+            height: Math.ceil(metrics.height) + this.cellVerticalSpacing,
+        };
+    };
+    /**
+     * Check if a cell is merged
+     * @param sheetId
+     * @param rowIndex
+     * @param columnIndex
+     * @returns
+     */
+    isMergedCell = (sheetId, rowIndex, columnIndex) => {
+        const sheet = this.sheets.find((sheet) => sheet.sheetId === sheetId);
+        if (sheet) {
+            return sheet.merges?.some((range) => {
+                return isCellWithinBounds({ rowIndex, columnIndex }, range);
+            });
+        }
+        return false;
+    };
+    /**
+     * Calculate row height based on cell content
+     * Same logic as use-sizer.ts getRowHeight
+     */
+    getRowHeight = (sheetId, rowIndex, shouldExclude) => {
+        const sheet = this.getSheet(sheetId);
+        const columnCount = sheet.columnCount;
+        const visibleColumns = this.resizeStrategy === "full" ? columnCount : 20;
+        let maxHeight = 0;
+        // Calculate for frozen columns
+        for (let i = 1; i <= sheet.frozenColumns; i++) {
+            if (this.isHiddenColumn(sheetId, i)) {
+                continue;
+            }
+            const { height } = this.getCellDimensions(sheetId, rowIndex, i, "x");
+            if (height > maxHeight)
+                maxHeight = height;
+        }
+        // Loop through visible columns
+        let start = this.resizeStrategy === "full" ? Math.max(sheet.frozenColumns, 1) : 0;
+        while (start < visibleColumns) {
+            if (this.isHiddenColumn(sheetId, start) || shouldExclude?.(start)) {
+                start++;
+                continue;
+            }
+            const { height } = this.getCellDimensions(sheetId, rowIndex, start, "x");
+            if (height > maxHeight)
+                maxHeight = height;
+            start++;
+        }
+        return Math.max(this.minRowDimension * this.scale, maxHeight) / this.scale;
+    };
+    /**
+     * Calculate column width based on cell content
+     * Same logic as use-sizer.ts getColumnWidth
+     */
+    getColumnWidth = (sheetId, columnIndex, options) => {
+        const sheet = this.getSheet(sheetId);
+        const rowCount = sheet.rowCount;
+        const { rowStartIndexRegion, rowStopIndexRegion, fallbackToDefaultIfEmpty, } = options ?? {};
+        const visibleRows = rowStopIndexRegion ?? this.resizeStrategy === "full" ? rowCount : 20;
+        let maxWidth = 0;
+        // Calculate for frozen rows: Frozen rows are always on the screen
+        for (let i = 1; i < sheet.frozenRows; i++) {
+            if (this.isHiddenRow(sheetId, i)) {
+                continue;
+            }
+            const { width } = this.getCellDimensions(sheetId, i, columnIndex);
+            if (width > maxWidth)
+                maxWidth = width;
+        }
+        // Loop through all visible rows
+        let start = rowStartIndexRegion ?? this.resizeStrategy === "full"
+            ? sheet.frozenRows
+            : 0;
+        while (start < visibleRows) {
+            if (this.isHiddenRow(sheetId, start)) {
+                start++;
+                continue;
+            }
+            const { width } = this.getCellDimensions(sheetId, start, columnIndex, "y");
+            if (width > maxWidth)
+                maxWidth = width;
+            start++;
+        }
+        // This column is empty
+        if (maxWidth === 0) {
+            if (fallbackToDefaultIfEmpty) {
+                return DEFAULT_COLUMN_WIDTH;
+            }
+            return this.getStoredColumnWidth(sheetId, columnIndex);
+        }
+        return (Math.max(this.minColumnDimension * this.scale, maxWidth) / this.scale);
+    };
+    /**
+     * Generate RFC patches that can be used to
+     * update yJS doc
+     * @returns
+     */
+    async generateStatePatches() {
+        const spreadsheetPatches = [];
+        const promises = [];
+        // Sheet data
+        promises.push(new Promise((resolve) => {
+            this.onChangeSheetData?.((prev) => {
+                const [_, patches, inversePatches] = produceWithPatches({}, () => {
+                    return prev;
+                });
+                spreadsheetPatches.push([
+                    {
+                        sheetData: { patches, inversePatches },
+                    },
+                ]);
+                resolve();
+                return prev;
+            });
+        }));
+        // onChangeSheets
+        promises.push(new Promise((resolve) => {
+            this.onChangeSheets?.((prev) => {
+                const [_, patches, inversePatches] = produceWithPatches([], () => {
+                    return prev;
+                });
+                spreadsheetPatches.push([
+                    {
+                        sheets: { patches, inversePatches },
+                    },
+                ]);
+                resolve();
+                return prev;
+            });
+        }));
+        // onChangeTables
+        promises.push(new Promise((resolve) => {
+            this.onChangeTables?.((prev) => {
+                const [_, patches, inversePatches] = produceWithPatches([], () => {
+                    return prev;
+                });
+                spreadsheetPatches.push([
+                    {
+                        tables: { patches, inversePatches },
+                    },
+                ]);
+                resolve();
+                return prev;
+            });
+        }));
+        // onChangeCharts
+        promises.push(new Promise((resolve) => {
+            this.onChangeCharts?.((prev) => {
+                const [_, patches, inversePatches] = produceWithPatches([], () => {
+                    return prev;
+                });
+                spreadsheetPatches.push([
+                    {
+                        charts: { patches, inversePatches },
+                    },
+                ]);
+                resolve();
+                return prev;
+            });
+        }));
+        // onChangeEmbeds
+        promises.push(new Promise((resolve) => {
+            this.onChangeEmbeds?.((prev) => {
+                const [_, patches, inversePatches] = produceWithPatches([], () => {
+                    return prev;
+                });
+                spreadsheetPatches.push([
+                    {
+                        embeds: { patches, inversePatches },
+                    },
+                ]);
+                resolve();
+                return prev;
+            });
+        }));
+        // onChangeNamedRanges
+        promises.push(new Promise((resolve) => {
+            this.onChangeNamedRanges?.((prev) => {
+                const [_, patches, inversePatches] = produceWithPatches([], () => {
+                    return prev;
+                });
+                spreadsheetPatches.push([
+                    {
+                        namedRanges: { patches, inversePatches },
+                    },
+                ]);
+                resolve();
+                return prev;
+            });
+        }));
+        // onChangeSharedStrings
+        promises.push(new Promise((resolve) => {
+            this.onChangeSharedStrings?.((prev) => {
+                // Always use Map for shared strings
+                const base = new Map();
+                const [_, patches, inversePatches] = produceWithPatches(base, () => {
+                    return prev;
+                });
+                spreadsheetPatches.push([
+                    {
+                        sharedStrings: { patches, inversePatches },
+                    },
+                ]);
+                resolve();
+                return prev;
+            });
+        }));
+        // onChangeDataValidations
+        promises.push(new Promise((resolve) => {
+            this.onChangeDataValidations?.((prev) => {
+                const [_, patches, inversePatches] = produceWithPatches([], () => {
+                    return prev;
+                });
+                spreadsheetPatches.push([
+                    {
+                        dataValidations: { patches, inversePatches },
+                    },
+                ]);
+                resolve();
+                return prev;
+            });
+        }));
+        // onChangeConditionalFormats
+        promises.push(new Promise((resolve) => {
+            this.onChangeConditionalFormats?.((prev) => {
+                const [_, patches, inversePatches] = produceWithPatches([], () => {
+                    return prev;
+                });
+                spreadsheetPatches.push([
+                    {
+                        conditionalFormats: { patches, inversePatches },
+                    },
+                ]);
+                resolve();
+                return prev;
+            });
+        }));
+        // onChangeCellXfs
+        promises.push(new Promise((resolve) => {
+            this.onChangeCellXfs?.((prev) => {
+                const [_, patches, inversePatches] = produceWithPatches([], () => {
+                    return prev;
+                });
+                spreadsheetPatches.push([
+                    {
+                        cellXfs: { patches, inversePatches },
+                    },
+                ]);
+                resolve();
+                return prev;
+            });
+        }));
+        // onChangeCitations
+        promises.push(new Promise((resolve) => {
+            this.onChangeCitations?.((prev) => {
+                const [_, patches, inversePatches] = produceWithPatches([], () => {
+                    return prev;
+                });
+                spreadsheetPatches.push([
+                    {
+                        citations: { patches, inversePatches },
+                    },
+                ]);
+                resolve();
+                return prev;
+            });
+        }));
+        // Wait for all callbacks to complete
+        await Promise.all(promises);
+        return spreadsheetPatches;
+    }
+    /**
+     * Get selection from a named range variable
+     * @param variableName
+     * @returns
+     */
+    getSelectionFromNamedRange = (variableName) => {
+        const namedRange = this.namedRanges?.find((range) => range.name.localeCompare(variableName, undefined, {
+            sensitivity: "accent",
+        }) === 0);
+        // Only return selection for names with ranges
+        if (namedRange?.range) {
+            const sheet = this.getSheet(namedRange.range.sheetId);
+            return {
+                range: namedRange.range,
+                sheetName: sheet.name,
+            };
+        }
+        // Get static or formula value
+        const result = namedRange?.value;
+        if (!isNil(result)) {
+            return result;
+        }
+        return undefined;
+    };
+    /**
+     * Get selections from table reference
+     * @param sheetId
+     * @param cell
+     * @param tableName
+     * @param columnNames
+     * @param thisRow
+     * @param specialItem
+     * @returns
+     */
+    getSelectionFromTable = (sheetId, cell, tableName, columnNames, thisRow, specialItem) => {
+        // If there is no tablename, we need to find table based
+        // on cell
+        const table = this.tables?.find((table) => {
+            if (tableName) {
+                return table.title === tableName;
+            }
+            return cell
+                ? isCellWithinBounds(cell, table.range) && table.sheetId === sheetId
+                : true;
+        });
+        // Current row
+        const { rowIndex } = cell ?? DEFAULT_ACTIVE_CELL;
+        if (table) {
+            const { range } = table;
+            const headerRow = table.headerRow ?? true;
+            const totalRow = table.totalRow ?? false;
+            const headerRowOffset = headerRow ? 1 : 0;
+            const totalRowOffset = totalRow ? 1 : 0;
+            const sheet = this.getSheet(table.sheetId);
+            const sheetName = sheet.name;
+            const [from, to] = columnNames ?? [];
+            const startColIndex = getColumnIndexFromColumnName(table, from);
+            const endColIndex = getColumnIndexFromColumnName(table, to);
+            const startColumnIndex = isNil(startColIndex)
+                ? range.startColumnIndex
+                : startColIndex;
+            const endColumnIndex = isNil(endColIndex) && isNil(startColIndex)
+                ? range.endColumnIndex
+                : isNil(endColIndex)
+                    ? startColumnIndex
+                    : endColIndex;
+            // Headers only
+            if (specialItem === "#Headers") {
+                return {
+                    range: {
+                        ...range,
+                        startColumnIndex,
+                        endColumnIndex,
+                        startRowIndex: range.startRowIndex,
+                        endRowIndex: range.startRowIndex,
+                    },
+                    sheetName,
+                };
+            }
+            // All
+            if (specialItem === "#All") {
+                return {
+                    range: {
+                        ...range,
+                        startColumnIndex,
+                        endColumnIndex,
+                    },
+                    sheetName,
+                };
+            }
+            // All
+            if (specialItem === "#Data") {
+                return {
+                    range: {
+                        ...range,
+                        startColumnIndex,
+                        endColumnIndex,
+                        startRowIndex: range.startRowIndex + headerRowOffset,
+                        endRowIndex: range.endRowIndex - totalRowOffset,
+                    },
+                    sheetName,
+                };
+            }
+            if (!from && !to) {
+                return {
+                    range: {
+                        startRowIndex: thisRow
+                            ? rowIndex
+                            : range.startRowIndex + headerRowOffset,
+                        endRowIndex: thisRow
+                            ? rowIndex
+                            : range.endRowIndex - totalRowOffset,
+                        startColumnIndex,
+                        endColumnIndex,
+                    },
+                    sheetName,
+                };
+            }
+            // If column is not found, lets not select anything
+            if (startColIndex === -1 || isNil(startColIndex)) {
+                return undefined;
+            }
+            // Check if thisrow is active and current cell is in bounds
+            if (thisRow &&
+                (rowIndex < range.startRowIndex || rowIndex > range.endRowIndex)) {
+                return undefined;
+            }
+            return {
+                range: {
+                    ...range,
+                    startRowIndex: thisRow
+                        ? rowIndex
+                        : range.startRowIndex + headerRowOffset,
+                    endRowIndex: thisRow ? rowIndex : range.endRowIndex - totalRowOffset,
+                    startColumnIndex,
+                    endColumnIndex,
+                },
+                sheetName: sheet.name,
+            };
+        }
+    };
+    /**
+     * Tokenize a string in the back-end
+     * @param value
+     * @param sheetId
+     * @param activeCell
+     * @returns
+     */
+    tokenize = (value, sheetId, activeCell) => {
+        const tokens = defaultTokenizer?.(value) ?? [];
+        let index = -1;
+        for (const token of tokens) {
+            if (token.selection) {
+                token["index"] = ++index;
+            }
+            if (token.isNamedRange) {
+                if (this.getSelectionFromNamedRange?.(token.image)) {
+                    token["index"] = ++index;
+                }
+                else {
+                    delete token["index"];
+                }
+            }
+            if (token.structured) {
+                if (this.getSelectionFromTable?.(sheetId, activeCell, token.tableName, token.columnNames, token.thisRow, token.specialItem)) {
+                    token["index"] = ++index;
+                }
+                else {
+                    delete token["index"];
+                }
+            }
+        }
+        return tokens;
+    };
+    /**
+     * Get selections from a formula
+     * @param value
+     * @param sheetId
+     * @param activeCell
+     * @returns
+     */
+    getSelectionFromFormula = (value, sheetId, activeCell) => {
+        const sheet = this.getSheet(sheetId);
+        return generateSelectionsFromFormula(value, sheetId, sheet.name, activeCell, sheet.rowCount, sheet.columnCount, (formulaValue) => this.tokenize(formulaValue, sheetId, activeCell), (id, cell, tableName, columnNames, thisRow, specialItem) => this.getSelectionFromTable(id, cell, tableName, columnNames, thisRow, specialItem), this.getSelectionFromNamedRange);
+    };
+    /**
+     * Get patches as tuples for applyPatchesToYDoc
+     * @param type - The operation type ('redo' or 'undo')
+     * @returns Array of tuples in the format expected by applyPatchesToYDoc
+     */
+    getPatchTuples(type = "redo") {
+        return this._patches.map((patch) => [patch, type]);
+    }
+    /**
+     * Insert note in a cell
+     * @param args
+     */
+    insertNote(...args) {
+        insertNote({
+            createHistory: this.createHistory,
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+        })(...args);
+    }
+    /**
+     * Inserts table row
+     * @param tableView
+     * @param relativeRowIndex
+     * @param rowData
+     */
+    insertTableRow(tableView, relativeRowIndex, rowData) {
+        const sheet = this.getSheet(tableView.sheetId);
+        insertTableRow({
+            onChangeSheets: this.onChangeSheets,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeTables: this.onChangeTables,
+            onChangeDataValidations: this.onChangeDataValidations,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            getActiveCell: this.getActiveCell,
+            getDependents: this.getDependents,
+            getSheetName: this.getSheetName,
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+        })(tableView, relativeRowIndex, rowData);
+    }
+    /**
+     * Inserts a row
+     * @param sheetId
+     * @param referenceRowIndex
+     * @param numRows
+     */
+    insertRow(sheetId, referenceRowIndex, numRows = 1) {
+        const sheet = this.getSheet(sheetId);
+        insertRow({
+            onChangeSheets: this.onChangeSheets,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeTables: this.onChangeTables,
+            onChangeDataValidations: this.onChangeDataValidations,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            getActiveCell: this.getActiveCell,
+            getSelections: this.getSelections,
+            getDependents: this.getDependents,
+            getGraphNodes: () => this._calculationInterface.getNodes(),
+            getGraphNodesInSheet: (sheetId) => this._calculationInterface.getNodesInSheet(sheetId),
+            getSheetName: this.getSheetName,
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+        })(sheetId, referenceRowIndex, numRows);
+    }
+    /**
+     * Inserts a column
+     * @param sheetId
+     * @param referenceColumnIndex
+     * @param numColumns
+     */
+    insertColumn(sheetId, referenceColumnIndex, numColumns = 1) {
+        const sheet = this.getSheet(sheetId);
+        insertColumn({
+            onChangeSheets: this.onChangeSheets,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeTables: this.onChangeTables,
+            onChangeDataValidations: this.onChangeDataValidations,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            getDependents: this.getDependents,
+            getGraphNodes: () => this._calculationInterface.getNodes(),
+            getGraphNodesInSheet: (sheetId) => this._calculationInterface.getNodesInSheet(sheetId),
+            getSelections: this.getSelections,
+            getActiveCell: this.getActiveCell,
+            getSheetName: this.getSheetName,
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+            tables: this.tables,
+        })(sheetId, referenceColumnIndex, numColumns);
+    }
+    /**
+     * Deletes columns
+     * @param sheetId
+     * @param columnIndexes
+     */
+    deleteColumn(sheetId, columnIndexes) {
+        const sheet = this.getSheet(sheetId);
+        deleteColumn({
+            onChangeSheets: this.onChangeSheets,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeTables: this.onChangeTables,
+            onChangeDataValidations: this.onChangeDataValidations,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            getDependents: this.getDependents,
+            getGraphNodes: () => this._calculationInterface.getNodes(),
+            getGraphNodesInSheet: (sheetId) => this._calculationInterface.getNodesInSheet(sheetId),
+            getActiveCell: this.getActiveCell,
+            getSelections: this.getSelections,
+            getSheetName: this.getSheetName,
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+            locale: this.locale,
+            onChangeActiveCell: this.onChangeActiveSheet,
+            onChangeSelections: this.onChangeSelections,
+            onChangeCitations: this.onChangeCitations,
+        })(sheetId, columnIndexes);
+    }
+    /**
+     * Update a range of cells
+     * @param sheetId
+     * @param ranges
+     * @param values
+     */
+    changeBatch(sheetId, ranges, values, formatting, citations, changeBatchOptions) {
+        const ssRegistry = this.sharedStringRegistry;
+        const cellXfsRegistry = this.cellXfsRegistry;
+        return changeBatch({
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            tables: this.tables,
+            onChangeTables: this.onChangeTables,
+            locale: this.locale,
+            getUserEnteredValue: this.getUserEnteredStringValue,
+            cellXfsRegistry: cellXfsRegistry,
+            getFormattedValue: this.getFormattedValue,
+            getCellDimensions: this.getCellDimensions,
+            getRowHeight: this.getRowHeight,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            getDependents: this.getDependents,
+            getSheetName: this.getSheetName,
+            isMergedCell: this.isMergedCell,
+            getDataValidationById: this.getDataValidationById,
+            sharedStringRegistry: ssRegistry,
+            getEffectiveValuesFromRange: this.getEffectiveValuesFromRange,
+            onChangeCitations: this.onChangeCitations,
+            onChangeTableColumn: (...args) => changeTableColumn({
+                locale: this.locale,
+                sharedStringRegistry: ssRegistry,
+                cellXfsRegistry: cellXfsRegistry,
+                createHistory: this.createHistory,
+                enqueueCalculation: this.enqueueCalculation,
+                enqueueGraphOperation: this.enqueueCalculation,
+                getDependents: this.getDependents,
+                onChangeSheetData: this.onChangeSheetData,
+                onChangeTables: this.onChangeTables,
+            })(...args),
+            onChangeCalculatedColumn: (...args) => changeCalculatedColumn({
+                locale: this.locale,
+                sharedStringRegistry: ssRegistry,
+                cellXfsRegistry: cellXfsRegistry,
+                createHistory: this.createHistory,
+                enqueueCalculation: this.enqueueCalculation,
+                onChangeTables: this.onChangeTables,
+                getSheetName: this.getSheetName,
+                getUserEnteredValue: this.getUserEnteredStringValue,
+                onChangeSheetData: this.onChangeSheetData,
+            })(...args),
+        })(sheetId, ranges, values, formatting, citations, changeBatchOptions);
+    }
+    /**
+     * Stream cell updates into a range
+     * @param sheetId
+     * @param range
+     * @param stream
+     */
+    async changeBatchStream(sheetId, range, stream) {
+        return changeBatchStream({
+            onChangeSheetData: this.onChangeSheetData,
+            enqueueCalculation: this.enqueueCalculation,
+            locale: this.locale,
+            getDataValidationById: this.getDataValidationById,
+            getEffectiveValuesFromRange: this.getEffectiveValuesFromRange,
+        })(sheetId, range, stream);
+    }
+    /**
+     * Change cell formatting
+     * @param args
+     */
+    changeFormatting(...args) {
+        changeFormatting({
+            getFormattedValue: this.getFormattedValue,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            locale: this.locale,
+            cellXfsRegistry: this.cellXfsRegistry,
+            getCellDimensions: this.getCellDimensions,
+            getRowHeight: this.getRowHeight,
+        })(...args);
+    }
+    /**
+     * Change cell border
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     * @param location
+     * @param color
+     * @param style
+     */
+    changeBorder(sheetId, activeCell, selections, location, color, style = "solid") {
+        changeBorder({
+            getFormattedValue: this.getFormattedValue,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            locale: this.locale,
+            cellXfsRegistry: this.cellXfsRegistry,
+        })(sheetId, activeCell, selections, location, color, style);
+    }
+    /**
+     * Create a new table spec
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     * @param tableSpec
+     * @param theme
+     * @param bandedRange
+     */
+    createTable(sheetId, activeCell, selections, tableSpec, theme, bandedRange) {
+        const sheet = this.getSheet(sheetId);
+        return createTable({
+            locale: this.locale,
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            getDependents: this.getDependents,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            onChangeTables: this.onChangeTables,
+            onRequestCalculate: this.onRequestCalculate,
+            getEffectiveValue: this.getEffectiveValue,
+            getFormattedValue: this.getFormattedValue,
+            getContentfulRangeAroundCell: this.getContentfulRangeAroundCell,
+            getSheetName: this.getSheetName,
+            theme: defaultSpreadsheetTheme,
+        })(sheetId, activeCell, selections, tableSpec, theme, bandedRange);
+    }
+    /**
+     * Updates an existing table spec
+     * @param sheetId
+     * @param updatedTable
+     * @param previousTable
+     */
+    updateTable(sheetId, tableId, updatedTable) {
+        return updateTable({
+            locale: this.locale,
+            tables: this.tables,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            getDependents: this.getDependents,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeTables: this.onChangeTables,
+            getFormattedValue: this.getFormattedValue,
+        })(sheetId, tableId, updatedTable);
+    }
+    /**
+     * Removes an existing table view
+     * @param tableView
+     */
+    removeTable(tableView) {
+        removeTable({
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            getDependents: this.getDependents,
+            onChangeSheets: this.onChangeSheets,
+            onChangeTables: this.onChangeTables,
+        })(tableView);
+    }
+    /**
+     * Insert a column into a table
+     * @param tableView
+     * @param dimensionIndex
+     * @param direction
+     */
+    insertTableColumn(tableView, dimensionIndex, direction) {
+        const sheet = this.getSheet(tableView.sheetId);
+        insertTableColumn({
+            tables: this.tables,
+            columnCount: sheet.columnCount,
+            rowCount: sheet.rowCount,
+            locale: this.locale,
+            createHistory: this.createHistory,
+            onChangeTables: this.onChangeTables,
+            onChangeSheets: this.onChangeSheets,
+            onChangeSheetData: this.onChangeSheetData,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            getDependents: this.getDependents,
+            getSheetName: this.getSheetName,
+        })(tableView, dimensionIndex, direction);
+    }
+    /**
+     * Delete a column from a table
+     * @param tableView
+     * @param dimensionIndex
+     */
+    deleteTableColumn(tableView, dimensionIndex) {
+        const sheet = this.getSheet(tableView.sheetId);
+        deleteTableColumn({
+            columnCount: sheet.columnCount,
+            rowCount: sheet.rowCount,
+            locale: this.locale,
+            getSheetName: this.getSheetName,
+            createHistory: this.createHistory,
+            onChangeTables: this.onChangeTables,
+            onChangeSheets: this.onChangeSheets,
+            onChangeSheetData: this.onChangeSheetData,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            getDependents: this.getDependents,
+        })(tableView, dimensionIndex);
+    }
+    /**
+     * Delete rows
+     * @param sheetId
+     * @param rowIndexes
+     */
+    deleteRow(sheetId, rowIndexes) {
+        const sheet = this.getSheet(sheetId);
+        deleteRow({
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+            locale: this.locale,
+            getActiveCell: this.getActiveCell,
+            getSelections: this.getSelections,
+            getDependents: this.getDependents,
+            getGraphNodes: () => this._calculationInterface.getNodes(),
+            getGraphNodesInSheet: (sheetId) => this._calculationInterface.getNodesInSheet(sheetId),
+            getSheetName: this.getSheetName,
+            createHistory: this.createHistory,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            onChangeTables: this.onChangeTables,
+            onChangeDataValidations: this.onChangeDataValidations,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+            onChangeActiveCell: this.onChangeActiveSheet,
+            onChangeSelections: this.onChangeSelections,
+        })(sheetId, rowIndexes);
+    }
+    /**
+     * Delete selected cells and shift left
+     */
+    deleteCellsShiftLeft(sheetId, activeCell, selections) {
+        const sheet = this.getSheet(sheetId);
+        deleteCellsShiftLeft({
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+            locale: this.locale,
+            getDependents: this.getDependents,
+            getActiveCell: this.getActiveCell,
+            getSelections: this.getSelections,
+            createHistory: this.createHistory,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+        })(sheetId, activeCell, selections);
+    }
+    /**
+     * Delete selected cells and shift up
+     */
+    deleteCellsShiftUp(sheetId, activeCell, selections) {
+        const sheet = this.getSheet(sheetId);
+        deleteCellsShiftUp({
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+            locale: this.locale,
+            getDependents: this.getDependents,
+            getActiveCell: this.getActiveCell,
+            getSelections: this.getSelections,
+            createHistory: this.createHistory,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+        })(sheetId, activeCell, selections);
+    }
+    /** Freeze a row index */
+    freezeRow(sheetId, rowIndex) {
+        freezeRow({
+            createHistory: this.createHistory,
+            onChangeSheets: this.onChangeSheets,
+            onChangeCharts: this.onChangeCharts,
+            onChangeEmbeds: this.onChangeEmbeds,
+        })(sheetId, rowIndex);
+    }
+    /** Freeze a column index */
+    freezeColumn(sheetId, columnIndex) {
+        freezeColumn({
+            createHistory: this.createHistory,
+            onChangeSheets: this.onChangeSheets,
+            onChangeCharts: this.onChangeCharts,
+            onChangeEmbeds: this.onChangeEmbeds,
+        })(sheetId, columnIndex);
+    }
+    /** Hide columns */
+    hideColumns(sheetId, columnIndexes) {
+        const sheet = this.getSheet(sheetId);
+        hideColumns({
+            createHistory: this.createHistory,
+            getActiveCell: this.getActiveCell,
+            getSelections: this.getSelections,
+            onChangeActiveCell: this.onChangeActiveCell,
+            onChangeSelections: this.onChangeSelections,
+            onChangeSheets: this.onChangeSheets,
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+            getNextFocusableCell: undefined,
+        })(sheetId, columnIndexes);
+    }
+    /** Hide rows */
+    hideRows(sheetId, rowIndexes) {
+        const sheet = this.getSheet(sheetId);
+        hideRows({
+            createHistory: this.createHistory,
+            getActiveCell: this.getActiveCell,
+            getSelections: this.getSelections,
+            onChangeActiveCell: this.onChangeActiveCell,
+            onChangeSelections: this.onChangeSelections,
+            onChangeSheets: this.onChangeSheets,
+            columnCount: sheet.columnCount,
+            rowCount: sheet.rowCount,
+            getNextFocusableCell: undefined,
+        })(sheetId, rowIndexes);
+    }
+    /**
+     * Apply fill operation programmatically
+     */
+    async applyFill(sheetId, activeCell, fillSelection, selections, fillableSelections, fillType) {
+        const getCellData = (sId, r, c) => this._sheetData?.[sId]?.[r]?.values?.[c];
+        const ssRegistry = this.sharedStringRegistry;
+        await applyFill({
+            locale: this.locale,
+            cellXfsRegistry: this.cellXfsRegistry,
+            // Fallback safe getters
+            getCellData,
+            getEffectiveValue: this.getEffectiveValue,
+            getFormattedValue: this.getFormattedValue,
+            getAutoFillValues,
+            enqueueCalculation: this.enqueueCalculation,
+            onChangeSheetData: this.onChangeSheetData,
+            createHistory: this.createHistory,
+            getSheetName: this.getSheetName,
+            sharedStringRegistry: ssRegistry,
+        })(sheetId, activeCell, fillSelection, selections, fillableSelections, fillType);
+    }
+    createNewSheet(sheetSpec) {
+        return createNewSheet({
+            sheetId: this.activeSheetId,
+            createHistory: this.createHistory,
+            onChangeActiveSheet: this.onChangeActiveSheet,
+            onChangeSheets: this.onChangeSheets,
+            sheets: this.sheets,
+        })(sheetSpec);
+    }
+    updateSheet(sheetId, sheetSpec) {
+        return updateSheet({
+            sheets: this.sheets,
+            locale: this.locale,
+            createHistory: this.createHistory,
+            onChangeSheets: this.onChangeSheets,
+            onChangeSheetData: this.onChangeSheetData,
+            getGraphNodes: () => this._calculationInterface.getNodes(),
+            // Use raw getPrecedents without filtering to correctly handle cross-sheet references
+            getPrecedents: (source) => this._calculationInterface.getPrecedents(source),
+        })(sheetId, sheetSpec);
+    }
+    /**
+     * Delete a sheet
+     * @param sheetId
+     */
+    deleteSheet(sheetId) {
+        deleteSheet({
+            sheets: this.sheets,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeActiveSheet: () => { },
+            onChangeSheets: this.onChangeSheets,
+            createHistory: this.createHistory,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+        })(sheetId);
+    }
+    /**
+     * Create conditional formatting rule
+     * @param rule
+     */
+    createConditionalFormattingRule(rule) {
+        createConditionalFormattingRule({
+            enqueueCalculation: this.enqueueCalculation,
+            createHistory: this.createHistory,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+        })(rule);
+    }
+    /**
+     * Update conditional formatting rule
+     * @param updatedRule
+     * @param previousRule
+     */
+    updateConditionalFormattingRule(updatedRule, previousRule) {
+        updateConditionalFormattingRule({
+            enqueueCalculation: this.enqueueCalculation,
+            createHistory: this.createHistory,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+        })(updatedRule, previousRule);
+    }
+    /**
+     * Delete conditional formatting rule
+     * @param rule
+     */
+    deleteConditionalFormattingRule(rule) {
+        deleteConditionalFormattingRule({
+            enqueueCalculation: this.enqueueCalculation,
+            createHistory: this.createHistory,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+        })(rule);
+    }
+    /**
+     * Preview conditional formatting rule
+     * @param rule
+     */
+    previewConditionalFormattingRule(rule) {
+        previewConditionalFormattingRule({
+            enqueueCalculation: this.enqueueCalculation,
+            createHistory: this.createHistory,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+        })(rule);
+    }
+    /**
+     * Create data validation rule
+     * @param rule
+     */
+    createDataValidationRule(rule) {
+        createDataValidationRule({
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeDataValidations: this.onChangeDataValidations,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            getSheetName: this.getSheetName,
+            cellXfsRegistry: this.cellXfsRegistry,
+            sharedStringRegistry: this.sharedStringRegistry,
+        })(rule);
+    }
+    /**
+     * Update data validation rule
+     * @param rule
+     * @param previousRule
+     */
+    updateDataValidationRule(rule, previousRule) {
+        updateDataValidationRule({
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeDataValidations: this.onChangeDataValidations,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            getSheetName: this.getSheetName,
+            cellXfsRegistry: this.cellXfsRegistry,
+            sharedStringRegistry: this.sharedStringRegistry,
+        })(rule, previousRule);
+    }
+    /**
+     * Delete data validation rule
+     * @param rule
+     */
+    deleteDataValidationRule(rule) {
+        deleteDataValidationRule({
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeDataValidations: this.onChangeDataValidations,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            getSheetName: this.getSheetName,
+            cellXfsRegistry: this.cellXfsRegistry,
+            sharedStringRegistry: this.sharedStringRegistry,
+        })(rule);
+    }
+    /**
+     * Delete all data validation rules
+     * @param rules
+     */
+    deleteDataValidationRules(rules) {
+        deleteDataValidationRules({
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeDataValidations: this.onChangeDataValidations,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            getSheetName: this.getSheetName,
+            cellXfsRegistry: this.cellXfsRegistry,
+            sharedStringRegistry: this.sharedStringRegistry,
+        })(rules);
+    }
+    /**
+     * Change cell decimals
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     * @param type
+     */
+    changeDecimals(sheetId, activeCell, selections, type) {
+        changeDecimals({
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            cellXfsRegistry: this.cellXfsRegistry,
+        })(sheetId, activeCell, selections, type);
+    }
+    /**
+     * Change sheet tab color
+     * @param sheetId
+     * @param color
+     */
+    changeSheetTabcolor(sheetId, color) {
+        changeSheetTabcolor({
+            onChangeSheets: this.onChangeSheets,
+            createHistory: this.createHistory,
+        })(sheetId, color);
+    }
+    /**
+     * Change theme
+     * @param theme
+     */
+    changeTheme(theme) {
+        changeTheme({
+            createHistory: this.createHistory,
+            onChangeTheme: () => { },
+        })(theme);
+    }
+    /**
+     * Clear formatting
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     */
+    clearFormatting(sheetId, activeCell, selections) {
+        clearFormatting({
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            createHistory: this.createHistory,
+            cellXfsRegistry: this.cellXfsRegistry,
+        })(sheetId, activeCell, selections);
+    }
+    /**
+     * Remove duplicate rows
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     */
+    removeDuplicates(sheetId, activeCell, selections) {
+        return removeDuplicates({
+            locale: this.locale,
+            getFormattedValue: this.getFormattedValue,
+            onChangeSheetData: this.onChangeSheetData,
+            enqueueCalculation: this.enqueueCalculation,
+            createHistory: this.createHistory,
+        })(sheetId, activeCell, selections);
+    }
+    /**
+     * Increase indent
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     */
+    increaseIndent(sheetId, activeCell, selections) {
+        increaseIndent({
+            locale: this.locale,
+            enqueueCalculation: this.enqueueCalculation,
+            onChangeSheetData: this.onChangeSheetData,
+            createHistory: this.createHistory,
+            cellXfsRegistry: this.cellXfsRegistry,
+        })(sheetId, activeCell, selections);
+    }
+    /**
+     * Decrease indent
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     */
+    decreaseIndent(sheetId, activeCell, selections) {
+        decreaseIndent({
+            locale: this.locale,
+            enqueueCalculation: this.enqueueCalculation,
+            onChangeSheetData: this.onChangeSheetData,
+            createHistory: this.createHistory,
+            cellXfsRegistry: this.cellXfsRegistry,
+        })(sheetId, activeCell, selections);
+    }
+    /**
+     * Create named range
+     * @param sheetId
+     * @param namedRange
+     */
+    createNamedRange(sheetId, namedRange) {
+        createNamedRange({
+            enqueueCalculation: this.enqueueCalculation,
+            createHistory: this.createHistory,
+            onChangeNamedRanges: this.onChangeNamedRanges,
+        })(sheetId, namedRange);
+    }
+    /**
+     * Delete named range
+     * @param id
+     */
+    deleteNamedRange(id) {
+        deleteNamedRange({
+            getDependents: this.getDependents,
+            enqueueCalculation: this.enqueueCalculation,
+            createHistory: this.createHistory,
+            onChangeNamedRanges: this.onChangeNamedRanges,
+        })(id);
+    }
+    /**
+     * Delete cells
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     * @param clearType - "contents" (default), "formats", or "all"
+     */
+    deleteCells(sheetId, activeCell, selections, clearType = "contents") {
+        const sheet = this.getSheet(sheetId);
+        deleteCells({
+            locale: this.locale,
+            rowCount: sheet.rowCount,
+            cellXfsRegistry: this.cellXfsRegistry,
+            getDependents: this.getDependents,
+            getDataRowCount: () => sheet.rowCount,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            onChangeTables: this.onChangeTables,
+            onChangeActiveCell: () => { },
+            enqueueCalculation: this.enqueueCalculation,
+            createHistory: this.createHistory,
+            isArrayFormula: () => false,
+            getRowHeight: this.getRowHeight,
+        })(sheetId, activeCell, selections, clearType);
+    }
+    /**
+     * Delete table row
+     * @param tableView
+     * @param rowIndexes
+     */
+    deleteTableRow(tableView, rowIndexes) {
+        const sheet = this.getSheet(tableView.sheetId);
+        deleteTableRow({
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+            locale: this.locale,
+            getDependents: this.getDependents,
+            getSheetName: this.getSheetName,
+            createHistory: this.createHistory,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            onChangeTables: this.onChangeTables,
+            onChangeDataValidations: this.onChangeDataValidations,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+        })(tableView, rowIndexes);
+    }
+    /**
+     * Duplicate sheet
+     * @param sheetId
+     */
+    duplicateSheet(sheetId, newSheetId) {
+        return duplicateSheet({
+            locale: this.locale,
+            maxSheetCount: 100,
+            sheets: this.sheets,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            onChangeTables: this.onChangeTables,
+            onChangeCharts: this.onChangeCharts,
+            onChangeEmbeds: this.onChangeEmbeds,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+            onChangeDataValidations: this.onChangeDataValidations,
+            onChangeActiveSheet: () => { },
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            createHistory: this.createHistory,
+        })(sheetId, newSheetId);
+    }
+    /**
+     * Create embed
+     * @param embedId
+     */
+    createEmbed(spec) {
+        createEmbed({
+            onChangeEmbeds: this.onChangeEmbeds,
+            createHistory: this.createHistory,
+        })(spec);
+    }
+    /**
+     * Delete embed
+     * @param embedId
+     */
+    deleteEmbed(embedId) {
+        deleteEmbed({
+            onChangeEmbeds: this.onChangeEmbeds,
+            createHistory: this.createHistory,
+        })(embedId);
+    }
+    /**
+     * Update embed
+     * @param embed
+     */
+    updateEmbed(embed) {
+        updateEmbed({
+            onChangeEmbeds: this.onChangeEmbeds,
+            createHistory: this.createHistory,
+        })(embed);
+    }
+    /**
+     * Move embed
+     * @param embedId
+     * @param sheetId
+     * @param anchorCell
+     * @param offsetXPixels
+     * @param offsetYPixels
+     */
+    moveEmbed(embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels) {
+        moveEmbed({
+            onChangeEmbeds: this.onChangeEmbeds,
+            createHistory: this.createHistory,
+        })(embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels);
+    }
+    /**
+     * Resize embed
+     * @param embedId
+     * @param sheetId
+     * @param anchorCell
+     * @param offsetXPixels
+     * @param offsetYPixels
+     * @param width
+     * @param height
+     */
+    resizeEmbed(embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels, width, height) {
+        resizeEmbed({
+            onChangeEmbeds: this.onChangeEmbeds,
+            createHistory: this.createHistory,
+        })(embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels, width, height);
+    }
+    /**
+     * Check if chart operations are available
+     * @returns true if @rowsncolumns/charts package is installed
+     */
+    isChartsAvailable() {
+        return isChartsAvailable();
+    }
+    /**
+     * Create a chart
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     * @param chartSpec
+     */
+    createChart(sheetId, activeCell, selections, chartSpec) {
+        safeCreateChart({
+            onChangeCharts: this.onChangeCharts,
+            getFormattedValue: this.getFormattedValue,
+            getEffectiveValue: this.getEffectiveValue,
+            createHistory: this.createHistory,
+        })(sheetId, activeCell, selections, chartSpec);
+    }
+    /**
+     * Delete a chart
+     * @param chartId
+     */
+    deleteChart(chartId) {
+        safeDeleteChart({
+            onChangeCharts: this.onChangeCharts,
+            createHistory: this.createHistory,
+        })(chartId);
+    }
+    /**
+     * Move a chart
+     * @param chartId
+     * @param anchorCell
+     * @param offsetXPixels
+     * @param offsetYPixels
+     */
+    moveChart(chartId, anchorCell, offsetXPixels, offsetYPixels) {
+        safeMoveChart({
+            onChangeCharts: this.onChangeCharts,
+            createHistory: this.createHistory,
+        })(chartId, anchorCell, offsetXPixels, offsetYPixels);
+    }
+    /**
+     * Resize a chart
+     * @param chartId
+     * @param anchorCell
+     * @param offsetXPixels
+     * @param offsetYPixels
+     * @param width
+     * @param height
+     */
+    resizeChart(chartId, anchorCell, offsetXPixels, offsetYPixels, width, height) {
+        safeResizeChart({
+            onChangeCharts: this.onChangeCharts,
+            createHistory: this.createHistory,
+        })(chartId, anchorCell, offsetXPixels, offsetYPixels, width, height);
+    }
+    /**
+     * Update a chart
+     * @param chart
+     */
+    updateChart(chart) {
+        safeUpdateChart({
+            onChangeCharts: this.onChangeCharts,
+            createHistory: this.createHistory,
+        })(chart);
+    }
+    /**
+     * Auto fit rows or columns
+     * @param sheetId
+     * @param indexes
+     * @param axis
+     * @returns
+     */
+    autoResize(sheetId, indexes, axis) {
+        return autoResize({
+            createHistory: this.createHistory,
+            onChangeSheets: this.onChangeSheets,
+            getColumnWidth: this.getColumnWidth,
+            getRowHeight: this.getRowHeight,
+            getActiveCell: this.getActiveCell,
+        })(sheetId, indexes, axis);
+    }
+    /**
+     * Resize row or column
+     * @param sheetId
+     * @param indexes
+     * @param dimension
+     * @param axis
+     * @returns
+     */
+    resize(sheetId, indexes, dimension, axis) {
+        return resize({
+            createHistory: this.createHistory,
+            onChangeSheets: this.onChangeSheets,
+            getRowHeight: this.getRowHeight,
+            getActiveCell: this.getActiveCell,
+            getCellDimensions: this.getCellDimensions,
+            isMergedCell: this.isMergedCell,
+        })(sheetId, indexes, dimension, axis);
+    }
+    async deletePivotTable(pivotId, database) {
+        return safeDeletePivotTable({
+            activeCell: this.getActiveCell(),
+            enqueueCalculation: this.enqueueCalculation,
+            onChangeActiveCell: this.onChangeActiveSheet,
+            pivotTables: this.pivotTables,
+            sheetId: this.activeSheetId,
+            cellXfsRegistry: this.cellXfsRegistry,
+            database,
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            // onCreateNewSheet:,
+            createHistory: this.createHistory,
+            onChangePivotTables: this.onChangePivotTables,
+            getColumnWidth: this.getColumnWidth,
+        })(pivotId);
+    }
+    async createPivotTable(pivotTable, createNewSheet, database) {
+        await safeCreatePivotTable({
+            activeCell: this.getActiveCell(),
+            enqueueCalculation: this.enqueueCalculation,
+            onChangeActiveCell: this.onChangeActiveSheet,
+            pivotTables: this.pivotTables,
+            sheetId: this.activeSheetId,
+            cellXfsRegistry: this.cellXfsRegistry,
+            database,
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            // onCreateNewSheet:,
+            createHistory: this.createHistory,
+            onChangePivotTables: this.onChangePivotTables,
+            getGridValues: this.getGridValuesForPivot,
+            getColumnWidth: this.getColumnWidth,
+        })(pivotTable, createNewSheet);
+    }
+    getGridValuesForPivot = (range) => {
+        let headers = [];
+        const rows = [];
+        for (let rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+            const row = [];
+            const isHeader = rowIndex === range.startRowIndex;
+            for (let columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+                row.push(this.getEffectiveValue(range.sheetId, rowIndex, columnIndex) ?? "");
+            }
+            if (isHeader) {
+                headers = row;
+            }
+            else {
+                rows.push(row);
+            }
+        }
+        return {
+            headers,
+            rows,
+        };
+    };
+    /**
+     * Create a new citation and attach it to a cell
+     * @param sheetId
+     * @param rowIndex
+     * @param columnIndex
+     * @param citation
+     */
+    createCitation(sheetId, rowIndex, columnIndex, citation) {
+        createCitation({
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeCitations: this.onChangeCitations,
+            createHistory: this.createHistory,
+        })(sheetId, rowIndex, columnIndex, citation);
+    }
+    /**
+     * Create multiple citations in a batch (adds to citations array only)
+     * @param cellCitations
+     */
+    createBatchCitations(citations) {
+        createBatchCitations({
+            onChangeCitations: this.onChangeCitations,
+            createHistory: this.createHistory,
+        })(citations);
+    }
+    /**
+     * Update an existing citation
+     * @param citationId
+     * @param updates
+     */
+    updateCitation(citationId, updates) {
+        updateCitation({
+            onChangeCitations: this.onChangeCitations,
+            createHistory: this.createHistory,
+        })(citationId, updates);
+    }
+    /**
+     * Remove a citation reference from a cell
+     * @param sheetId
+     * @param rowIndex
+     * @param columnIndex
+     */
+    removeCitationFromCell(sheetId, rowIndex, columnIndex) {
+        removeCitationFromCell({
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            createHistory: this.createHistory,
+        })(sheetId, rowIndex, columnIndex);
+    }
+    /**
+     * Delete a citation completely (removes from citations array)
+     * Note: Cells with this citationId will still have the reference
+     * @param citationId
+     */
+    deleteCitation(citationId) {
+        deleteCitation({
+            onChangeCitations: this.onChangeCitations,
+            createHistory: this.createHistory,
+        })(citationId);
+    }
+}
+/**
+ * Simple sheet interface for some getters
+ */
+class SheetInterface {
+    sheet;
+    constructor(sheet) {
+        this.sheet = sheet;
+    }
+    get name() {
+        return this.sheet?.title;
+    }
+    get rowCount() {
+        return this.sheet?.rowCount ?? DEFAULT_ROW_COUNT;
+    }
+    get columnCount() {
+        return this.sheet?.columnCount ?? DEFAULT_COLUMN_COUNT;
+    }
+    get frozenColumns() {
+        return this.sheet?.frozenColumnCount ?? 0;
+    }
+    get frozenRows() {
+        return this.sheet?.frozenRowCount ?? 0;
+    }
+}