@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/hooks/use-ss-registry.d.ts

@@ -0,0 +1,6 @@
+import { type Dispatch, type SetStateAction } from "react";
+import { SharedStringRegistry } from "../shared-string-registry";
+import type { SharedStrings } from "../types";
+export { SharedStringRegistry } from "../shared-string-registry";
+export declare const useSharedStringRegistry: (sharedStrings?: SharedStrings | null, onChangeSharedStrings?: Dispatch<SetStateAction<SharedStrings>>) => SharedStringRegistry;
+//# sourceMappingURL=use-ss-registry.d.ts.map

package/dist/cjs/hooks/use-ss-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-ss-registry.d.ts","sourceRoot":"","sources":["../../../hooks/use-ss-registry.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,cAAc,EAIpB,MAAM,OAAO,CAAC;AAEf,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEjE,eAAO,MAAM,uBAAuB,GAClC,gBAAgB,aAAa,GAAG,IAAI,EACpC,wBAAwB,QAAQ,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC,yBAkBhE,CAAC"}

package/dist/cjs/hooks/use-ss-registry.js

@@ -0,0 +1,17 @@
+import { useIsomorphicLayoutEffect } from "@rowsncolumns/spreadsheet";
+import { useCallback, useMemo, useRef, } from "react";
+import { SharedStringRegistry } from "../shared-string-registry";
+export { SharedStringRegistry } from "../shared-string-registry";
+export var useSharedStringRegistry = function (sharedStrings, onChangeSharedStrings) {
+    var ssRegistryRef = useRef(null);
+    var getRegistry = useCallback(function () {
+        if (!ssRegistryRef.current) {
+            ssRegistryRef.current = new SharedStringRegistry(sharedStrings, onChangeSharedStrings);
+        }
+        return ssRegistryRef.current;
+    }, [sharedStrings, onChangeSharedStrings]);
+    useIsomorphicLayoutEffect(function () {
+        getRegistry().setSharedStrings(sharedStrings);
+    }, [sharedStrings, getRegistry]);
+    return useMemo(function () { return getRegistry(); }, [getRegistry]);
+};

package/dist/cjs/hooks/use-structured-reference.d.ts

@@ -0,0 +1,8 @@
+import type { CellCoords, CellRange } from "@rowsncolumns/fast-formula-parser";
+import type { TableView } from "@rowsncolumns/spreadsheet";
+export declare const useStructuredReference: ({ tables, sheetId, getSheetName, }: {
+    tables: TableView[] | undefined;
+    sheetId: number;
+    getSheetName(sheetId: number): string;
+}) => (tableName: string | undefined, columnNames: string[] | undefined, thisRow: boolean, specialItem: string | undefined, sheetName: string, cell: CellCoords) => CellRange | CellCoords;
+//# sourceMappingURL=use-structured-reference.d.ts.map

package/dist/cjs/hooks/use-structured-reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-structured-reference.d.ts","sourceRoot":"","sources":["../../../hooks/use-structured-reference.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAG/E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAK3D,eAAO,MAAM,sBAAsB,GAAI,oCAIpC;IACD,MAAM,EAAE,SAAS,EAAE,GAAG,SAAS,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;CACvC,iBAGgB,MAAM,GAAG,SAAS,eAChB,MAAM,EAAE,GAAG,SAAS,WACxB,OAAO,eACH,MAAM,GAAG,SAAS,aACpB,MAAM,QACX,UAAU,KACf,SAAS,GAAG,UAsJlB,CAAC"}

package/dist/cjs/hooks/use-structured-reference.js

