@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/hooks/use-on-merge-unmerge-cells.js

@@ -0,0 +1,310 @@
+import { areaIntersects, cellIdentifier, Direction, isEqualCells, selectionFromActiveCell, } from "@rowsncolumns/grid";
+import { error, iterateCellsInRange } from "@rowsncolumns/utils";
+import { current, produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+import { useShowError } from "../atoms/error-state.atom";
+import { SHEET_PROTECTION_ERROR_TITLE, useCanEditCellRange, useCanPerformSheetAction, } from "./use-can-edit-cellrange";
+export const useOnMergeUnMergeCells = ({ locale, merges, cellXfsRegistry, sharedStringRegistry, createHistory, onChangeSheetData, onChangeSheets, onChangeSelections, enqueueCalculation, onCommand, }) => {
+    const canEditCellRange = useCanEditCellRange();
+    const canPerformSheetAction = useCanPerformSheetAction();
+    const showError = useShowError();
+    /**
+     * Merge cells
+     */
+    const onMergeCells = useCallback((sheetId, activeCell, selections, direction) => {
+        if (!selections.length) {
+            error("Merge Cells: Could not merge cells without selections");
+            return;
+        }
+        if (!canPerformSheetAction(sheetId, "mergeCells")) {
+            showError({
+                title: SHEET_PROTECTION_ERROR_TITLE,
+                message: "You can't merge or unmerge cells on a protected sheet.",
+            });
+            return;
+        }
+        if (!canEditCellRange(sheetId, activeCell)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        const { range } = selections[selections.length - 1];
+        // Calculate new merges
+        const newMerges = [];
+        if (direction === Direction.Right) {
+            for (let rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                newMerges.push({
+                    ...range,
+                    startRowIndex: rowIndex,
+                    endRowIndex: rowIndex,
+                });
+            }
+        }
+        else if (direction === Direction.Down) {
+            for (let columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+                newMerges.push({
+                    ...range,
+                    startColumnIndex: columnIndex,
+                    endColumnIndex: columnIndex,
+                });
+            }
+        }
+        else {
+            newMerges.push(range);
+        }
+        const saveHistory = createHistory();
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        // Update references
+        onChangeSheets((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (sheet) {
+                    if (!sheet?.merges) {
+                        sheet.merges = [];
+                    }
+                    // Remove existing merges that intersect with new merges
+                    if (sheet.merges.length > 0) {
+                        sheet.merges = sheet.merges.filter((existingMerge) => !newMerges.some((newMerge) => areaIntersects(existingMerge, newMerge)));
+                    }
+                    sheet.merges.push(...newMerges);
+                }
+            });
+            // Save history
+            saveHistory({
+                sheets: { patches, inversePatches },
+                selections: { undo: selections, redo: [] },
+                activeCell: { undo: activeCell, redo: activeCell },
+            });
+            return nextState;
+        });
+        // Update sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                // First, check if we need to move content to master cells
+                // If master cell is empty, find first cell with content and copy it
+                const checkCell = new SheetCell();
+                for (const mergeRange of newMerges) {
+                    const masterCell = {
+                        rowIndex: mergeRange.startRowIndex,
+                        columnIndex: mergeRange.startColumnIndex,
+                    };
+                    // Check if master cell has content
+                    const masterCellData = draft[sheetId]?.[masterCell.rowIndex]?.values?.[masterCell.columnIndex];
+                    // Use current() to get plain data from Immer draft
+                    const plainMasterCellData = masterCellData
+                        ? current(masterCellData)
+                        : masterCellData;
+                    checkCell.assign(sheetId, masterCell, plainMasterCellData, {
+                        locale,
+                        cellXfsRegistry,
+                        sharedStringRegistry,
+                    });
+                    const masterHasContent = checkCell.formattedValue !== undefined &&
+                        checkCell.formattedValue !== null &&
+                        checkCell.formattedValue !== "";
+                    // If master cell is empty, find first cell with content and copy it
+                    if (!masterHasContent) {
+                        for (const [rowIndex, columnIndex] of iterateCellsInRange(mergeRange)) {
+                            // Skip the master cell itself
+                            if (rowIndex === masterCell.rowIndex &&
+                                columnIndex === masterCell.columnIndex) {
+                                continue;
+                            }
+                            const cellData = draft[sheetId]?.[rowIndex]?.values?.[columnIndex];
+                            // Use current() to get plain data from Immer draft
+                            const plainCellData = cellData ? current(cellData) : cellData;
+                            // Check if cell has content
+                            checkCell.assign(sheetId, { rowIndex, columnIndex }, plainCellData, { locale, cellXfsRegistry, sharedStringRegistry });
+                            const hasContent = checkCell.formattedValue !== undefined &&
+                                checkCell.formattedValue !== null &&
+                                checkCell.formattedValue !== "";
+                            if (hasContent) {
+                                // Found a cell with content - copy it to master cell
+                                const masterSheet = createSheetDraft(draft, sheetId, masterCell.rowIndex);
+                                const cellDataToCopy = checkCell.getCellData();
+                                // Copy to master cell
+                                masterSheet[masterCell.rowIndex].values[masterCell.columnIndex] = cellDataToCopy;
+                                // Break after finding first cell with content
+                                break;
+                            }
+                        }
+                    }
+                }
+                // Keep track of master cells
+                // Merging cells only keeps the upper-left value and discards other values.
+                const masterCells = new Set();
+                if (direction === Direction.Right) {
+                    for (let rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                        masterCells.add(cellIdentifier(rowIndex, range.startColumnIndex));
+                    }
+                }
+                else if (direction === Direction.Down) {
+                    for (let columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+                        masterCells.add(cellIdentifier(range.startRowIndex, columnIndex));
+                    }
+                }
+                else {
+                    masterCells.add(cellIdentifier(range.startRowIndex, range.startColumnIndex));
+                }
+                // Create a cell
+                const sheetCell = new SheetCell();
+                for (const [rowIndex, columnIndex] of iterateCellsInRange(range)) {
+                    const cellId = cellIdentifier(rowIndex, columnIndex);
+                    if (masterCells.has(cellId)) {
+                        continue;
+                    }
+                    const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    sheetCell.assign(sheetId, { rowIndex, columnIndex }, draft[sheetId][rowIndex]?.values?.[columnIndex], { locale, sharedStringRegistry, cellXfsRegistry });
+                    // Clear values
+                    sheetCell.setUserEnteredValue(undefined);
+                    sheetCell.setEffectiveValue(undefined);
+                    // Set cell data
+                    currentSheet[rowIndex].values[columnIndex] =
+                        sheetCell.getCellData();
+                    // Enqueue
+                    enqueueCalculation({
+                        position: { rowIndex, columnIndex, sheetId },
+                        type: "remove",
+                    });
+                    // Recalc cells
+                    recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                        rowIndex,
+                        columnIndex,
+                        sheetId,
+                    });
+                }
+            });
+            // Update history
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+        // Clear selections
+        onChangeSelections?.(sheetId, []);
+        onCommand?.({
+            command: "merge-cells",
+            sheetId,
+            activeCell,
+            selections,
+            direction,
+        });
+    }, [
+        locale,
+        sharedStringRegistry,
+        cellXfsRegistry,
+        onChangeSheetData,
+        onChangeSheets,
+        createHistory,
+        enqueueCalculation,
+        onChangeSelections,
+        canEditCellRange,
+        canPerformSheetAction,
+        showError,
+        onCommand,
+    ]);
+    // Unmerge
+    const onUnMergeCells = useCallback((sheetId, activeCell, currentSelections) => {
+        const saveHistory = createHistory();
+        const selections = currentSelections.length
+            ? currentSelections
+            : selectionFromActiveCell(activeCell);
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        onChangeSheets((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (sheet && sheet.merges) {
+                    sheet.merges = sheet.merges?.filter((merge) => {
+                        return !selections.some((sel) => areaIntersects(sel.range, merge));
+                    });
+                }
+            });
+            // Save history
+            saveHistory({
+                sheets: { patches, inversePatches },
+                // selections: { undo: selections, redo: selections },
+                activeCell: { undo: activeCell, redo: activeCell },
+            });
+            return nextState;
+        });
+        // Update sheet data
+        // Clear cells in merges, except tr cell
+        // Only for additional safety, can be removed after testing with google sheets
+        const activeMerges = merges?.filter((merge) => {
+            return selections.some((sel) => areaIntersects(sel.range, merge));
+        });
+        if (activeMerges) {
+            onChangeSheetData?.((prevSheetData) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                    for (const range of activeMerges) {
+                        // Merging cells only keeps the upper-left value and discards other values.
+                        const topRightCell = {
+                            rowIndex: range.startRowIndex,
+                            columnIndex: range.startColumnIndex,
+                        };
+                        // Create a cell
+                        const sheetCell = new SheetCell();
+                        for (const [rowIndex, columnIndex] of iterateCellsInRange(range)) {
+                            if (isEqualCells({ rowIndex, columnIndex }, topRightCell)) {
+                                continue;
+                            }
+                            const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                            sheetCell.assign(sheetId, { rowIndex, columnIndex }, draft[sheetId][rowIndex]?.values?.[columnIndex], { locale });
+                            // Clear values
+                            sheetCell.setUserEnteredValue(undefined);
+                            sheetCell.setEffectiveValue(undefined);
+                            // Set cell data
+                            currentSheet[rowIndex].values[columnIndex] =
+                                sheetCell.getCellData();
+                            // Enqueue
+                            enqueueCalculation({
+                                position: { rowIndex, columnIndex, sheetId },
+                                type: "remove",
+                            });
+                            // Recalc cells
+                            recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                                rowIndex,
+                                columnIndex,
+                                sheetId,
+                            });
+                        }
+                    }
+                });
+                // Update history
+                saveHistory({
+                    sheetData: { patches, inversePatches },
+                    recalcCells: { undo: recalcCells, redo: recalcCells },
+                });
+                return nextState;
+            });
+            // Clear selections
+            // const newSelections = currentSelections
+            const selections = activeMerges.map((range) => ({ range }));
+            onChangeSelections?.(sheetId, selections);
+        }
+        onCommand?.({
+            command: "unmerge-cells",
+            sheetId,
+            activeCell,
+            selections: currentSelections,
+        });
+    }, [
+        locale,
+        merges,
+        onChangeSheetData,
+        onChangeSheets,
+        createHistory,
+        onChangeSelections,
+        enqueueCalculation,
+        onCommand,
+    ]);
+    return {
+        onMergeCells,
+        onUnMergeCells,
+    };
+};

