@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/hooks/utils/sort-rows.js

@@ -0,0 +1,102 @@
+import { cellValueSorter } from "../../api/sort";
+const toSortableValue = (value) => {
+    if (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean" ||
+        value == null) {
+        return value;
+    }
+    return String(value);
+};
+/**
+ * Case-insensitive string equality for color matching. Sort entries are
+ * already theme-resolved by the caller (via `getStringifiedColor`), so
+ * we don't need to handle theme-indexed objects or ARGB stripping here.
+ */
+const sameColor = (left, right) => typeof left === "string" && left.toLowerCase() === right.toLowerCase();
+/**
+ * "Surface to the top" comparator. When ASCENDING, cells matching the
+ * target go first; ties between matching/non-matching cells are kept
+ * stable. DESCENDING flips the direction.
+ */
+const surfaceMatchSorter = (leftMatches, rightMatches, sortOrder) => {
+    if (leftMatches === rightMatches)
+        return 0;
+    const direction = sortOrder === "ASCENDING" ? -1 : 1;
+    return leftMatches ? direction : -direction;
+};
+/** Custom-list comparator. Values not in the list sort last. */
+const customListSorter = (left, right, list, sortOrder) => {
+    const indexOf = (v) => {
+        if (v == null)
+            return -1;
+        const s = String(v).toLowerCase();
+        return list.findIndex((entry) => entry.toLowerCase() === s);
+    };
+    const li = indexOf(left);
+    const ri = indexOf(right);
+    // Values absent from the list go to the end regardless of direction.
+    if (li === -1 && ri === -1)
+        return 0;
+    if (li === -1)
+        return 1;
+    if (ri === -1)
+        return -1;
+    const diff = li - ri;
+    return (sortOrder === "ASCENDING" ? 1 : -1) * Math.sign(diff);
+};
+const sortValueOne = (left, right, spec) => {
+    const sortOrder = spec.sortOrder;
+    if (spec.sortBy === "cellColor" || spec.sortBy === "fontColor") {
+        const target = spec.sortColor;
+        if (!target)
+            return 0;
+        return surfaceMatchSorter(sameColor(left, target), sameColor(right, target), sortOrder);
+    }
+    if (spec.sortBy === "icon") {
+        const target = spec.sortIcon;
+        if (!target)
+            return 0;
+        const isMatch = (val) => {
+            const icon = val;
+            return icon?.iconSet === target.iconSet && icon?.iconId === target.iconId;
+        };
+        return surfaceMatchSorter(isMatch(left), isMatch(right), sortOrder);
+    }
+    if (spec.customList?.length) {
+        return customListSorter(toSortableValue(left), toSortableValue(right), spec.customList, sortOrder);
+    }
+    return cellValueSorter(toSortableValue(left), toSortableValue(right), sortOrder);
+};
+/** Normalize the legacy `SortOrder[]` shape to `DimensionSortSpec[]`. */
+const normalizeSpecs = (specs) => specs.map((s) => (typeof s === "string" ? { sortOrder: s } : s));
+const compareSortValues = (leftValues, rightValues, specs) => {
+    const columnLength = Math.max(leftValues.length, rightValues.length);
+    for (let i = 0; i < columnLength; i++) {
+        const spec = specs[i] ?? specs[0] ?? { sortOrder: "ASCENDING" };
+        const diff = sortValueOne(leftValues[i], rightValues[i], spec);
+        if (diff !== 0) {
+            return diff;
+        }
+    }
+    return 0;
+};
+export const sortRowEntriesByFrozenState = (rowEntries, frozenRowCount, 
+/**
+ * Sort specifications per dimension. Accepts either the legacy
+ * `SortOrder[]` array (back-compat) or the richer `DimensionSortSpec[]`
+ * with `sortBy`/`sortColor`/`sortIcon`/`customList`.
+ */
+sortSpecs) => {
+    const normalized = normalizeSpecs(sortSpecs);
+    if (!frozenRowCount) {
+        rowEntries.sort((left, right) => compareSortValues(left.sortValues, right.sortValues, normalized));
+        return rowEntries;
+    }
+    const frozenEntries = rowEntries.filter((entry) => entry.rowIndex <= frozenRowCount);
+    const nonFrozenEntries = rowEntries.filter((entry) => entry.rowIndex > frozenRowCount);
+    const comparator = (left, right) => compareSortValues(left.sortValues, right.sortValues, normalized);
+    frozenEntries.sort(comparator);
+    nonFrozenEntries.sort(comparator);
+    return [...frozenEntries, ...nonFrozenEntries];
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,38 @@
+export * from "./generated-names";
+export * from "./hooks/use-spreadsheet-state";
+export * from "./hooks/use-on-copy";
+export { generateDataFromClipboard, pickFormatting, pickFormula, pickValue, transpose, } from "./api/copy-paste";
+export * from "./hooks/use-calculation";
+export * from "./hooks/use-on-change-batch-stream";
+export * from "./hooks/use-on-trace-dependents-precedents";
+export * from "./hooks/use-structured-reference";
+export * from "./hooks/use-undo-redo";
+export * from "./hooks/use-async-datasource";
+export * from "./hooks/use-search";
+export * from "./hooks/use-calculation-initialize";
+export * from "./hooks/use-comments";
+export * from "./components";
+export * from "./api/datatype";
+export * from "./sheet-cell";
+export { useSubscribeToSheet, useSubscribeToMultipleRanges, } from "./hooks/use-sheet-observer";
+export * from "./helpers";
+export * from "./api/fill";
+export * from "./api/immer-utils";
+export * from "./api/range";
+export * from "./atoms";
+export * from "./api/formula";
+export * from "./types";
+export * from "./commands";
+export type { ClearType } from "./interface/delete-cells";
+export * from "./hooks/use-cellxfs-registry";
+export * from "./hooks/use-ss-registry";
+export * from "./hooks/use-sheet-properties";
+export * from "./hooks/use-on-remove-duplicates";
+export * from "./hooks/use-on-locale-change";
+export * from "./hooks/use-on-request-resize";
+export * from "./hooks/use-on-request-edit-table";
+export * from "./hooks/use-on-request-delete-sheet";
+export * from "./hooks/use-on-request-data-validation";
+export * from "./hooks/use-on-request-define-named-range";
+export * from "./hooks/use-on-request-update-named-range";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,qBAAqB,CAAC;AACpC,OAAO,EACL,yBAAyB,EACzB,cAAc,EACd,WAAW,EACX,SAAS,EACT,SAAS,GACV,MAAM,kBAAkB,CAAC;AAC1B,cAAc,yBAAyB,CAAC;AACxC,cAAc,oCAAoC,CAAC;AACnD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,kCAAkC,CAAC;AACjD,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,oCAAoC,CAAC;AACnD,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,OAAO,EACL,mBAAmB,EACnB,4BAA4B,GAC7B,MAAM,4BAA4B,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,YAAY,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAG7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,qCAAqC,CAAC;AACpD,cAAc,wCAAwC,CAAC;AACvD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,2CAA2C,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1,39 @@
+export * from "./generated-names";
+export * from "./hooks/use-spreadsheet-state";
+export * from "./hooks/use-on-copy";
+export { generateDataFromClipboard, pickFormatting, pickFormula, pickValue, transpose, } from "./api/copy-paste";
+export * from "./hooks/use-calculation";
+export * from "./hooks/use-on-change-batch-stream";
+export * from "./hooks/use-on-trace-dependents-precedents";
+export * from "./hooks/use-structured-reference";
+export * from "./hooks/use-undo-redo";
+export * from "./hooks/use-async-datasource";
+export * from "./hooks/use-search";
+export * from "./hooks/use-calculation-initialize";
+export * from "./hooks/use-comments";
+export * from "./components";
+export * from "./api/datatype";
+export * from "./sheet-cell";
+export { useSubscribeToSheet, useSubscribeToMultipleRanges, } from "./hooks/use-sheet-observer";
+export * from "./helpers";
+export * from "./api/fill";
+export * from "./api/immer-utils";
+export * from "./api/range";
+export * from "./atoms";
+export * from "./api/formula";
+export * from "./types";
+export * from "./commands";
+// Register
+export * from "./hooks/use-cellxfs-registry";
+export * from "./hooks/use-ss-registry";
+export * from "./hooks/use-sheet-properties";
+export * from "./hooks/use-on-remove-duplicates";
+export * from "./hooks/use-on-locale-change";
+// Dialog-opener hooks external engine chrome bridges to (they write the payload
+// atoms the dialog hosts read; nothing else exports them).
+export * from "./hooks/use-on-request-resize";
+export * from "./hooks/use-on-request-edit-table";
+export * from "./hooks/use-on-request-delete-sheet";
+export * from "./hooks/use-on-request-data-validation";
+export * from "./hooks/use-on-request-define-named-range";
+export * from "./hooks/use-on-request-update-named-range";

package/dist/esm/interface/apply-fill.d.ts

@@ -0,0 +1,6 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, SelectionAttributes, Sheet } from "@rowsncolumns/spreadsheet";
+import type { AutoFillType } from "../api/fill";
+import type { UseOnFillProps } from "../hooks/use-on-fill";
+export declare const applyFill: <T extends CellData, S extends Sheet>({ locale, cellXfsRegistry, sharedStringRegistry, getDataValidationById, getCellData, getEffectiveValue, getFormattedValue, getAutoFillValues, getSheetName, enqueueCalculation, enqueueStructureChange, onChangeSheetData, createHistory, onChangeDataValidations, }: UseOnFillProps<T, S>) => (sheetId: number, activeCell: CellInterface, fillSelection: SelectionArea, selections: SelectionArea<SelectionAttributes>[], fillableSelections?: SelectionArea<SelectionAttributes>[], fillType?: AutoFillType) => Promise<void>;
+//# sourceMappingURL=apply-fill.d.ts.map