@@ -0,0 +1,132 @@
+import { __read } from "tslib";
+import { FormulaError } from "@rowsncolumns/fast-formula-parser";
+import { isCellWithinBounds } from "@rowsncolumns/grid";
+import { getColumnIndexFromColumnName } from "@rowsncolumns/spreadsheet";
+import { isNil } from "@rowsncolumns/utils";
+import { useCallback } from "react";
+export var useStructuredReference = function (_a) {
+    var tables = _a.tables, sheetId = _a.sheetId, getSheetName = _a.getSheetName;
+    return useCallback(function (tableName, columnNames, thisRow, specialItem, sheetName, cell) {
+        var _a, _b;
+        // If there is no tablename, we need to find table based
+        // on cell
+        var table = tables === null || tables === void 0 ? void 0 : tables.find(function (table) {
+            if (tableName) {
+                return table.title === tableName;
+            }
+            return (isCellWithinBounds({ rowIndex: cell.row, columnIndex: cell.col }, table.range) && table.sheetId === sheetId);
+        });
+        // Current row
+        var rowIndex = cell.row;
+        if (!table) {
+            throw new FormulaError("#NAME!", "Table could not be found");
+        }
+        // Special this row item
+        if (specialItem === "#This Row") {
+            thisRow = true;
+        }
+        var range = table.range;
+        var headerRow = (_a = table.headerRow) !== null && _a !== void 0 ? _a : true;
+        var totalRow = (_b = table.totalRow) !== null && _b !== void 0 ? _b : false;
+        var headerRowOffset = headerRow ? 1 : 0;
+        var totalRowOffset = totalRow ? 1 : 0;
+        var _c = __read(columnNames !== null && columnNames !== void 0 ? columnNames : [], 2), from = _c[0], to = _c[1];
+        var startColIndex = getColumnIndexFromColumnName(table, from);
+        var endColIndex = getColumnIndexFromColumnName(table, to);
+        // Exit early, if column could not be found
+        if (!isNil(to) && isNil(endColIndex)) {
+            throw new FormulaError("#VALUE!", "Column not found ".concat(to));
+        }
+        if (!isNil(from) && isNil(startColIndex)) {
+            throw new FormulaError("#VALUE!", "Column not found ".concat(from));
+        }
+        var startColumnIndex = isNil(startColIndex)
+            ? range.startColumnIndex
+            : startColIndex;
+        var endColumnIndex = isNil(endColIndex) && isNil(startColIndex)
+            ? range.endColumnIndex
+            : isNil(endColIndex)
+                ? startColumnIndex
+                : endColIndex;
+        // Headers only
+        if (specialItem === "#Headers") {
+            return {
+                from: {
+                    row: range.startRowIndex,
+                    col: startColumnIndex,
+                },
+                to: {
+                    row: range.startRowIndex,
+                    col: endColumnIndex,
+                },
+                sheet: getSheetName(table.sheetId),
+            };
+        }
+        // All
+        if (specialItem === "#All") {
+            return {
+                from: {
+                    row: range.startRowIndex,
+                    col: startColumnIndex,
+                },
+                to: {
+                    row: range.endRowIndex,
+                    col: endColumnIndex,
+                },
+                sheet: getSheetName(table.sheetId),
+            };
+        }
+        // All
+        if (specialItem === "#Data") {
+            return {
+                from: {
+                    row: range.startRowIndex + headerRowOffset,
+                    col: startColumnIndex,
+                },
+                to: {
+                    row: range.endRowIndex - totalRowOffset,
+                    col: endColumnIndex,
+                },
+                sheet: getSheetName(table.sheetId),
+            };
+        }
+        if (isNil(columnNames)) {
+            throw new FormulaError("#VALUE!", "No columns selected from ".concat(tableName));
+        }
+        // If column is not found, lets not select anything
+        if (from && isNil(startColIndex)) {
+            throw new FormulaError("#VALUE!", "Column: ".concat(from, " could not be found"));
+        }
+        if (to && isNil(endColIndex)) {
+            throw new FormulaError("#VALUE!", "Column: ".concat(to, " could not be found"));
+        }
+        // Check if thisrow is active and current cell is in bounds
+        if (thisRow &&
+            (rowIndex < range.startRowIndex || rowIndex > range.endRowIndex)) {
+            throw new FormulaError("#VALUE!", "Value could not be found");
+        }
+        // From row
+        var fromRow = thisRow ? rowIndex : range.startRowIndex;
+        var toRow = thisRow ? rowIndex : range.endRowIndex;
+        // Cell reference
+        if (fromRow === toRow && startColumnIndex === endColumnIndex) {
+            return {
+                row: fromRow,
+                col: startColumnIndex,
+                sheet: getSheetName(table.sheetId),
+            };
+        }
+        // Range reference
+        return {
+            from: {
+                row: thisRow ? rowIndex : range.startRowIndex + headerRowOffset,
+                col: startColumnIndex,
+            },
+            to: {
+                row: thisRow ? rowIndex : range.endRowIndex - totalRowOffset,
+                col: endColumnIndex,
+            },
+            sheet: getSheetName(table.sheetId),
+        };
+    }, [tables, getSheetName, sheetId]);
+};

package/dist/cjs/hooks/use-undo-redo-actions.d.ts