package/dist/esm/hooks/use-on-move-columns.d.ts

@@ -0,0 +1,28 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import { type CellData, type Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { useCalculation } from "./use-calculation";
+import type { useSheetProperties } from "./use-sheet-properties";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+type UseOnMoveColumnsProps<T extends CellData, S extends Sheet> = {
+    rowCount: number;
+    columnCount: number;
+    locale?: string;
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    enqueueStructureChange?: ReturnType<typeof useCalculation>["enqueueStructureChange"];
+    enqueueGraphOperation: ReturnType<typeof useCalculation>["enqueueGraphOperation"];
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeTables: UseSpreadsheetProps<T, S>["onChangeTables"];
+    onChangeConditionalFormats?: UseSpreadsheetProps<T, S>["onChangeConditionalFormats"];
+    onChangeDataValidations?: UseSpreadsheetProps<T, S>["onChangeDataValidations"];
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+    getDataRowCount?: ReturnType<typeof useSheetProperties>["getDataRowCount"];
+    getActiveCell: () => CellInterface;
+    onCommand?: OnCommand;
+};
+export declare const useOnMoveColumns: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, createHistory, onChangeSheetData, onChangeSheets, onChangeTables, onChangeConditionalFormats, onChangeDataValidations, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, getDependents, getDataRowCount, getActiveCell, onCommand, }: UseOnMoveColumnsProps<T, S>) => (sheetId: number, columns: number[], referenceColumnIndex: number) => void;
+export {};
+//# sourceMappingURL=use-on-move-columns.d.ts.map

