@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,378 @@
+import { __assign, __read, __spreadArray, __values } from "tslib";
+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 var useOnMoveColumns = function (_a) {
+    var rowCount = _a.rowCount, columnCount = _a.columnCount, locale = _a.locale, createHistory = _a.createHistory, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeTables = _a.onChangeTables, onChangeConditionalFormats = _a.onChangeConditionalFormats, onChangeDataValidations = _a.onChangeDataValidations, enqueueGraphOperation = _a.enqueueGraphOperation, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, getDependents = _a.getDependents, getDataRowCount = _a.getDataRowCount, getActiveCell = _a.getActiveCell, onCommand = _a.onCommand;
+    var canEditSheet = useCanEditSheet();
+    return useCallback(function (sheetId, columns, referenceColumnIndex) {
+        var _a;
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        if (!columns.length) {
+            return;
+        }
+        var saveHistory = createHistory();
+        var _b = columns, firstColumn = _b[0], _c = columns.length - 1, lastColumn = _b[_c];
+        // We need to track this for history. Precedent cells
+        var recalcCells = new Map();
+        // Count
+        var count = columns.length;
+        var direction = referenceColumnIndex <= firstColumn ? Direction.Left : Direction.Right;
+        var delta = (direction === Direction.Right ? -1 : 1) * count;
+        var dataRowCount = (_a = getDataRowCount === null || getDataRowCount === void 0 ? void 0 : getDataRowCount(sheetId)) !== null && _a !== void 0 ? _a : rowCount;
+        var invalidationStartColumnIndex = Math.max(1, Math.min(firstColumn, referenceColumnIndex));
+        var invalidationEndColumnIndex = Math.min(columnCount, Math.max(lastColumn, referenceColumnIndex + count - 1));
+        enqueueStructureChange === null || enqueueStructureChange === void 0 ? void 0 : enqueueStructureChange({
+            kind: "invalidate-range",
+            sheetId: sheetId,
+            startRowIndex: 1,
+            endRowIndex: dataRowCount,
+            startColumnIndex: invalidationStartColumnIndex,
+            endColumnIndex: invalidationEndColumnIndex,
+        });
+        var sourceRange = {
+            startColumnIndex: firstColumn,
+            endColumnIndex: lastColumn,
+            startRowIndex: 1,
+            endRowIndex: dataRowCount,
+        };
+        // When you move columns, the resident columns
+        // gets shifted
+        var shiftedRange = {
+            startColumnIndex: Math.min(referenceColumnIndex + count, firstColumn + count),
+            endColumnIndex: Math.max(referenceColumnIndex + count - 1, firstColumn),
+            startRowIndex: 1,
+            endRowIndex: dataRowCount,
+        };
+        // Update sheets
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var e_1, _a, e_2, _b;
+                var sheet = draft.find(function (sheet) { return 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) {
+                                try {
+                                    for (var _c = __values(sheet.basicFilter.filterSpecs), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                        var spec = _d.value;
+                                        if (spec.columnIndex >= referenceColumnIndex) {
+                                            spec.columnIndex += count;
+                                        }
+                                    }
+                                }
+                                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                                finally {
+                                    try {
+                                        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                                    }
+                                    finally { if (e_1) throw e_1.error; }
+                                }
+                            }
+                            // Update filter specs for columns after
+                            if (sheet.basicFilter.sortSpecs) {
+                                try {
+                                    for (var _e = __values(sheet.basicFilter.sortSpecs), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                        var spec = _f.value;
+                                        if (spec.dimensionIndex >= referenceColumnIndex) {
+                                            spec.dimensionIndex += count;
+                                        }
+                                    }
+                                }
+                                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                finally {
+                                    try {
+                                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                                    }
+                                    finally { if (e_2) throw e_2.error; }
+                                }
+                            }
+                        }
+                        // Move
+                        shiftTableMovingColumns(sheet.basicFilter, columns, referenceColumnIndex);
+                    }
+                    var columnMetadatas_1 = columns.map(function (columnIndex) {
+                        var _a, _b;
+                        return (_b = (_a = sheet.columnMetadata) === null || _a === void 0 ? void 0 : _a[columnIndex]) !== null && _b !== void 0 ? _b : null;
+                    });
+                    // Remove
+                    sheet.columnMetadata.splice(firstColumn, count);
+                    // Insert
+                    columns.forEach(function (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_1[index];
+                    });
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Remove columns and insert them at referenceColumnIndex
+        // Update sheet data
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_3, _a, e_4, _b;
+                var _c, _d;
+                // Process formulas of moved columns
+                var movedKeys = new Set();
+                try {
+                    // Update formulas
+                    for (var _e = __values(iterateCellsInRange(sourceRange)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var _g = __read(_f.value, 2), rowIndex = _g[0], columnIndex = _g[1];
+                        var columnDelta = referenceColumnIndex - firstColumn;
+                        var rowDelta = 0;
+                        // Process dependents
+                        processSideEffectDependentCells({
+                            draft: draft,
+                            rowIndex: rowIndex,
+                            columnIndex: columnIndex,
+                            sheetId: sheetId,
+                            columnDelta: columnDelta,
+                            enqueueGraphOperation: enqueueGraphOperation,
+                            enqueueCalculation: enqueueCalculation,
+                            getDependents: getDependents,
+                            recalcCells: recalcCells,
+                            rowDelta: rowDelta,
+                            sourceRange: sourceRange,
+                            movedKeys: movedKeys,
+                            locale: locale,
+                            rowCount: rowCount,
+                            columnCount: columnCount,
+                        });
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+                movedKeys.clear();
+                try {
+                    // Update formulas
+                    for (var _h = __values(iterateCellsInRange(shiftedRange)), _j = _h.next(); !_j.done; _j = _h.next()) {
+                        var _k = __read(_j.value, 2), rowIndex = _k[0], columnIndex = _k[1];
+                        var columnDelta = delta;
+                        var rowDelta = 0;
+                        // Process dependents
+                        processSideEffectDependentCells({
+                            draft: draft,
+                            rowIndex: rowIndex,
+                            columnIndex: columnIndex,
+                            sheetId: sheetId,
+                            columnDelta: columnDelta,
+                            enqueueGraphOperation: enqueueGraphOperation,
+                            enqueueCalculation: enqueueCalculation,
+                            getDependents: getDependents,
+                            recalcCells: recalcCells,
+                            rowDelta: rowDelta,
+                            sourceRange: shiftedRange,
+                            movedKeys: movedKeys,
+                            locale: locale,
+                            rowCount: rowCount,
+                            columnCount: columnCount,
+                        });
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+                var _loop_1 = function (rowIndex) {
+                    var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    // Save columns being moved
+                    var columnValues = columns.map(function (columnIndex) { return currentSheet[rowIndex].values[columnIndex]; });
+                    // Remove
+                    currentSheet[rowIndex].values.splice(firstColumn, count);
+                    // Insert
+                    columns.forEach(function (_, index) {
+                        currentSheet[rowIndex].values.splice(referenceColumnIndex + index, 0, {});
+                        currentSheet[rowIndex].values[referenceColumnIndex + index] =
+                            columnValues[index];
+                    });
+                };
+                for (var rowIndex = 1; rowIndex < ((_d = (_c = draft[sheetId]) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0); rowIndex++) {
+                    _loop_1(rowIndex);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                activeCell: {
+                    undo: getActiveCell(),
+                    redo: __assign(__assign({}, 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 === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTables) {
+            var _a = __read(produceWithPatches(prevTables, function (draft) {
+                var e_5, _a, e_6, _b, e_7, _c;
+                var _d, _e;
+                try {
+                    for (var draft_1 = __values(draft), draft_1_1 = draft_1.next(); !draft_1_1.done; draft_1_1 = draft_1.next()) {
+                        var table = draft_1_1.value;
+                        if (table.sheetId !== sheetId) {
+                            continue;
+                        }
+                        if (referenceColumnIndex >= table.range.startColumnIndex &&
+                            referenceColumnIndex <= table.range.endColumnIndex) {
+                            // The column that is being moved
+                            var columnsToMove = (_d = table.columns) === null || _d === void 0 ? void 0 : _d.splice(firstColumn - table.range.startColumnIndex, count);
+                            if (columnsToMove) {
+                                (_e = table.columns) === null || _e === void 0 ? void 0 : _e.splice.apply(_e, __spreadArray([referenceColumnIndex - table.range.startColumnIndex,
+                                    0], __read(columnsToMove), false));
+                            }
+                            // Update filter specs for columns after
+                            if (table.filterSpecs) {
+                                try {
+                                    for (var _f = (e_6 = void 0, __values(table.filterSpecs)), _g = _f.next(); !_g.done; _g = _f.next()) {
+                                        var spec = _g.value;
+                                        if (spec.columnIndex >= referenceColumnIndex) {
+                                            spec.columnIndex += count;
+                                        }
+                                    }
+                                }
+                                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                                finally {
+                                    try {
+                                        if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                                    }
+                                    finally { if (e_6) throw e_6.error; }
+                                }
+                            }
+                            // Update filter specs for columns after
+                            if (table.sortSpecs) {
+                                try {
+                                    for (var _h = (e_7 = void 0, __values(table.sortSpecs)), _j = _h.next(); !_j.done; _j = _h.next()) {
+                                        var spec = _j.value;
+                                        if (spec.dimensionIndex >= referenceColumnIndex) {
+                                            spec.dimensionIndex += count;
+                                        }
+                                    }
+                                }
+                                catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                                finally {
+                                    try {
+                                        if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                                    }
+                                    finally { if (e_7) throw e_7.error; }
+                                }
+                            }
+                        }
+                        // Move table
+                        shiftTableMovingColumns(table, columns, referenceColumnIndex);
+                    }
+                }
+                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                finally {
+                    try {
+                        if (draft_1_1 && !draft_1_1.done && (_a = draft_1.return)) _a.call(draft_1);
+                    }
+                    finally { if (e_5) throw e_5.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                tables: {
+                    patches: patches,
+                    inversePatches: inversePatches,
+                },
+            });
+            return nextState;
+        });
+        // Re-anchor CF / DV ranges to follow the moved columns. Matches
+        // Excel's cell-tracking semantics for single-range rules.
+        onChangeDataValidations === null || onChangeDataValidations === void 0 ? void 0 : onChangeDataValidations(function (prevValidations) {
+            var _a = __read(produceWithPatches(prevValidations, function (draft) {
+                updateRangedRulesOnReorder(draft, "column", firstColumn, lastColumn, referenceColumnIndex, sheetId);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ dataValidations: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        onChangeConditionalFormats === null || onChangeConditionalFormats === void 0 ? void 0 : onChangeConditionalFormats(function (prevConditionalFormats) {
+            var _a = __read(produceWithPatches(prevConditionalFormats, function (draft) {
+                updateRangedRulesOnReorder(draft, "column", firstColumn, lastColumn, referenceColumnIndex, sheetId);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ conditionalFormats: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "move-columns",
+            sheetId: sheetId,
+            columns: columns,
+            referenceColumnIndex: referenceColumnIndex,
+        });
+    }, [
+        rowCount,
+        columnCount,
+        locale,
+        getActiveCell,
+        getDataRowCount,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeTables,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        createHistory,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+        getDependents,
+        canEditSheet,
+        onCommand,
+    ]);
+};

package/dist/cjs/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

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-move-rows.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-move-rows.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAa,MAAM,4BAA4B,CAAC;AAE3E,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAUtE,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,kBAAkB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC7D,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,mBAAmB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC;IACtE,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,sBAAsB,CAAC,EAAE,UAAU,CACjC,OAAO,kBAAkB,CAC1B,CAAC,wBAAwB,CAAC,CAAC;IAC5B,aAAa,EAAE,MAAM,aAAa,CAAC;IACnC,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,+RAiBhE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,eAGb,MAAM,QAAQ,MAAM,EAAE,qBAAqB,MAAM,SA2U9D,CAAC"}