@@ -0,0 +1,40 @@
+import type { CanvasGridProps, CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { Patch } from "immer";
+import type { CalculationOperation } from "./use-calculation";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseUndoRedoActionsProps<T extends CellData, S extends Sheet> = {
+    sheetId: number;
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeCharts?: UseSpreadsheetProps<T, S>["onChangeCharts"];
+    onChangeEmbeds?: UseSpreadsheetProps<T, S>["onChangeEmbeds"];
+    onChangeTables?: UseSpreadsheetProps<T, S>["onChangeTables"];
+    onChangeNamedRanges?: UseSpreadsheetProps<T, S>["onChangeNamedRanges"];
+    onChangeCellXfs?: UseSpreadsheetProps<T, S>["onChangeCellXfs"];
+    onChangeSlicers?: UseSpreadsheetProps<T, S>["onChangeSlicers"];
+    onChangeCitations?: UseSpreadsheetProps<T, S>["onChangeCitations"];
+    onChangeSharedStrings?: UseSpreadsheetProps<T, S>["onChangeSharedStrings"];
+    onChangeProtectedRanges?: UseSpreadsheetProps<T, S>["onChangeProtectedRanges"];
+    onChangeConditionalFormats?: UseSpreadsheetProps<T, S>["onChangeConditionalFormats"];
+    onChangeDataValidations?: UseSpreadsheetProps<T, S>["onChangeDataValidations"];
+    onChangeTheme?: UseSpreadsheetProps<T, S>["onChangeTheme"];
+    onChangeActiveCell: CanvasGridProps<T>["onChangeActiveCell"];
+    onChangeSelections: CanvasGridProps<T>["onChangeSelections"];
+    onChangePivotTables: UseSpreadsheetProps<T, S>["onChangePivotTables"];
+    onChangeActiveSheet(sheetId: number): void;
+    enqueueCalculation(operation: CalculationOperation): void;
+    /**
+     * Clear the calculator's range cache. Undo/redo replays structural
+     * patches without going through `enqueueStructureChange`, so any cached
+     * range values whose cells shifted under the original op would otherwise
+     * remain stale. Clearing wholesale is cheap — the cache rebuilds lazily.
+     */
+    clearRangeCache?: () => void;
+};
+export declare const useUndoRedoActions: <T extends CellData, S extends Sheet>({ sheetId, onChangeSheets, onChangeSheetData, onChangeActiveCell, onChangeSelections, onChangeActiveSheet, onChangePivotTables, onChangeTables, onChangeNamedRanges, onChangeEmbeds, onChangeCharts, onChangeTheme, onChangeCellXfs, onChangeConditionalFormats, onChangeDataValidations, onChangeProtectedRanges, onChangeSlicers, onChangeCitations, onChangeSharedStrings, enqueueCalculation, clearRangeCache, }: UseUndoRedoActionsProps<T, S>) => {
+    onUndoAction: (patch: SpreadsheetPatch<Patch>) => void;
+    onRedoAction: (patch: SpreadsheetPatch<Patch>) => void;
+    applyPatch: (patch: SpreadsheetPatch<Patch>) => void;
+};
+//# sourceMappingURL=use-undo-redo-actions.d.ts.map

package/dist/cjs/hooks/use-undo-redo-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-undo-redo-actions.d.ts","sourceRoot":"","sources":["../../../hooks/use-undo-redo-actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,QAAQ,EACR,KAAK,EACN,MAAM,2BAA2B,CAAC;AAQnC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAKnC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAe,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAErE,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAClE,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,cAAc,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC7D,cAAc,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC7D,cAAc,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC7D,mBAAmB,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC;IACvE,eAAe,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC;IAC/D,eAAe,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC;IAC/D,iBAAiB,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IACnE,qBAAqB,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,uBAAuB,CAAC,CAAC;IAC3E,uBAAuB,CAAC,EAAE,mBAAmB,CAC3C,CAAC,EACD,CAAC,CACF,CAAC,yBAAyB,CAAC,CAAC;IAC7B,0BAA0B,CAAC,EAAE,mBAAmB,CAC9C,CAAC,EACD,CAAC,CACF,CAAC,4BAA4B,CAAC,CAAC;IAChC,uBAAuB,CAAC,EAAE,mBAAmB,CAC3C,CAAC,EACD,CAAC,CACF,CAAC,yBAAyB,CAAC,CAAC;IAC7B,aAAa,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC;IAC3D,kBAAkB,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC7D,kBAAkB,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC7D,mBAAmB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC;IACtE,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,kBAAkB,CAAC,SAAS,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC1D;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,sZAsBrE,uBAAuB,CAAC,CAAC,EAAE,CAAC,CAAC;0BAqQpB,gBAAgB,CAAC,KAAK,CAAC;0BAQvB,gBAAgB,CAAC,KAAK,CAAC;wBAQvB,gBAAgB,CAAC,KAAK,CAAC;CAWlC,CAAC"}

package/dist/cjs/hooks/use-undo-redo-actions.js

@@ -0,0 +1,209 @@
+import { __assign, __read, __values } from "tslib";
+import { DEFAULT_ARRAY, isSelectionACell, useFocusEmbedOrChart, useSpreadsheet, } from "@rowsncolumns/spreadsheet";
+import { isNil } from "@rowsncolumns/utils";
+import { useCallback } from "react";
+import { applyPatches } from "../api/patches";
+export var useUndoRedoActions = function (_a) {
+    var sheetId = _a.sheetId, onChangeSheets = _a.onChangeSheets, onChangeSheetData = _a.onChangeSheetData, onChangeActiveCell = _a.onChangeActiveCell, onChangeSelections = _a.onChangeSelections, onChangeActiveSheet = _a.onChangeActiveSheet, onChangePivotTables = _a.onChangePivotTables, onChangeTables = _a.onChangeTables, onChangeNamedRanges = _a.onChangeNamedRanges, onChangeEmbeds = _a.onChangeEmbeds, onChangeCharts = _a.onChangeCharts, onChangeTheme = _a.onChangeTheme, onChangeCellXfs = _a.onChangeCellXfs, onChangeConditionalFormats = _a.onChangeConditionalFormats, onChangeDataValidations = _a.onChangeDataValidations, onChangeProtectedRanges = _a.onChangeProtectedRanges, onChangeSlicers = _a.onChangeSlicers, onChangeCitations = _a.onChangeCitations, onChangeSharedStrings = _a.onChangeSharedStrings, enqueueCalculation = _a.enqueueCalculation, clearRangeCache = _a.clearRangeCache;
+    var _b = useSpreadsheet(), scrollToCell = _b.scrollToCell, updateSelectionStartEndReference = _b.updateSelectionStartEndReference;
+    var focusEmbedOrChart = useFocusEmbedOrChart();
+    // Undo/redo side-effects
+    var executeSideEffects = useCallback(function (patch, action) {
+        var e_1, _a;
+        var shouldRecalc = patch.disableRecalc ? false : true;
+        // The forward path invalidates the calculator's range cache via
+        // `enqueueStructureChange` whenever a structural op shifts cells.
+        // Undo/redo replays the patches directly, bypassing that hook, so
+        // any cached range overlapping a moved region would stay stale.
+        // Clearing wholesale is cheaper than reconstructing the inverse
+        // invalidation range per-op and the cache repopulates lazily.
+        clearRangeCache === null || clearRangeCache === void 0 ? void 0 : clearRangeCache();
+        // Grid data
+        if (patch.sheetData) {
+            onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prev) {
+                return applyPatches(prev, patch.sheetData[action === "undo" ? "inversePatches" : "patches"]);
+            });
+        }
+        // Sheet id
+        if (patch.sheetId && patch.sheetId[action]) {
+            var sheetId_1 = patch.sheetId[action];
+            if (!isNil(sheetId_1))
+                onChangeActiveSheet === null || onChangeActiveSheet === void 0 ? void 0 : onChangeActiveSheet(sheetId_1);
+        }
+        // Update active cell
+        if (patch.activeCell && patch.activeCell) {
+            var activeCell = patch.activeCell[action];
+            // Change active cell
+            // Trigger re-render of the grid
+            onChangeActiveCell === null || onChangeActiveCell === void 0 ? void 0 : onChangeActiveCell(sheetId, __assign({}, activeCell));
+            // Update references
+            updateSelectionStartEndReference === null || updateSelectionStartEndReference === void 0 ? void 0 : updateSelectionStartEndReference(activeCell);
+            // Scroll
+            scrollToCell === null || scrollToCell === void 0 ? void 0 : scrollToCell(activeCell);
+        }
+        // Cells to recalculate
+        // Usually precedent cells
+        if (patch.recalcCells && shouldRecalc) {
+            var recalcCells = patch.recalcCells[action];
+            try {
+                for (var recalcCells_1 = __values(recalcCells), recalcCells_1_1 = recalcCells_1.next(); !recalcCells_1_1.done; recalcCells_1_1 = recalcCells_1.next()) {
+                    var _b = __read(recalcCells_1_1.value, 2), _1 = _b[0], _c = _b[1], rowIndex = _c.rowIndex, columnIndex = _c.columnIndex, sheetId_2 = _c.sheetId;
+                    enqueueCalculation({
+                        type: "add",
+                        position: {
+                            rowIndex: rowIndex,
+                            columnIndex: columnIndex,
+                            sheetId: sheetId_2,
+                        },
+                    });
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (recalcCells_1_1 && !recalcCells_1_1.done && (_a = recalcCells_1.return)) _a.call(recalcCells_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        // Update selections
+        if (patch.selections && patch.selections[action]) {
+            var selections = patch.selections[action];
+            // Change active cell
+            if (selections && !isSelectionACell(selections)) {
+                onChangeSelections === null || onChangeSelections === void 0 ? void 0 : onChangeSelections(sheetId, selections);
+            }
+            // Enque selections
+        }
+        else {
+            onChangeSelections === null || onChangeSelections === void 0 ? void 0 : onChangeSelections(sheetId, DEFAULT_ARRAY);
+        }
+        // Update sheets
+        if (patch.sheets) {
+            onChangeSheets(function (prev) {
+                return applyPatches(prev, patch.sheets[action === "undo" ? "inversePatches" : "patches"]);
+            });
+        }
+        // Update tables
+        if (patch.tables) {
+            onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prev) {
+                return applyPatches(prev, patch.tables[action === "undo" ? "inversePatches" : "patches"]);
+            });
+        }
+        // Update charts
+        if (patch.charts) {
+            onChangeCharts === null || onChangeCharts === void 0 ? void 0 : onChangeCharts(function (prev) {
+                return applyPatches(prev, patch.charts[action === "undo" ? "inversePatches" : "patches"]);
+            });
+        }
+        // Update embeds
+        if (patch.embeds) {
+            onChangeEmbeds === null || onChangeEmbeds === void 0 ? void 0 : onChangeEmbeds(function (prev) {
+                return applyPatches(prev, patch.embeds[action === "undo" ? "inversePatches" : "patches"]);
+            });
+        }
+        // Update theme
+        if (patch.theme) {
+            onChangeTheme === null || onChangeTheme === void 0 ? void 0 : onChangeTheme(function (prev) {
+                return applyPatches(prev, patch.theme[action === "undo" ? "inversePatches" : "patches"]);
+            });
+        }
+        // Update namedranges
+        if (patch.namedRanges) {
+            onChangeNamedRanges === null || onChangeNamedRanges === void 0 ? void 0 : onChangeNamedRanges(function (prev) {
+                return applyPatches(prev, patch.namedRanges[action === "undo" ? "inversePatches" : "patches"]);
+            });
+        }
+        // Update protected ranges
+        if (patch.protectedRanges) {
+            onChangeProtectedRanges === null || onChangeProtectedRanges === void 0 ? void 0 : onChangeProtectedRanges(function (prev) {
+                return applyPatches(prev, patch.protectedRanges[action === "undo" ? "inversePatches" : "patches"]);
+            });
+        }
+        // Update conditional formats
+        if (patch.conditionalFormats) {
+            onChangeConditionalFormats === null || onChangeConditionalFormats === void 0 ? void 0 : onChangeConditionalFormats(function (prev) {
+                return applyPatches(prev, patch.conditionalFormats[action === "undo" ? "inversePatches" : "patches"]);
+            });
+        }
+        // Update data validations
+        if (patch.dataValidations) {
+            onChangeDataValidations === null || onChangeDataValidations === void 0 ? void 0 : onChangeDataValidations(function (prev) {
+                return applyPatches(prev, patch.dataValidations[action === "undo" ? "inversePatches" : "patches"]);
+            });
+        }
+        // Update pivot tables
+        if (patch.pivotTables) {
+            onChangePivotTables === null || onChangePivotTables === void 0 ? void 0 : onChangePivotTables(function (prev) {
+                return applyPatches(prev, patch.pivotTables[action === "undo" ? "inversePatches" : "patches"]);
+            });
+        }
+        // Update cellXfs
+        if (patch.cellXfs) {
+            onChangeCellXfs === null || onChangeCellXfs === void 0 ? void 0 : onChangeCellXfs(function (prev) {
+                return applyPatches(prev, patch.cellXfs[action === "undo" ? "inversePatches" : "patches"]);
+            });
+        }
+        // Update slicers
+        if (patch.slicers) {
+            onChangeSlicers === null || onChangeSlicers === void 0 ? void 0 : onChangeSlicers(function (prev) {
+                return applyPatches(prev, patch.slicers[action === "undo" ? "inversePatches" : "patches"]);
+            });
+        }
+        // Update citations
+        if (patch.citations) {
+            onChangeCitations === null || onChangeCitations === void 0 ? void 0 : onChangeCitations(function (prev) {
+                return applyPatches(prev, patch.citations[action === "undo" ? "inversePatches" : "patches"]);
+            });
+        }
+        // Update shared strings
+        if (patch.sharedStrings) {
+            onChangeSharedStrings === null || onChangeSharedStrings === void 0 ? void 0 : onChangeSharedStrings(function (prev) {
+                return applyPatches(prev, patch.sharedStrings[action === "undo" ? "inversePatches" : "patches"]);
+            });
+        }
+        if (patch.selectedEmbedOrChart && patch.selectedEmbedOrChart[action]) {
+            focusEmbedOrChart(patch.selectedEmbedOrChart[action]);
+        }
+    }, [
+        sheetId,
+        onChangeActiveCell,
+        onChangeSelections,
+        onChangeSheetData,
+        enqueueCalculation,
+        onChangeSheets,
+        onChangeActiveSheet,
+        onChangeTables,
+        onChangeNamedRanges,
+        onChangeEmbeds,
+        onChangeCharts,
+        onChangeTheme,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        onChangeProtectedRanges,
+        onChangeCellXfs,
+        onChangeSlicers,
+        onChangeSharedStrings,
+        scrollToCell,
+        updateSelectionStartEndReference,
+        focusEmbedOrChart,
+        onChangePivotTables,
+        clearRangeCache,
+    ]);
+    var onUndoAction = useCallback(function (patch) {
+        executeSideEffects(patch, "undo");
+    }, [executeSideEffects]);
+    // Redo actions
+    var onRedoAction = useCallback(function (patch) {
+        executeSideEffects(patch, "redo");
+    }, [executeSideEffects]);
+    // Apply patches
+    var applyPatch = useCallback(function (patch) {
+        onRedoAction(patch);
+    }, [onRedoAction]);
+    return {
+        onUndoAction: onUndoAction,
+        onRedoAction: onRedoAction,
+        applyPatch: applyPatch,
+    };
+};

package/dist/cjs/hooks/use-undo-redo.d.ts

@@ -0,0 +1,69 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { EmbeddedObject, SelectionAttributes } from "@rowsncolumns/spreadsheet";
+import type { Patch } from "immer";
+import type { RecalcCellCoordinate } from "../types";
+export type PatchType<T extends Patch = Patch> = {
+    patches: T[];
+    inversePatches: T[];
+};
+export type HistoryType = "undo" | "redo";
+type UseUndoRedoProps<T extends Patch> = {
+    /**
+     * Enable or disable undo/redo functionality
+     */
+    isEnabled?: boolean;
+    onUndoAction?(patches: SpreadsheetPatch<T>): void;
+    onRedoAction?(patches: SpreadsheetPatch<T>): void;
+    onChangeHistory?(historyBatch: [
+        patch: SpreadsheetPatch<T>,
+        type?: HistoryType | undefined
+    ][]): void;
+};
+export type SpreadsheetPatch<T extends Patch = Patch> = {
+    sheetData?: PatchType<T>;
+    activeCell?: {
+        redo: CellInterface;
+        undo: CellInterface;
+    };
+    selections?: {
+        redo: SelectionArea<SelectionAttributes>[] | undefined;
+        undo: SelectionArea<SelectionAttributes>[] | undefined;
+    };
+    sheets?: PatchType<T>;
+    protectedRanges?: PatchType<T>;
+    conditionalFormats?: PatchType<T>;
+    dataValidations?: PatchType<T>;
+    pivotTables?: PatchType<T>;
+    sheetId?: {
+        redo: number | undefined;
+        undo: number | undefined;
+    };
+    recalcCells?: Record<HistoryType, Map<string, RecalcCellCoordinate>>;
+    theme?: PatchType<T>;
+    tables?: PatchType<T>;
+    namedRanges?: PatchType<T>;
+    charts?: PatchType<T>;
+    embeds?: PatchType<T>;
+    selectedEmbedOrChart?: {
+        undo: EmbeddedObject["embedId"] | undefined;
+        redo: EmbeddedObject["embedId"] | undefined;
+    };
+    cellXfs?: PatchType<T>;
+    sharedStrings?: PatchType<T>;
+    bandedRanges?: PatchType<T>;
+    disableRecalc?: boolean;
+    isFullRecalc?: boolean;
+    slicers?: PatchType<T>;
+    citations?: PatchType<T>;
+};
+export declare const useUndoRedo: <T extends Patch = Patch>({ isEnabled, onUndoAction, onRedoAction, onChangeHistory, }: UseUndoRedoProps<T>) => {
+    createHistory: (callback?: () => void) => (patches: SpreadsheetPatch<T>) => void;
+    createHistoryWithoutPointer: () => (patches: SpreadsheetPatch<T>) => void;
+    onUndo: () => void;
+    onRedo: () => void;
+    onClearHistory: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+};
+export {};
+//# sourceMappingURL=use-undo-redo.d.ts.map

package/dist/cjs/hooks/use-undo-redo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-undo-redo.d.ts","sourceRoot":"","sources":["../../../hooks/use-undo-redo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC/E,OAAO,KAAK,EACV,cAAc,EACd,mBAAmB,EACpB,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAGnC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAErD,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,IAAI;IAC/C,OAAO,EAAE,CAAC,EAAE,CAAC;IACb,cAAc,EAAE,CAAC,EAAE,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;AAE1C,KAAK,gBAAgB,CAAC,CAAC,SAAS,KAAK,IAAI;IACvC;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAClD,YAAY,CAAC,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAClD,eAAe,CAAC,CACd,YAAY,EAAE;QACZ,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC;QAC1B,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;KAC/B,EAAE,GACF,IAAI,CAAC;CACT,CAAC;AAEF,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,IAAI;IACtD,SAAS,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACzB,UAAU,CAAC,EAAE;QAAE,IAAI,EAAE,aAAa,CAAC;QAAC,IAAI,EAAE,aAAa,CAAA;KAAE,CAAC;IAC1D,UAAU,CAAC,EAAE;QACX,IAAI,EAAE,aAAa,CAAC,mBAAmB,CAAC,EAAE,GAAG,SAAS,CAAC;QACvD,IAAI,EAAE,aAAa,CAAC,mBAAmB,CAAC,EAAE,GAAG,SAAS,CAAC;KACxD,CAAC;IACF,MAAM,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACtB,eAAe,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IAC/B,kBAAkB,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IAClC,eAAe,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IAC/B,WAAW,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IAC3B,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IACjE,WAAW,CAAC,EAAE,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC;IACrE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACrB,MAAM,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACtB,WAAW,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IAC3B,MAAM,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACtB,MAAM,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACtB,oBAAoB,CAAC,EAAE;QACrB,IAAI,EAAE,cAAc,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;QAC5C,IAAI,EAAE,cAAc,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;KAC7C,CAAC;IACF,OAAO,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACvB,aAAa,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IAC7B,YAAY,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IAC5B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACvB,SAAS,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;CAC1B,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,KAAK,GAAG,KAAK,EAAE,6DAKlD,gBAAgB,CAAC,CAAC,CAAC;+BAqEN,MAAM,IAAI,eAKH,gBAAgB,CAAC,CAAC,CAAC;iDAYrB,gBAAgB,CAAC,CAAC,CAAC;;;;;;CA6CvC,CAAC"}

package/dist/cjs/hooks/use-undo-redo.js

@@ -0,0 +1,124 @@
+import { __assign, __values } from "tslib";
+import { useCallbackRef } from "@rowsncolumns/spreadsheet";
+import { debug, isNil } from "@rowsncolumns/utils";
+import { useCallback, useRef } from "react";
+export var useUndoRedo = function (_a) {
+    var _b = _a.isEnabled, isEnabled = _b === void 0 ? true : _b, onUndoAction = _a.onUndoAction, onRedoAction = _a.onRedoAction, onChangeHistory = _a.onChangeHistory;
+    var undoStack = useRef([]);
+    var undoStackPointer = useRef(-1);
+    var onChangeHistoryStable = useCallbackRef(onChangeHistory);
+    var pointerSetRef = useRef(new Set());
+    var historyQueueRef = useRef(undefined);
+    var saveHistoryCallbackRef = useRef(undefined);
+    var getQueue = useCallback(function () {
+        if (!historyQueueRef.current) {
+            historyQueueRef.current = [];
+        }
+        return historyQueueRef.current;
+    }, []);
+    // Trigger history change
+    var triggerHistoryChange = useCallback(function (patch, type) {
+        if (getQueue().push([patch, type]) === 1) {
+            requestAnimationFrame(function () {
+                var _a;
+                onChangeHistoryStable === null || onChangeHistoryStable === void 0 ? void 0 : onChangeHistoryStable(getQueue());
+                getQueue().length = 0;
+                /* Callback ref */
+                (_a = saveHistoryCallbackRef.current) === null || _a === void 0 ? void 0 : _a.call(saveHistoryCallbackRef);
+                saveHistoryCallbackRef.current = undefined;
+            });
+        }
+    }, [getQueue, onChangeHistoryStable]);
+    // Save to point
+    var onSaveHistoryToPointer = useCallback(function (patches, pointer) {
+        undoStack.current[pointer] = __assign(__assign({}, undoStack.current[pointer]), patches);
+        // There can be multiple state updates in a single
+        // pointer, So use a queue
+        // Eg: When a cell is added to end of table
+        // 1. History 1 => Add a cell
+        // 2. History 2 => Expand table, Recompute calculated column
+        if (pointerSetRef.current.add(pointer).size === 1) {
+            requestAnimationFrame(function () {
+                var e_1, _a;
+                try {
+                    for (var _b = __values(pointerSetRef.current), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var p = _c.value;
+                        triggerHistoryChange(undoStack.current[p]);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                pointerSetRef.current.clear();
+            });
+        }
+    }, [triggerHistoryChange]);
+    // Create next history pointer
+    var createHistoryPointer = useCallback(function () {
+        if (!isEnabled) {
+            debug("Undo/Redo functionality has been disabled");
+            return;
+        }
+        var pointer = ++undoStackPointer.current;
+        undoStack.current.length = pointer;
+        return pointer;
+    }, [isEnabled]);
+    // Create current history
+    var createHistory = useCallback(function (callback) {
+        var pointer = createHistoryPointer();
+        /* Set callback ref */
+        saveHistoryCallbackRef.current = callback;
+        return function (patches) {
+            if (isNil(pointer)) {
+                return;
+            }
+            return onSaveHistoryToPointer(patches, pointer);
+        };
+    }, [createHistoryPointer, onSaveHistoryToPointer]);
+    // Save history without
+    var createHistoryWithoutPointer = useCallback(function () {
+        return function (patches) {
+            requestAnimationFrame(function () { return triggerHistoryChange(patches); });
+        };
+    }, [triggerHistoryChange]);
+    // Undo
+    var onUndo = useCallback(function () {
+        if (undoStackPointer.current < 0) {
+            return;
+        }
+        var patches = undoStack.current[undoStackPointer.current];
+        undoStackPointer.current--;
+        onUndoAction === null || onUndoAction === void 0 ? void 0 : onUndoAction(patches);
+        // Trigger history change
+        triggerHistoryChange(patches, "undo");
+    }, [onUndoAction, triggerHistoryChange]);
+    // Redo
+    var onRedo = useCallback(function () {
+        if (undoStackPointer.current === undoStack.current.length - 1) {
+            return;
+        }
+        undoStackPointer.current++;
+        var patches = undoStack.current[undoStackPointer.current];
+        onRedoAction === null || onRedoAction === void 0 ? void 0 : onRedoAction(patches);
+        // Trigger history change
+        triggerHistoryChange(patches, "redo");
+    }, [onRedoAction, triggerHistoryChange]);
+    // Clear undo history
+    var onClearHistory = useCallback(function () {
+        undoStack.current = [];
+        undoStackPointer.current = -1;
+    }, []);
+    return {
+        createHistory: createHistory,
+        createHistoryWithoutPointer: createHistoryWithoutPointer,
+        onUndo: onUndo,
+        onRedo: onRedo,
+        onClearHistory: onClearHistory,
+        canUndo: !(undoStackPointer.current < 0),
+        canRedo: !(undoStackPointer.current === undoStack.current.length - 1),
+    };
+};

package/dist/cjs/hooks/utils/frozen-sort.d.ts

@@ -0,0 +1,9 @@
+import type { CellData } from "@rowsncolumns/common-types";
+import type { SheetCell } from "../../sheet-cell";
+/**
+ * Sorts rows while keeping frozen rows at the top segment. Frozen rows are
+ * sorted independently from the rest of the rows to mimic Excel's behaviour
+ * where panes above the frozen line get reordered within their own segment.
+ */
+export declare const reorderRowsByFrozenState: <T extends CellData>(rowValues: SheetCell<T>[][], rowIndexMap: number[], frozenRowCount: number, comparator: (a: SheetCell<T>[], b: SheetCell<T>[]) => number) => void;
+//# sourceMappingURL=frozen-sort.d.ts.map

package/dist/cjs/hooks/utils/frozen-sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frozen-sort.d.ts","sourceRoot":"","sources":["../../../../hooks/utils/frozen-sort.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAE3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAOlD;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,QAAQ,EACzD,WAAW,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,EAC3B,aAAa,MAAM,EAAE,EACrB,gBAAgB,MAAM,EACtB,YAAY,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,MAAM,SA8B7D,CAAC"}