package/dist/esm/hooks/use-on-move-columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-move-columns.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-move-columns.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAa,MAAM,4BAA4B,CAAC;AAE3E,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAWtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,KAAK,qBAAqB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAChE,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,sBAAsB,CAAC,EAAE,UAAU,CACjC,OAAO,cAAc,CACtB,CAAC,wBAAwB,CAAC,CAAC;IAC5B,qBAAqB,EAAE,UAAU,CAC/B,OAAO,cAAc,CACtB,CAAC,uBAAuB,CAAC,CAAC;IAC3B,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,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,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,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;IAClE,eAAe,CAAC,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,iBAAiB,CAAC,CAAC;IAC3E,aAAa,EAAE,MAAM,aAAa,CAAC;IACnC,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,wRAiBnE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,eAGhB,MAAM,WAAW,MAAM,EAAE,wBAAwB,MAAM,SAsYpE,CAAC"}

package/dist/esm/hooks/use-on-move-columns.js

@@ -0,0 +1,295 @@
+import { Direction } from "@rowsncolumns/grid";
+import { iterateCellsInRange } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { processSideEffectDependentCells } from "../api/dependency";
+import { createSheetDraft } from "../api/immer-utils";
+import { moveMergedCells } from "../api/merges";
+import { updateRangedRulesOnReorder } from "../api/range-rule-helpers";
+import { shiftTableMovingColumns } from "../api/table";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+export const useOnMoveColumns = ({ rowCount, columnCount, locale, createHistory, onChangeSheetData, onChangeSheets, onChangeTables, onChangeConditionalFormats, onChangeDataValidations, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, getDependents, getDataRowCount, getActiveCell, onCommand, }) => {
+    const canEditSheet = useCanEditSheet();
+    return useCallback((sheetId, columns, referenceColumnIndex) => {
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        if (!columns.length) {
+            return;
+        }
+        const saveHistory = createHistory();
+        const { 0: firstColumn, [columns.length - 1]: lastColumn } = columns;
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        // Count
+        const count = columns.length;
+        const direction = referenceColumnIndex <= firstColumn ? Direction.Left : Direction.Right;
+        const delta = (direction === Direction.Right ? -1 : 1) * count;
+        const dataRowCount = getDataRowCount?.(sheetId) ?? rowCount;
+        const invalidationStartColumnIndex = Math.max(1, Math.min(firstColumn, referenceColumnIndex));
+        const invalidationEndColumnIndex = Math.min(columnCount, Math.max(lastColumn, referenceColumnIndex + count - 1));
+        enqueueStructureChange?.({
+            kind: "invalidate-range",
+            sheetId,
+            startRowIndex: 1,
+            endRowIndex: dataRowCount,
+            startColumnIndex: invalidationStartColumnIndex,
+            endColumnIndex: invalidationEndColumnIndex,
+        });
+        const sourceRange = {
+            startColumnIndex: firstColumn,
+            endColumnIndex: lastColumn,
+            startRowIndex: 1,
+            endRowIndex: dataRowCount,
+        };
+        // When you move columns, the resident columns
+        // gets shifted
+        const shiftedRange = {
+            startColumnIndex: Math.min(referenceColumnIndex + count, firstColumn + count),
+            endColumnIndex: Math.max(referenceColumnIndex + count - 1, firstColumn),
+            startRowIndex: 1,
+            endRowIndex: dataRowCount,
+        };
+        // Update sheets
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (sheet) {
+                    if (!sheet.columnMetadata) {
+                        sheet.columnMetadata = [];
+                    }
+                    if (sheet.merges) {
+                        sheet.merges = moveMergedCells(sheet.merges, "column-insert", referenceColumnIndex);
+                    }
+                    // Check if basicFilter needs to be moved
+                    if (sheet.basicFilter) {
+                        if (referenceColumnIndex >=
+                            sheet.basicFilter.range.startColumnIndex &&
+                            referenceColumnIndex <= sheet.basicFilter.range.endColumnIndex) {
+                            // Update filter specs for columns after
+                            if (sheet.basicFilter.filterSpecs) {
+                                for (const spec of sheet.basicFilter.filterSpecs) {
+                                    if (spec.columnIndex >= referenceColumnIndex) {
+                                        spec.columnIndex += count;
+                                    }
+                                }
+                            }
+                            // Update filter specs for columns after
+                            if (sheet.basicFilter.sortSpecs) {
+                                for (const spec of sheet.basicFilter.sortSpecs) {
+                                    if (spec.dimensionIndex >= referenceColumnIndex) {
+                                        spec.dimensionIndex += count;
+                                    }
+                                }
+                            }
+                        }
+                        // Move
+                        shiftTableMovingColumns(sheet.basicFilter, columns, referenceColumnIndex);
+                    }
+                    const columnMetadatas = columns.map((columnIndex) => {
+                        return sheet.columnMetadata?.[columnIndex] ?? null;
+                    });
+                    // Remove
+                    sheet.columnMetadata.splice(firstColumn, count);
+                    // Insert
+                    columns.forEach((columnIndex, index) => {
+                        // Fixes a bug when u drag a column adjacent to modified column
+                        // Modify A size, and drag it before G
+                        sheet.columnMetadata.splice(referenceColumnIndex + index, 0, {});
+                        sheet.columnMetadata[referenceColumnIndex + index] =
+                            columnMetadatas[index];
+                    });
+                }
+            });
+            // Save history
+            saveHistory({
+                sheets: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Remove columns and insert them at referenceColumnIndex
+        // Update sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                // Process formulas of moved columns
+                const movedKeys = new Set();
+                // Update formulas
+                for (const [rowIndex, columnIndex] of iterateCellsInRange(sourceRange)) {
+                    const columnDelta = referenceColumnIndex - firstColumn;
+                    const rowDelta = 0;
+                    // Process dependents
+                    processSideEffectDependentCells({
+                        draft,
+                        rowIndex,
+                        columnIndex,
+                        sheetId,
+                        columnDelta,
+                        enqueueGraphOperation,
+                        enqueueCalculation,
+                        getDependents,
+                        recalcCells,
+                        rowDelta,
+                        sourceRange,
+                        movedKeys,
+                        locale,
+                        rowCount,
+                        columnCount,
+                    });
+                }
+                movedKeys.clear();
+                // Update formulas
+                for (const [rowIndex, columnIndex] of iterateCellsInRange(shiftedRange)) {
+                    const columnDelta = delta;
+                    const rowDelta = 0;
+                    // Process dependents
+                    processSideEffectDependentCells({
+                        draft,
+                        rowIndex,
+                        columnIndex,
+                        sheetId,
+                        columnDelta,
+                        enqueueGraphOperation,
+                        enqueueCalculation,
+                        getDependents,
+                        recalcCells,
+                        rowDelta,
+                        sourceRange: shiftedRange,
+                        movedKeys,
+                        locale,
+                        rowCount,
+                        columnCount,
+                    });
+                }
+                for (let rowIndex = 1; rowIndex < (draft[sheetId]?.length ?? 0); rowIndex++) {
+                    const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    // Save columns being moved
+                    const columnValues = columns.map((columnIndex) => currentSheet[rowIndex].values[columnIndex]);
+                    // Remove
+                    currentSheet[rowIndex].values.splice(firstColumn, count);
+                    // Insert
+                    columns.forEach((_, index) => {
+                        currentSheet[rowIndex].values.splice(referenceColumnIndex + index, 0, {});
+                        currentSheet[rowIndex].values[referenceColumnIndex + index] =
+                            columnValues[index];
+                    });
+                }
+            });
+            // Save history
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                activeCell: {
+                    undo: getActiveCell(),
+                    redo: { ...getActiveCell(), columnIndex: referenceColumnIndex },
+                },
+                selections: {
+                    undo: [
+                        {
+                            range: {
+                                startRowIndex: 1,
+                                endRowIndex: rowCount,
+                                startColumnIndex: firstColumn,
+                                endColumnIndex: lastColumn,
+                            },
+                        },
+                    ],
+                    redo: [
+                        {
+                            range: {
+                                startRowIndex: 1,
+                                endRowIndex: rowCount,
+                                startColumnIndex: referenceColumnIndex,
+                                endColumnIndex: referenceColumnIndex + count - 1,
+                            },
+                        },
+                    ],
+                },
+            });
+            return nextState;
+        });
+        // Update move tables if user is moving columns
+        onChangeTables?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                for (const table of draft) {
+                    if (table.sheetId !== sheetId) {
+                        continue;
+                    }
+                    if (referenceColumnIndex >= table.range.startColumnIndex &&
+                        referenceColumnIndex <= table.range.endColumnIndex) {
+                        // The column that is being moved
+                        const columnsToMove = table.columns?.splice(firstColumn - table.range.startColumnIndex, count);
+                        if (columnsToMove) {
+                            table.columns?.splice(referenceColumnIndex - table.range.startColumnIndex, 0, ...columnsToMove);
+                        }
+                        // Update filter specs for columns after
+                        if (table.filterSpecs) {
+                            for (const spec of table.filterSpecs) {
+                                if (spec.columnIndex >= referenceColumnIndex) {
+                                    spec.columnIndex += count;
+                                }
+                            }
+                        }
+                        // Update filter specs for columns after
+                        if (table.sortSpecs) {
+                            for (const spec of table.sortSpecs) {
+                                if (spec.dimensionIndex >= referenceColumnIndex) {
+                                    spec.dimensionIndex += count;
+                                }
+                            }
+                        }
+                    }
+                    // Move table
+                    shiftTableMovingColumns(table, columns, referenceColumnIndex);
+                }
+            });
+            saveHistory({
+                tables: {
+                    patches,
+                    inversePatches,
+                },
+            });
+            return nextState;
+        });
+        // Re-anchor CF / DV ranges to follow the moved columns. Matches
+        // Excel's cell-tracking semantics for single-range rules.
+        onChangeDataValidations?.((prevValidations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevValidations, (draft) => {
+                updateRangedRulesOnReorder(draft, "column", firstColumn, lastColumn, referenceColumnIndex, sheetId);
+            });
+            saveHistory({ dataValidations: { patches, inversePatches } });
+            return nextState;
+        });
+        onChangeConditionalFormats?.((prevConditionalFormats) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevConditionalFormats, (draft) => {
+                updateRangedRulesOnReorder(draft, "column", firstColumn, lastColumn, referenceColumnIndex, sheetId);
+            });
+            saveHistory({ conditionalFormats: { patches, inversePatches } });
+            return nextState;
+        });
+        onCommand?.({
+            command: "move-columns",
+            sheetId,
+            columns,
+            referenceColumnIndex,
+        });
+    }, [
+        rowCount,
+        columnCount,
+        locale,
+        getActiveCell,
+        getDataRowCount,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeTables,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        createHistory,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+        getDependents,
+        canEditSheet,
+        onCommand,
+    ]);
+};