package/dist/esm/interface/apply-fill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-fill.d.ts","sourceRoot":"","sources":["../../../interface/apply-fill.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG/E,OAAO,KAAK,EACV,QAAQ,EACR,mBAAmB,EACnB,KAAK,EACN,MAAM,2BAA2B,CAAC;AAInC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAU3D,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,sQAe5D,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAGnB,SAAS,MAAM,EAEf,YAAY,aAAa,EAEzB,eAAe,aAAa,EAE5B,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,EAChD,qBAAqB,aAAa,CAAC,mBAAmB,CAAC,EAAE,EAEzD,WAAW,YAAY,kBA0Q1B,CAAC"}

package/dist/esm/interface/apply-fill.js

@@ -0,0 +1,195 @@
+import { Direction } from "@rowsncolumns/common-types";
+import { selectionFromActiveCell } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { defaultCellCoords, defaultSheetId, SheetCell } from "../sheet-cell";
+import { getFillDirection } from "./../api/selection";
+import { collectDataValidationTarget, extendDataValidationRanges, } from "./data-validation-utils";
+export const applyFill = ({ locale, cellXfsRegistry, sharedStringRegistry, getDataValidationById, getCellData, getEffectiveValue, getFormattedValue, getAutoFillValues, getSheetName, enqueueCalculation, enqueueStructureChange, onChangeSheetData, createHistory, onChangeDataValidations, }) => {
+    return async (
+    // Active sheet ID
+    sheetId, 
+    // Active cell
+    activeCell, 
+    // Selections including the current selection that will be filled
+    fillSelection, 
+    // Current selections of the user
+    selections, fillableSelections, 
+    // Fill type - if not specified, will auto-detect
+    fillType) => {
+        const finalSelections = selections.length
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        const selection = finalSelections[finalSelections.length - 1];
+        const saveHistory = createHistory();
+        const { range: fillBounds } = fillSelection;
+        const direction = getFillDirection(fillSelection, selection);
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        const dataValidationTargets = new Map();
+        // Get fill values
+        const fillValues = await getAutoFillValues({
+            sheetId,
+            direction,
+            fillBounds,
+            getCellData,
+            getEffectiveValue,
+            getFormattedValue,
+            getSheetName,
+            selection,
+            locale,
+            cellXfsRegistry,
+            getDataValidationById,
+            fillType,
+        });
+        // Sample cell
+        const sheetCell = new SheetCell(defaultSheetId, defaultCellCoords, undefined, { locale, cellXfsRegistry, getDataValidationById });
+        const getFillValue = (rowIndex, columnIndex) => {
+            const fillValue = fillValues[rowIndex][columnIndex];
+            if (typeof fillValue !== "object") {
+                sheetCell.setUserEnteredValue(fillValue);
+                sharedStringRegistry?.registerCell(sheetCell);
+                const newCellData = sheetCell.getCellData();
+                return newCellData;
+            }
+            return fillValue;
+        };
+        // Fill writes through `onChangeSheetData` directly. The calculator
+        // only invalidates `rangeCache` for cells it recomputes, so the
+        // freshly-filled positions stay cached until we tell it otherwise.
+        // `fillBounds` is the union of source + filled area — exactly the
+        // rectangle whose cached ranges could be stale.
+        enqueueStructureChange?.({
+            kind: "invalidate-range",
+            sheetId,
+            startRowIndex: fillBounds.startRowIndex,
+            endRowIndex: fillBounds.endRowIndex,
+            startColumnIndex: fillBounds.startColumnIndex,
+            endColumnIndex: fillBounds.endColumnIndex,
+        });
+        // Copy sheetdata
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                switch (direction) {
+                    case Direction.Down: {
+                        const start = selection.range.endRowIndex + 1;
+                        const end = fillBounds.endRowIndex;
+                        let counter = 0;
+                        for (let i = start; i <= end; i++) {
+                            let rowIndex = selection.range.startRowIndex + counter;
+                            if (rowIndex > selection.range.endRowIndex) {
+                                counter = 0;
+                                rowIndex = selection.range.startRowIndex;
+                            }
+                            const rollingRowIndex = i - start;
+                            for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                                const rollingColumnIndex = columnIndex - selection.range.startColumnIndex;
+                                const newSheet = createSheetDraft(draft, sheetId, i);
+                                const newCellData = getFillValue(rollingRowIndex, rollingColumnIndex);
+                                newSheet[i].values[columnIndex] = newCellData;
+                                collectDataValidationTarget(dataValidationTargets, sheetId, i, columnIndex, newCellData);
+                                enqueueCalculation({
+                                    position: { rowIndex: i, columnIndex, sheetId },
+                                    type: "add",
+                                    force: true,
+                                });
+                                recalcCells.set(createSheetCellIdentifier(sheetId, i, columnIndex), { rowIndex: i, columnIndex, sheetId, force: true });
+                            }
+                            counter++;
+                        }
+                        break;
+                    }
+                    case Direction.Up: {
+                        const start = selection.range.startRowIndex - 1;
+                        const end = fillBounds.startRowIndex;
+                        for (let i = start; i >= end; i--) {
+                            const rollingRowIndex = i - fillBounds.startRowIndex;
+                            for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                                const rollingColumnIndex = columnIndex - selection.range.startColumnIndex;
+                                const newSheet = createSheetDraft(draft, sheetId, i);
+                                newSheet[i].values[columnIndex] = getFillValue(rollingRowIndex, rollingColumnIndex);
+                                collectDataValidationTarget(dataValidationTargets, sheetId, i, columnIndex, newSheet[i].values[columnIndex]);
+                                enqueueCalculation({
+                                    position: { rowIndex: i, columnIndex, sheetId },
+                                    type: "add",
+                                    force: true,
+                                });
+                                recalcCells.set(createSheetCellIdentifier(sheetId, i, columnIndex), { rowIndex: i, columnIndex, sheetId, force: true });
+                            }
+                        }
+                        break;
+                    }
+                    case Direction.Right: {
+                        for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                            const start = selection.range.endColumnIndex + 1;
+                            const end = fillBounds.endColumnIndex;
+                            let counter = 0;
+                            const rollingRowIndex = rowIndex - selection.range.startRowIndex;
+                            for (let j = start; j <= end; j++) {
+                                let columnIndex = selection.range.startColumnIndex + counter;
+                                if (columnIndex > selection.range.endColumnIndex) {
+                                    counter = 0;
+                                    columnIndex = selection.range.startColumnIndex;
+                                }
+                                const rollingColumnIndex = j - start;
+                                const newSheet = createSheetDraft(draft, sheetId, rowIndex);
+                                newSheet[rowIndex].values[j] = getFillValue(rollingRowIndex, rollingColumnIndex);
+                                collectDataValidationTarget(dataValidationTargets, sheetId, rowIndex, j, newSheet[rowIndex].values[j]);
+                                enqueueCalculation({
+                                    position: { rowIndex, columnIndex: j, sheetId },
+                                    type: "add",
+                                    force: true,
+                                });
+                                recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, j), { rowIndex, columnIndex: j, sheetId, force: true });
+                                counter++;
+                            }
+                        }
+                        break;
+                    }
+                    case Direction.Left: {
+                        for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                            const start = selection.range.startColumnIndex - 1;
+                            const end = fillBounds.startColumnIndex;
+                            const rollingRowIndex = rowIndex - selection.range.startRowIndex;
+                            let counter = 0;
+                            for (let j = start; j >= end; j--) {
+                                let columnIndex = selection.range.endColumnIndex + counter;
+                                if (columnIndex < selection.range.startColumnIndex) {
+                                    counter = 0;
+                                    columnIndex = selection.range.endColumnIndex;
+                                }
+                                const rollingColumnIndex = j - fillBounds.startColumnIndex;
+                                const newSheet = createSheetDraft(draft, sheetId, rowIndex);
+                                newSheet[rowIndex].values[j] = getFillValue(rollingRowIndex, rollingColumnIndex);
+                                collectDataValidationTarget(dataValidationTargets, sheetId, rowIndex, j, newSheet[rowIndex].values[j]);
+                                enqueueCalculation({
+                                    position: { rowIndex, columnIndex: j, sheetId },
+                                    type: "add",
+                                    force: true,
+                                });
+                                recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, j), { rowIndex, columnIndex: j, sheetId, force: true });
+                                counter--;
+                            }
+                        }
+                        break;
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                sheetId: { undo: sheetId, redo: sheetId },
+                activeCell: { undo: activeCell, redo: activeCell },
+                selections: {
+                    undo: fillableSelections ?? selections,
+                    redo: [fillSelection],
+                },
+            });
+            extendDataValidationRanges(dataValidationTargets, onChangeDataValidations, saveHistory);
+            sharedStringRegistry?.getPatches(saveHistory);
+            return nextState;
+        });
+    };
+};

