@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,366 @@
+import { __assign, __read, __spreadArray, __values } from "tslib";
+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 var useOnMergeUnMergeCells = function (_a) {
+    var locale = _a.locale, merges = _a.merges, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, createHistory = _a.createHistory, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeSelections = _a.onChangeSelections, enqueueCalculation = _a.enqueueCalculation, onCommand = _a.onCommand;
+    var canEditCellRange = useCanEditCellRange();
+    var canPerformSheetAction = useCanPerformSheetAction();
+    var showError = useShowError();
+    /**
+     * Merge cells
+     */
+    var onMergeCells = useCallback(function (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;
+        }
+        var range = selections[selections.length - 1].range;
+        // Calculate new merges
+        var newMerges = [];
+        if (direction === Direction.Right) {
+            for (var rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                newMerges.push(__assign(__assign({}, range), { startRowIndex: rowIndex, endRowIndex: rowIndex }));
+            }
+        }
+        else if (direction === Direction.Down) {
+            for (var columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+                newMerges.push(__assign(__assign({}, range), { startColumnIndex: columnIndex, endColumnIndex: columnIndex }));
+            }
+        }
+        else {
+            newMerges.push(range);
+        }
+        var saveHistory = createHistory();
+        // We need to track this for history. Precedent cells
+        var recalcCells = new Map();
+        // Update references
+        onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var _a;
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                if (sheet) {
+                    if (!(sheet === null || sheet === void 0 ? void 0 : sheet.merges)) {
+                        sheet.merges = [];
+                    }
+                    // Remove existing merges that intersect with new merges
+                    if (sheet.merges.length > 0) {
+                        sheet.merges = sheet.merges.filter(function (existingMerge) {
+                            return !newMerges.some(function (newMerge) {
+                                return areaIntersects(existingMerge, newMerge);
+                            });
+                        });
+                    }
+                    (_a = sheet.merges).push.apply(_a, __spreadArray([], __read(newMerges), false));
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+                selections: { undo: selections, redo: [] },
+                activeCell: { undo: activeCell, redo: activeCell },
+            });
+            return nextState;
+        });
+        // Update sheet data
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_1, _a, e_2, _b, e_3, _c;
+                var _d, _e, _f, _g, _h, _j, _k, _l;
+                // First, check if we need to move content to master cells
+                // If master cell is empty, find first cell with content and copy it
+                var checkCell = new SheetCell();
+                try {
+                    for (var newMerges_1 = __values(newMerges), newMerges_1_1 = newMerges_1.next(); !newMerges_1_1.done; newMerges_1_1 = newMerges_1.next()) {
+                        var mergeRange = newMerges_1_1.value;
+                        var masterCell = {
+                            rowIndex: mergeRange.startRowIndex,
+                            columnIndex: mergeRange.startColumnIndex,
+                        };
+                        // Check if master cell has content
+                        var masterCellData = (_f = (_e = (_d = draft[sheetId]) === null || _d === void 0 ? void 0 : _d[masterCell.rowIndex]) === null || _e === void 0 ? void 0 : _e.values) === null || _f === void 0 ? void 0 : _f[masterCell.columnIndex];
+                        // Use current() to get plain data from Immer draft
+                        var plainMasterCellData = masterCellData
+                            ? current(masterCellData)
+                            : masterCellData;
+                        checkCell.assign(sheetId, masterCell, plainMasterCellData, {
+                            locale: locale,
+                            cellXfsRegistry: cellXfsRegistry,
+                            sharedStringRegistry: sharedStringRegistry,
+                        });
+                        var masterHasContent = checkCell.formattedValue !== undefined &&
+                            checkCell.formattedValue !== null &&
+                            checkCell.formattedValue !== "";
+                        // If master cell is empty, find first cell with content and copy it
+                        if (!masterHasContent) {
+                            try {
+                                for (var _m = (e_2 = void 0, __values(iterateCellsInRange(mergeRange))), _o = _m.next(); !_o.done; _o = _m.next()) {
+                                    var _p = __read(_o.value, 2), rowIndex = _p[0], columnIndex = _p[1];
+                                    // Skip the master cell itself
+                                    if (rowIndex === masterCell.rowIndex &&
+                                        columnIndex === masterCell.columnIndex) {
+                                        continue;
+                                    }
+                                    var cellData = (_j = (_h = (_g = draft[sheetId]) === null || _g === void 0 ? void 0 : _g[rowIndex]) === null || _h === void 0 ? void 0 : _h.values) === null || _j === void 0 ? void 0 : _j[columnIndex];
+                                    // Use current() to get plain data from Immer draft
+                                    var plainCellData = cellData ? current(cellData) : cellData;
+                                    // Check if cell has content
+                                    checkCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, plainCellData, { locale: locale, cellXfsRegistry: cellXfsRegistry, sharedStringRegistry: sharedStringRegistry });
+                                    var hasContent = checkCell.formattedValue !== undefined &&
+                                        checkCell.formattedValue !== null &&
+                                        checkCell.formattedValue !== "";
+                                    if (hasContent) {
+                                        // Found a cell with content - copy it to master cell
+                                        var masterSheet = createSheetDraft(draft, sheetId, masterCell.rowIndex);
+                                        var cellDataToCopy = checkCell.getCellData();
+                                        // Copy to master cell
+                                        masterSheet[masterCell.rowIndex].values[masterCell.columnIndex] = cellDataToCopy;
+                                        // Break after finding first cell with content
+                                        break;
+                                    }
+                                }
+                            }
+                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                            finally {
+                                try {
+                                    if (_o && !_o.done && (_b = _m.return)) _b.call(_m);
+                                }
+                                finally { if (e_2) throw e_2.error; }
+                            }
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (newMerges_1_1 && !newMerges_1_1.done && (_a = newMerges_1.return)) _a.call(newMerges_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                // Keep track of master cells
+                // Merging cells only keeps the upper-left value and discards other values.
+                var masterCells = new Set();
+                if (direction === Direction.Right) {
+                    for (var rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                        masterCells.add(cellIdentifier(rowIndex, range.startColumnIndex));
+                    }
+                }
+                else if (direction === Direction.Down) {
+                    for (var columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+                        masterCells.add(cellIdentifier(range.startRowIndex, columnIndex));
+                    }
+                }
+                else {
+                    masterCells.add(cellIdentifier(range.startRowIndex, range.startColumnIndex));
+                }
+                // Create a cell
+                var sheetCell = new SheetCell();
+                try {
+                    for (var _q = __values(iterateCellsInRange(range)), _r = _q.next(); !_r.done; _r = _q.next()) {
+                        var _s = __read(_r.value, 2), rowIndex = _s[0], columnIndex = _s[1];
+                        var cellId = cellIdentifier(rowIndex, columnIndex);
+                        if (masterCells.has(cellId)) {
+                            continue;
+                        }
+                        var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                        sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, (_l = (_k = draft[sheetId][rowIndex]) === null || _k === void 0 ? void 0 : _k.values) === null || _l === void 0 ? void 0 : _l[columnIndex], { locale: locale, sharedStringRegistry: sharedStringRegistry, cellXfsRegistry: cellXfsRegistry });
+                        // Clear values
+                        sheetCell.setUserEnteredValue(undefined);
+                        sheetCell.setEffectiveValue(undefined);
+                        // Set cell data
+                        currentSheet[rowIndex].values[columnIndex] =
+                            sheetCell.getCellData();
+                        // Enqueue
+                        enqueueCalculation({
+                            position: { rowIndex: rowIndex, columnIndex: columnIndex, sheetId: sheetId },
+                            type: "remove",
+                        });
+                        // Recalc cells
+                        recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                            rowIndex: rowIndex,
+                            columnIndex: columnIndex,
+                            sheetId: sheetId,
+                        });
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (_r && !_r.done && (_c = _q.return)) _c.call(_q);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Update history
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+        // Clear selections
+        onChangeSelections === null || onChangeSelections === void 0 ? void 0 : onChangeSelections(sheetId, []);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "merge-cells",
+            sheetId: sheetId,
+            activeCell: activeCell,
+            selections: selections,
+            direction: direction,
+        });
+    }, [
+        locale,
+        sharedStringRegistry,
+        cellXfsRegistry,
+        onChangeSheetData,
+        onChangeSheets,
+        createHistory,
+        enqueueCalculation,
+        onChangeSelections,
+        canEditCellRange,
+        canPerformSheetAction,
+        showError,
+        onCommand,
+    ]);
+    // Unmerge
+    var onUnMergeCells = useCallback(function (sheetId, activeCell, currentSelections) {
+        var saveHistory = createHistory();
+        var selections = currentSelections.length
+            ? currentSelections
+            : selectionFromActiveCell(activeCell);
+        // We need to track this for history. Precedent cells
+        var recalcCells = new Map();
+        onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var _a;
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                if (sheet && sheet.merges) {
+                    sheet.merges = (_a = sheet.merges) === null || _a === void 0 ? void 0 : _a.filter(function (merge) {
+                        return !selections.some(function (sel) {
+                            return areaIntersects(sel.range, merge);
+                        });
+                    });
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheets: { patches: patches, inversePatches: 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
+        var activeMerges = merges === null || merges === void 0 ? void 0 : merges.filter(function (merge) {
+            return selections.some(function (sel) { return areaIntersects(sel.range, merge); });
+        });
+        if (activeMerges) {
+            onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+                var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                    var e_4, _a, e_5, _b;
+                    var _c, _d;
+                    try {
+                        for (var activeMerges_1 = __values(activeMerges), activeMerges_1_1 = activeMerges_1.next(); !activeMerges_1_1.done; activeMerges_1_1 = activeMerges_1.next()) {
+                            var range = activeMerges_1_1.value;
+                            // Merging cells only keeps the upper-left value and discards other values.
+                            var topRightCell = {
+                                rowIndex: range.startRowIndex,
+                                columnIndex: range.startColumnIndex,
+                            };
+                            // Create a cell
+                            var sheetCell = new SheetCell();
+                            try {
+                                for (var _e = (e_5 = void 0, __values(iterateCellsInRange(range))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                    var _g = __read(_f.value, 2), rowIndex = _g[0], columnIndex = _g[1];
+                                    if (isEqualCells({ rowIndex: rowIndex, columnIndex: columnIndex }, topRightCell)) {
+                                        continue;
+                                    }
+                                    var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                                    sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, (_d = (_c = draft[sheetId][rowIndex]) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d[columnIndex], { locale: locale });
+                                    // Clear values
+                                    sheetCell.setUserEnteredValue(undefined);
+                                    sheetCell.setEffectiveValue(undefined);
+                                    // Set cell data
+                                    currentSheet[rowIndex].values[columnIndex] =
+                                        sheetCell.getCellData();
+                                    // Enqueue
+                                    enqueueCalculation({
+                                        position: { rowIndex: rowIndex, columnIndex: columnIndex, sheetId: sheetId },
+                                        type: "remove",
+                                    });
+                                    // Recalc cells
+                                    recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                                        rowIndex: rowIndex,
+                                        columnIndex: columnIndex,
+                                        sheetId: sheetId,
+                                    });
+                                }
+                            }
+                            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                            finally {
+                                try {
+                                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                                }
+                                finally { if (e_5) throw e_5.error; }
+                            }
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (activeMerges_1_1 && !activeMerges_1_1.done && (_a = activeMerges_1.return)) _a.call(activeMerges_1);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                // Update history
+                saveHistory({
+                    sheetData: { patches: patches, inversePatches: inversePatches },
+                    recalcCells: { undo: recalcCells, redo: recalcCells },
+                });
+                return nextState;
+            });
+            // Clear selections
+            // const newSelections = currentSelections
+            var selections_1 = activeMerges.map(function (range) { return ({ range: range }); });
+            onChangeSelections === null || onChangeSelections === void 0 ? void 0 : onChangeSelections(sheetId, selections_1);
+        }
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "unmerge-cells",
+            sheetId: sheetId,
+            activeCell: activeCell,
+            selections: currentSelections,
+        });
+    }, [
+        locale,
+        merges,
+        onChangeSheetData,
+        onChangeSheets,
+        createHistory,
+        onChangeSelections,
+        enqueueCalculation,
+        onCommand,
+    ]);
+    return {
+        onMergeCells: onMergeCells,
+        onUnMergeCells: onUnMergeCells,
+    };
+};

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