package/dist/esm/hooks/use-on-move-rows.d.ts

@@ -0,0 +1,30 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import { type CellData, type Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { useCalculation } from "./use-calculation";
+import type { useSheetProperties } from "./use-sheet-properties";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+type UseOnMoveRowsProps<T extends CellData, S extends Sheet> = {
+    rowCount: number;
+    columnCount: number;
+    locale?: string;
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    enqueueStructureChange?: ReturnType<typeof useCalculation>["enqueueStructureChange"];
+    enqueueGraphOperation: ReturnType<typeof useCalculation>["enqueueGraphOperation"];
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeTables: UseSpreadsheetProps<T, S>["onChangeTables"];
+    onChangeNamedRanges: UseSpreadsheetProps<T, S>["onChangeNamedRanges"];
+    onChangeConditionalFormats?: UseSpreadsheetProps<T, S>["onChangeConditionalFormats"];
+    onChangeDataValidations?: UseSpreadsheetProps<T, S>["onChangeDataValidations"];
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+    getDataRowCount?: ReturnType<typeof useSheetProperties>["getDataRowCount"];
+    getNonEmptyColumnCount?: ReturnType<typeof useSheetProperties>["getNonEmptyColumnCount"];
+    getActiveCell: () => CellInterface;
+    onCommand?: OnCommand;
+};
+export declare const useOnMoveRows: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, createHistory, onChangeSheetData, onChangeSheets, onChangeTables, onChangeConditionalFormats, onChangeDataValidations, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, getDependents, getNonEmptyColumnCount, getActiveCell, onCommand, }: UseOnMoveRowsProps<T, S>) => (sheetId: number, rows: number[], referenceRowIndex: number) => void;
+export {};
+//# sourceMappingURL=use-on-move-rows.d.ts.map