package/dist/esm/interface/auto-resize.d.ts

@@ -0,0 +1,4 @@
+import type { AXIS, CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnAutoResizeProps } from "../hooks/use-on-autoresize";
+export declare const autoResize: <T extends CellData, S extends Sheet>({ createHistory, getActiveCell, onChangeSheets, getColumnWidth, getRowHeight, getCellDimensions, isMergedCell, }: UseOnAutoResizeProps<T, S>) => (sheetId: number, indexes: number[], axis: AXIS) => void;
+//# sourceMappingURL=auto-resize.d.ts.map

package/dist/esm/interface/auto-resize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-resize.d.ts","sourceRoot":"","sources":["../../../interface/auto-resize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,QAAQ,EAER,KAAK,EACN,MAAM,2BAA2B,CAAC;AAInC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAGvE,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,kHAQ7D,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,MACnB,SAAS,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,IAAI,SAuDvD,CAAC"}

package/dist/esm/interface/auto-resize.js

@@ -0,0 +1,50 @@
+import { isNil } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { autoResizeRows } from "./resize-utils";
+export const autoResize = ({ createHistory, getActiveCell, onChangeSheets, getColumnWidth, getRowHeight, getCellDimensions, isMergedCell, }) => {
+    return (sheetId, indexes, axis) => {
+        const saveHistory = createHistory();
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (sheet) {
+                    const metaData = axis === "x" ? "rowMetadata" : "columnMetadata";
+                    if (!sheet[metaData]) {
+                        sheet[metaData] = [];
+                    }
+                    for (const index of indexes) {
+                        const dimension = axis === "y"
+                            ? getColumnWidth?.(sheetId, index, {
+                                fallbackToDefaultIfEmpty: true,
+                            })
+                            : getRowHeight?.(sheetId, index);
+                        if (!isNil(dimension)) {
+                            sheet[metaData][index] = {
+                                size: dimension,
+                                resizedByUser: false,
+                            };
+                            if (axis === "y") {
+                                autoResizeRows({
+                                    sheet,
+                                    sheetId,
+                                    columnIndexes: [index],
+                                    dimension,
+                                    getCellDimensions,
+                                    getRowHeight,
+                                    isMergedCell,
+                                });
+                            }
+                        }
+                    }
+                }
+            });
+            // Save to history
+            saveHistory({
+                sheets: { patches, inversePatches },
+                sheetId: { undo: sheetId, redo: sheetId },
+                activeCell: { undo: getActiveCell(), redo: getActiveCell() },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/esm/interface/calculation-interface.d.ts

@@ -0,0 +1,67 @@
+import type { Worker as NodeWorker } from "node:worker_threads";
+import { type CalculationPrimitive } from "@rowsncolumns/calculation-worker/server";
+import type { CellFormat, IterativeCalculationOptions, StructuredResult } from "@rowsncolumns/common-types";
+import type { CellCoordinate, CellCoordinateRange } from "@rowsncolumns/dag";
+import type { NamedRange, TableView } from "@rowsncolumns/spreadsheet";
+import type { CalculationOperation, CalculationResult, StructureChange } from "../hooks/use-calculation";
+type CalculationResultEntry = [
+    position: CellCoordinate,
+    result: CalculationResult,
+    formatting?: CellFormat
+];
+export type CalculationInterfaceOptions = {
+    locale?: string;
+    iterativeCalculation?: IterativeCalculationOptions;
+    createWorker?: () => Worker | NodeWorker;
+    clientOnlyFunctionPattern?: RegExp;
+    getSheetName(sheetId: number): string;
+    getSheetId(sheetName: string): number | undefined;
+    getSheets(): Array<{
+        sheetId: number;
+        title: string;
+    }>;
+    getTables(): TableView[];
+    getNamedRanges(): NamedRange[];
+    getFinalUserEnteredValue(position: CellCoordinate): string | undefined;
+    getEffectiveValue(sheetId: number, rowIndex: number, columnIndex: number, property?: string): CalculationPrimitive;
+    getEffectiveStructuredValue?(structuredValue: StructuredResult, property?: keyof StructuredResult): CalculationPrimitive | undefined;
+    onResults(results: CalculationResultEntry[]): void;
+    onBeginCalculation?(dirtyCells: CellCoordinate[]): void;
+};
+export declare class CalculationInterface {
+    private readonly options;
+    private readonly graph;
+    private readonly workerClient;
+    private operationQueue;
+    private graphOperationQueue;
+    private flushScheduled;
+    private graphFlushScheduled;
+    private metadataDirty;
+    private lastMetadataSignature;
+    private pendingFlush;
+    constructor(options: CalculationInterfaceOptions);
+    enqueueCalculation: (operation: CalculationOperation) => void;
+    enqueueGraphOperation: (operation: CalculationOperation) => void;
+    enqueueStructureChange: (_change: StructureChange) => void;
+    getDependents(source: CellCoordinate | CellCoordinateRange): (import("@rowsncolumns/dag").CellNode | import("@rowsncolumns/dag").StaticNode)[];
+    getPrecedents(source: CellCoordinate | CellCoordinateRange): (import("@rowsncolumns/dag").CellNode | import("@rowsncolumns/dag").StaticNode | import("@rowsncolumns/dag").CellRangeNode)[];
+    getNodes(): Map<string, import("@rowsncolumns/dag").CellNode | import("@rowsncolumns/dag").StaticNode | import("@rowsncolumns/dag").CellRangeNode>;
+    getNodesInSheet(sheetId: number): ReadonlyMap<string, import("@rowsncolumns/dag").CellNode | import("@rowsncolumns/dag").CellRangeNode> | undefined;
+    markMetadataDirty: () => void;
+    flush(): Promise<void>;
+    flushWithResults(): Promise<CalculationResultEntry[]>;
+    calculate(operations: CalculationOperation[]): Promise<CalculationResultEntry[]>;
+    rebuildGraph(operations: CalculationOperation[]): void;
+    dispose(): void;
+    private scheduleFlush;
+    private scheduleGraphFlush;
+    private buildWorkerMetadata;
+    private buildMetadataSignature;
+    private ensureWorkerMetadata;
+    private isClientOnlyFormula;
+    private executeOperations;
+    private createDefaultWorker;
+    private ensureWorker;
+}
+export {};
+//# sourceMappingURL=calculation-interface.d.ts.map

package/dist/esm/interface/calculation-interface.d.ts.map

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