@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/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/esm/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/esm/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 const useSharedStringRegistry = (sharedStrings, onChangeSharedStrings) => {
+    const ssRegistryRef = useRef(null);
+    const getRegistry = useCallback(() => {
+        if (!ssRegistryRef.current) {
+            ssRegistryRef.current = new SharedStringRegistry(sharedStrings, onChangeSharedStrings);
+        }
+        return ssRegistryRef.current;
+    }, [sharedStrings, onChangeSharedStrings]);
+    useIsomorphicLayoutEffect(() => {
+        getRegistry().setSharedStrings(sharedStrings);
+    }, [sharedStrings, getRegistry]);
+    return useMemo(() => getRegistry(), [getRegistry]);
+};

package/dist/esm/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/esm/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/esm/hooks/use-structured-reference.js

@@ -0,0 +1,129 @@
+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 const useStructuredReference = ({ tables, sheetId, getSheetName, }) => {
+    return useCallback((tableName, columnNames, thisRow, specialItem, sheetName, cell) => {
+        // If there is no tablename, we need to find table based
+        // on cell
+        const table = tables?.find((table) => {
+            if (tableName) {
+                return table.title === tableName;
+            }
+            return (isCellWithinBounds({ rowIndex: cell.row, columnIndex: cell.col }, table.range) && table.sheetId === sheetId);
+        });
+        // Current row
+        const { row: rowIndex } = cell;
+        if (!table) {
+            throw new FormulaError("#NAME!", "Table could not be found");
+        }
+        // Special this row item
+        if (specialItem === "#This Row") {
+            thisRow = true;
+        }
+        const { range } = table;
+        const headerRow = table.headerRow ?? true;
+        const totalRow = table.totalRow ?? false;
+        const headerRowOffset = headerRow ? 1 : 0;
+        const totalRowOffset = totalRow ? 1 : 0;
+        const [from, to] = columnNames ?? [];
+        const startColIndex = getColumnIndexFromColumnName(table, from);
+        const endColIndex = getColumnIndexFromColumnName(table, to);
+        // Exit early, if column could not be found
+        if (!isNil(to) && isNil(endColIndex)) {
+            throw new FormulaError("#VALUE!", `Column not found ${to}`);
+        }
+        if (!isNil(from) && isNil(startColIndex)) {
+            throw new FormulaError("#VALUE!", `Column not found ${from}`);
+        }
+        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 {
+                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 ${tableName}`);
+        }
+        // If column is not found, lets not select anything
+        if (from && isNil(startColIndex)) {
+            throw new FormulaError("#VALUE!", `Column: ${from} could not be found`);
+        }
+        if (to && isNil(endColIndex)) {
+            throw new FormulaError("#VALUE!", `Column: ${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
+        const fromRow = thisRow ? rowIndex : range.startRowIndex;
+        const 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/esm/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/esm/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/esm/hooks/use-undo-redo-actions.js

@@ -0,0 +1,166 @@
+import { DEFAULT_ARRAY, isSelectionACell, useFocusEmbedOrChart, useSpreadsheet, } from "@rowsncolumns/spreadsheet";
+import { isNil } from "@rowsncolumns/utils";
+import { useCallback } from "react";
+import { applyPatches } from "../api/patches";
+export const useUndoRedoActions = ({ sheetId, onChangeSheets, onChangeSheetData, onChangeActiveCell, onChangeSelections, onChangeActiveSheet, onChangePivotTables, onChangeTables, onChangeNamedRanges, onChangeEmbeds, onChangeCharts, onChangeTheme, onChangeCellXfs, onChangeConditionalFormats, onChangeDataValidations, onChangeProtectedRanges, onChangeSlicers, onChangeCitations, onChangeSharedStrings, enqueueCalculation, clearRangeCache, }) => {
+    const { scrollToCell, updateSelectionStartEndReference } = useSpreadsheet();
+    const focusEmbedOrChart = useFocusEmbedOrChart();
+    // Undo/redo side-effects
+    const executeSideEffects = useCallback((patch, action) => {
+        const 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?.();
+        // Grid data
+        if (patch.sheetData) {
+            onChangeSheetData?.((prev) => applyPatches(prev, patch.sheetData[action === "undo" ? "inversePatches" : "patches"]));
+        }
+        // Sheet id
+        if (patch.sheetId && patch.sheetId[action]) {
+            const sheetId = patch.sheetId[action];
+            if (!isNil(sheetId))
+                onChangeActiveSheet?.(sheetId);
+        }
+        // Update active cell
+        if (patch.activeCell && patch.activeCell) {
+            const activeCell = patch.activeCell[action];
+            // Change active cell
+            // Trigger re-render of the grid
+            onChangeActiveCell?.(sheetId, { ...activeCell });
+            // Update references
+            updateSelectionStartEndReference?.(activeCell);
+            // Scroll
+            scrollToCell?.(activeCell);
+        }
+        // Cells to recalculate
+        // Usually precedent cells
+        if (patch.recalcCells && shouldRecalc) {
+            const recalcCells = patch.recalcCells[action];
+            for (const [_, { rowIndex, columnIndex, sheetId }] of recalcCells) {
+                enqueueCalculation({
+                    type: "add",
+                    position: {
+                        rowIndex,
+                        columnIndex,
+                        sheetId,
+                    },
+                });
+            }
+        }
+        // Update selections
+        if (patch.selections && patch.selections[action]) {
+            const selections = patch.selections[action];
+            // Change active cell
+            if (selections && !isSelectionACell(selections)) {
+                onChangeSelections?.(sheetId, selections);
+            }
+            // Enque selections
+        }
+        else {
+            onChangeSelections?.(sheetId, DEFAULT_ARRAY);
+        }
+        // Update sheets
+        if (patch.sheets) {
+            onChangeSheets((prev) => applyPatches(prev, patch.sheets[action === "undo" ? "inversePatches" : "patches"]));
+        }
+        // Update tables
+        if (patch.tables) {
+            onChangeTables?.((prev) => applyPatches(prev, patch.tables[action === "undo" ? "inversePatches" : "patches"]));
+        }
+        // Update charts
+        if (patch.charts) {
+            onChangeCharts?.((prev) => applyPatches(prev, patch.charts[action === "undo" ? "inversePatches" : "patches"]));
+        }
+        // Update embeds
+        if (patch.embeds) {
+            onChangeEmbeds?.((prev) => applyPatches(prev, patch.embeds[action === "undo" ? "inversePatches" : "patches"]));
+        }
+        // Update theme
+        if (patch.theme) {
+            onChangeTheme?.((prev) => applyPatches(prev, patch.theme[action === "undo" ? "inversePatches" : "patches"]));
+        }
+        // Update namedranges
+        if (patch.namedRanges) {
+            onChangeNamedRanges?.((prev) => applyPatches(prev, patch.namedRanges[action === "undo" ? "inversePatches" : "patches"]));
+        }
+        // Update protected ranges
+        if (patch.protectedRanges) {
+            onChangeProtectedRanges?.((prev) => applyPatches(prev, patch.protectedRanges[action === "undo" ? "inversePatches" : "patches"]));
+        }
+        // Update conditional formats
+        if (patch.conditionalFormats) {
+            onChangeConditionalFormats?.((prev) => applyPatches(prev, patch.conditionalFormats[action === "undo" ? "inversePatches" : "patches"]));
+        }
+        // Update data validations
+        if (patch.dataValidations) {
+            onChangeDataValidations?.((prev) => applyPatches(prev, patch.dataValidations[action === "undo" ? "inversePatches" : "patches"]));
+        }
+        // Update pivot tables
+        if (patch.pivotTables) {
+            onChangePivotTables?.((prev) => applyPatches(prev, patch.pivotTables[action === "undo" ? "inversePatches" : "patches"]));
+        }
+        // Update cellXfs
+        if (patch.cellXfs) {
+            onChangeCellXfs?.((prev) => applyPatches(prev, patch.cellXfs[action === "undo" ? "inversePatches" : "patches"]));
+        }
+        // Update slicers
+        if (patch.slicers) {
+            onChangeSlicers?.((prev) => applyPatches(prev, patch.slicers[action === "undo" ? "inversePatches" : "patches"]));
+        }
+        // Update citations
+        if (patch.citations) {
+            onChangeCitations?.((prev) => applyPatches(prev, patch.citations[action === "undo" ? "inversePatches" : "patches"]));
+        }
+        // Update shared strings
+        if (patch.sharedStrings) {
+            onChangeSharedStrings?.((prev) => 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,
+    ]);
+    const onUndoAction = useCallback((patch) => {
+        executeSideEffects(patch, "undo");
+    }, [executeSideEffects]);
+    // Redo actions
+    const onRedoAction = useCallback((patch) => {
+        executeSideEffects(patch, "redo");
+    }, [executeSideEffects]);
+    // Apply patches
+    const applyPatch = useCallback((patch) => {
+        onRedoAction(patch);
+    }, [onRedoAction]);
+    return {
+        onUndoAction,
+        onRedoAction,
+        applyPatch,
+    };
+};

package/dist/esm/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/esm/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":"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"}

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

@@ -0,0 +1,113 @@
+import { useCallbackRef } from "@rowsncolumns/spreadsheet";
+import { debug, isNil } from "@rowsncolumns/utils";
+import { useCallback, useRef } from "react";
+export const useUndoRedo = ({ isEnabled = true, onUndoAction, onRedoAction, onChangeHistory, }) => {
+    const undoStack = useRef([]);
+    const undoStackPointer = useRef(-1);
+    const onChangeHistoryStable = useCallbackRef(onChangeHistory);
+    const pointerSetRef = useRef(new Set());
+    const historyQueueRef = useRef(undefined);
+    const saveHistoryCallbackRef = useRef(undefined);
+    const getQueue = useCallback(() => {
+        if (!historyQueueRef.current) {
+            historyQueueRef.current = [];
+        }
+        return historyQueueRef.current;
+    }, []);
+    // Trigger history change
+    const triggerHistoryChange = useCallback((patch, type) => {
+        if (getQueue().push([patch, type]) === 1) {
+            requestAnimationFrame(() => {
+                onChangeHistoryStable?.(getQueue());
+                getQueue().length = 0;
+                /* Callback ref */
+                saveHistoryCallbackRef.current?.();
+                saveHistoryCallbackRef.current = undefined;
+            });
+        }
+    }, [getQueue, onChangeHistoryStable]);
+    // Save to point
+    const onSaveHistoryToPointer = useCallback((patches, pointer) => {
+        undoStack.current[pointer] = {
+            ...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(() => {
+                for (const p of pointerSetRef.current) {
+                    triggerHistoryChange(undoStack.current[p]);
+                }
+                pointerSetRef.current.clear();
+            });
+        }
+    }, [triggerHistoryChange]);
+    // Create next history pointer
+    const createHistoryPointer = useCallback(() => {
+        if (!isEnabled) {
+            debug("Undo/Redo functionality has been disabled");
+            return;
+        }
+        const pointer = ++undoStackPointer.current;
+        undoStack.current.length = pointer;
+        return pointer;
+    }, [isEnabled]);
+    // Create current history
+    const createHistory = useCallback((callback) => {
+        const pointer = createHistoryPointer();
+        /* Set callback ref */
+        saveHistoryCallbackRef.current = callback;
+        return (patches) => {
+            if (isNil(pointer)) {
+                return;
+            }
+            return onSaveHistoryToPointer(patches, pointer);
+        };
+    }, [createHistoryPointer, onSaveHistoryToPointer]);
+    // Save history without
+    const createHistoryWithoutPointer = useCallback(() => {
+        return (patches) => {
+            requestAnimationFrame(() => triggerHistoryChange(patches));
+        };
+    }, [triggerHistoryChange]);
+    // Undo
+    const onUndo = useCallback(() => {
+        if (undoStackPointer.current < 0) {
+            return;
+        }
+        const patches = undoStack.current[undoStackPointer.current];
+        undoStackPointer.current--;
+        onUndoAction?.(patches);
+        // Trigger history change
+        triggerHistoryChange(patches, "undo");
+    }, [onUndoAction, triggerHistoryChange]);
+    // Redo
+    const onRedo = useCallback(() => {
+        if (undoStackPointer.current === undoStack.current.length - 1) {
+            return;
+        }
+        undoStackPointer.current++;
+        const patches = undoStack.current[undoStackPointer.current];
+        onRedoAction?.(patches);
+        // Trigger history change
+        triggerHistoryChange(patches, "redo");
+    }, [onRedoAction, triggerHistoryChange]);
+    // Clear undo history
+    const onClearHistory = useCallback(() => {
+        undoStack.current = [];
+        undoStackPointer.current = -1;
+    }, []);
+    return {
+        createHistory,
+        createHistoryWithoutPointer,
+        onUndo,
+        onRedo,
+        onClearHistory,
+        canUndo: !(undoStackPointer.current < 0),
+        canRedo: !(undoStackPointer.current === undoStack.current.length - 1),
+    };
+};

package/dist/esm/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/esm/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"}

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

@@ -0,0 +1,25 @@
+/**
+ * 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 const reorderRowsByFrozenState = (rowValues, rowIndexMap, frozenRowCount, comparator) => {
+    if (!frozenRowCount) {
+        rowValues.sort(comparator);
+        return;
+    }
+    const entries = rowValues.map((values, idx) => ({
+        values,
+        rowIndex: rowIndexMap[idx] ?? Number.MAX_SAFE_INTEGER,
+    }));
+    const sortEntries = (items) => items
+        .sort((left, right) => comparator(left.values, right.values))
+        .map((entry) => entry.values);
+    const frozenEntries = entries.filter((entry) => entry.rowIndex <= frozenRowCount);
+    const nonFrozenEntries = entries.filter((entry) => entry.rowIndex > frozenRowCount);
+    const sortedRows = [
+        ...sortEntries(frozenEntries),
+        ...sortEntries(nonFrozenEntries),
+    ];
+    rowValues.splice(0, rowValues.length, ...sortedRows);
+};

package/dist/esm/hooks/utils/sort-rows.d.ts

@@ -0,0 +1,32 @@
+import type { SortOrder } from "@rowsncolumns/spreadsheet";
+export type RowSortEntry = {
+    rowIndex: number;
+    sortValues: unknown[];
+};
+/**
+ * Per-dimension sort specification consumed by the row sorter.
+ * `sortBy` defaults to "value" (numeric/text/boolean comparison via the
+ * collator). Color and icon modes surface the matching cells to the top
+ * (ASCENDING) or bottom (DESCENDING).
+ */
+export type DimensionSortSpec = {
+    sortOrder: SortOrder;
+    sortBy?: "value" | "cellColor" | "fontColor" | "icon" | null;
+    /** When sortBy is cellColor/fontColor, the color to surface (hex). */
+    sortColor?: string | null;
+    /** When sortBy is icon, the (iconSet, iconId) to surface. */
+    sortIcon?: {
+        iconSet: string;
+        iconId: number;
+    } | null;
+    /** Custom sort order. Strings define the position; case-insensitive. */
+    customList?: string[] | null;
+};
+export declare const sortRowEntriesByFrozenState: (rowEntries: RowSortEntry[], frozenRowCount: number, 
+/**
+ * Sort specifications per dimension. Accepts either the legacy
+ * `SortOrder[]` array (back-compat) or the richer `DimensionSortSpec[]`
+ * with `sortBy`/`sortColor`/`sortIcon`/`customList`.
+ */
+sortSpecs: SortOrder[] | DimensionSortSpec[]) => RowSortEntry[];
+//# sourceMappingURL=sort-rows.d.ts.map

package/dist/esm/hooks/utils/sort-rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-rows.d.ts","sourceRoot":"","sources":["../../../../hooks/utils/sort-rows.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAI3D,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,OAAO,EAAE,CAAC;CACvB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,SAAS,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,GAAG,WAAW,GAAG,WAAW,GAAG,MAAM,GAAG,IAAI,CAAC;IAC7D,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,6DAA6D;IAC7D,QAAQ,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACtD,wEAAwE;IACxE,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;CAC9B,CAAC;AA8HF,eAAO,MAAM,2BAA2B,GACtC,YAAY,YAAY,EAAE,EAC1B,gBAAgB,MAAM;AACtB;;;;GAIG;AACH,WAAW,SAAS,EAAE,GAAG,iBAAiB,EAAE,mBAuB7C,CAAC"}