@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/interface/delete-cells-shift-left.js

@@ -0,0 +1,160 @@
+import { __read, __spreadArray, __values } from "tslib";
+import { selectionFromActiveCell } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { collectUniqueDependentsForRange, moveFormulaAtPosition, } from "../api/dependency";
+import { moveMergedCells } from "../api/merges";
+export var deleteCellsShiftLeft = function (_a) {
+    var rowCount = _a.rowCount, columnCount = _a.columnCount, locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getActiveCell = _a.getActiveCell, getSelections = _a.getSelections, getDependents = _a.getDependents, createHistory = _a.createHistory, enqueueGraphOperation = _a.enqueueGraphOperation, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeCitations = _a.onChangeCitations;
+    return function (sheetId, activeCell, selections) {
+        var saveHistory = createHistory();
+        var recalcCells = new Map();
+        // Calculate selection
+        var finalSelections = selections.length
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        var selection = finalSelections[finalSelections.length - 1];
+        var count = selection.range.endColumnIndex - selection.range.startColumnIndex + 1;
+        enqueueStructureChange === null || enqueueStructureChange === void 0 ? void 0 : enqueueStructureChange({
+            kind: "delete-cells-shift-left",
+            sheetId: sheetId,
+            startRowIndex: selection.range.startRowIndex,
+            endRowIndex: selection.range.endRowIndex,
+            startColumnIndex: selection.range.startColumnIndex,
+            endColumnIndex: selection.range.endColumnIndex,
+            columnCount: columnCount,
+        });
+        // Update merges on sheet
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var sheet = draft.find(function (s) { return s.sheetId === sheetId; });
+                if (sheet === null || sheet === void 0 ? void 0 : sheet.merges) {
+                    for (var columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                        sheet.merges = moveMergedCells(sheet.merges, "column-remove", columnIndex);
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ sheets: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Update citations - delete if overlapping, shift back if after
+        onChangeCitations === null || onChangeCitations === void 0 ? void 0 : onChangeCitations(function (prevCitations) {
+            var _a = __read(produceWithPatches(prevCitations, function (draft) {
+                var deleteRowStart = selection.range.startRowIndex;
+                var deleteRowEnd = selection.range.endRowIndex;
+                var deleteColStart = selection.range.startColumnIndex;
+                var deleteColEnd = selection.range.endColumnIndex;
+                var shiftAmount = deleteColEnd - deleteColStart + 1;
+                for (var idx = draft.length - 1; idx >= 0; idx--) {
+                    var citation = draft[idx];
+                    if (citation.range.sheetId !== sheetId)
+                        continue;
+                    var rowsOverlap = !(citation.range.endRowIndex < deleteRowStart || citation.range.startRowIndex > deleteRowEnd);
+                    if (rowsOverlap) {
+                        var colsOverlap = !(citation.range.endColumnIndex < deleteColStart || citation.range.startColumnIndex > deleteColEnd);
+                        if (colsOverlap) {
+                            draft.splice(idx, 1);
+                        }
+                        else if (citation.range.startColumnIndex > deleteColEnd) {
+                            citation.range.startColumnIndex -= shiftAmount;
+                            citation.range.endColumnIndex -= shiftAmount;
+                        }
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ citations: { patches: patches, inversePatches: inversePatches } });
+            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;
+                var _b, _c, _d, _e, _f, _g, _h, _j;
+                var movedKeys = new Set();
+                // Build a broad source range across the selection rows, clamped per row by helper
+                var sourceRange = {
+                    startRowIndex: selection.range.startRowIndex,
+                    endRowIndex: selection.range.endRowIndex,
+                    startColumnIndex: selection.range.startColumnIndex,
+                    endColumnIndex: columnCount,
+                };
+                // Collect unique dependents only once
+                var dependents = collectUniqueDependentsForRange({
+                    draft: draft,
+                    sheetId: sheetId,
+                    sourceRange: sourceRange,
+                    getDependents: getDependents,
+                });
+                try {
+                    // Move each dependent exactly once (shift left by count)
+                    for (var _k = __values(dependents.values()), _l = _k.next(); !_l.done; _l = _k.next()) {
+                        var pos = _l.value;
+                        moveFormulaAtPosition({
+                            draft: draft,
+                            position: pos,
+                            enqueueCalculation: enqueueCalculation,
+                            enqueueGraphOperation: enqueueGraphOperation,
+                            recalcCells: recalcCells,
+                            movedKeys: movedKeys,
+                            rowDelta: 0,
+                            columnDelta: -count,
+                            sourceRange: sourceRange,
+                            locale: locale,
+                            rowCount: rowCount,
+                            columnCount: columnCount,
+                            cellXfsRegistry: cellXfsRegistry,
+                            sharedStringRegistry: sharedStringRegistry,
+                        });
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_l && !_l.done && (_a = _k.return)) _a.call(_k);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                // Also adjust formulas that live within the selection band itself
+                for (var rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                    var dataColumnCount = (_e = (_d = (_c = (_b = draft[sheetId]) === null || _b === void 0 ? void 0 : _b[rowIndex]) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0;
+                    var startCol = Math.min(Math.max(selection.range.startColumnIndex, 1), dataColumnCount);
+                    for (var columnIndex = startCol; columnIndex < dataColumnCount; columnIndex++) {
+                        moveFormulaAtPosition({
+                            draft: draft,
+                            position: { sheetId: sheetId, rowIndex: rowIndex, columnIndex: columnIndex },
+                            enqueueCalculation: enqueueCalculation,
+                            enqueueGraphOperation: enqueueGraphOperation,
+                            recalcCells: recalcCells,
+                            movedKeys: movedKeys,
+                            rowDelta: 0,
+                            columnDelta: -count,
+                            sourceRange: sourceRange,
+                            locale: locale,
+                            rowCount: rowCount,
+                            columnCount: columnCount,
+                            cellXfsRegistry: cellXfsRegistry,
+                            sharedStringRegistry: sharedStringRegistry,
+                        });
+                    }
+                }
+                // Finally delete the selected cells by splicing from right to left
+                for (var rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                    for (var columnIndex = selection.range.endColumnIndex; columnIndex >= selection.range.startColumnIndex; columnIndex--) {
+                        if ((_g = (_f = draft[sheetId]) === null || _f === void 0 ? void 0 : _f[rowIndex]) === null || _g === void 0 ? void 0 : _g.values) {
+                            (_j = (_h = draft[sheetId][rowIndex]) === null || _h === void 0 ? void 0 : _h.values) === null || _j === void 0 ? void 0 : _j.splice(columnIndex, 1);
+                        }
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                activeCell: { undo: getActiveCell(), redo: getActiveCell() },
+                selections: {
+                    undo: __spreadArray([], __read(getSelections()), false),
+                    redo: __spreadArray([], __read(getSelections()), false),
+                },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/cjs/interface/delete-cells-shift-up.d.ts

@@ -0,0 +1,5 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, SelectionAttributes, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnDeleteCellsShiftUpProps } from "../hooks/use-on-delete-cells-shift-up";
+export declare const deleteCellsShiftUp: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeCitations, }: UseOnDeleteCellsShiftUpProps<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+//# sourceMappingURL=delete-cells-shift-up.d.ts.map

package/dist/cjs/interface/delete-cells-shift-up.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-cells-shift-up.d.ts","sourceRoot":"","sources":["../../../interface/delete-cells-shift-up.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EAEb,aAAa,EACd,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EACV,QAAQ,EACR,mBAAmB,EACnB,KAAK,EACN,MAAM,2BAA2B,CAAC;AASnC,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAC;AAG1F,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,gQAgBrE,4BAA4B,CAAC,CAAC,EAAE,CAAC,CAAC,MAEjC,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,SAuKnD,CAAC"}

package/dist/cjs/interface/delete-cells-shift-up.js

@@ -0,0 +1,152 @@
+import { __read, __spreadArray, __values } from "tslib";
+import { selectionFromActiveCell } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { collectUniqueDependentsForRange, moveFormulaAtPosition, } from "../api/dependency";
+import { createSheetDraft } from "../api/immer-utils";
+import { moveMergedCells } from "../api/merges";
+export var deleteCellsShiftUp = function (_a) {
+    var rowCount = _a.rowCount, columnCount = _a.columnCount, locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getActiveCell = _a.getActiveCell, getSelections = _a.getSelections, getDependents = _a.getDependents, createHistory = _a.createHistory, enqueueGraphOperation = _a.enqueueGraphOperation, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeCitations = _a.onChangeCitations;
+    return function (sheetId, activeCell, selections) {
+        var saveHistory = createHistory();
+        var recalcCells = new Map();
+        var finalSelections = selections.length
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        var selection = finalSelections[finalSelections.length - 1];
+        var count = selection.range.endRowIndex - selection.range.startRowIndex + 1;
+        enqueueStructureChange === null || enqueueStructureChange === void 0 ? void 0 : enqueueStructureChange({
+            kind: "delete-cells-shift-up",
+            sheetId: sheetId,
+            startRowIndex: selection.range.startRowIndex,
+            endRowIndex: selection.range.endRowIndex,
+            startColumnIndex: selection.range.startColumnIndex,
+            endColumnIndex: selection.range.endColumnIndex,
+            rowCount: rowCount,
+        });
+        // Update merges on sheet rows
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var sheet = draft.find(function (s) { return s.sheetId === sheetId; });
+                if (sheet === null || sheet === void 0 ? void 0 : sheet.merges) {
+                    for (var rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                        sheet.merges = moveMergedCells(sheet.merges, "row-remove", rowIndex);
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ sheets: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Update citations - delete if overlapping, shift back if after
+        onChangeCitations === null || onChangeCitations === void 0 ? void 0 : onChangeCitations(function (prevCitations) {
+            var _a = __read(produceWithPatches(prevCitations, function (draft) {
+                var deleteRowStart = selection.range.startRowIndex;
+                var deleteRowEnd = selection.range.endRowIndex;
+                var deleteColStart = selection.range.startColumnIndex;
+                var deleteColEnd = selection.range.endColumnIndex;
+                var shiftAmount = deleteRowEnd - deleteRowStart + 1;
+                for (var idx = draft.length - 1; idx >= 0; idx--) {
+                    var citation = draft[idx];
+                    if (citation.range.sheetId !== sheetId)
+                        continue;
+                    var colsOverlap = !(citation.range.endColumnIndex < deleteColStart || citation.range.startColumnIndex > deleteColEnd);
+                    if (colsOverlap) {
+                        var rowsOverlap = !(citation.range.endRowIndex < deleteRowStart || citation.range.startRowIndex > deleteRowEnd);
+                        if (rowsOverlap) {
+                            draft.splice(idx, 1);
+                        }
+                        else if (citation.range.startRowIndex > deleteRowEnd) {
+                            citation.range.startRowIndex -= shiftAmount;
+                            citation.range.endRowIndex -= shiftAmount;
+                        }
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ citations: { patches: patches, inversePatches: inversePatches } });
+            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;
+                var _b, _c, _d, _e;
+                var movedKeys = new Set();
+                var totalRows = (_c = (_b = draft[sheetId]) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
+                // Collect unique dependents across the vertical band
+                var sourceRange = {
+                    startRowIndex: selection.range.startRowIndex,
+                    endRowIndex: totalRows,
+                    startColumnIndex: selection.range.startColumnIndex,
+                    endColumnIndex: selection.range.endColumnIndex,
+                };
+                var dependents = collectUniqueDependentsForRange({
+                    draft: draft,
+                    sheetId: sheetId,
+                    sourceRange: sourceRange,
+                    getDependents: getDependents,
+                });
+                try {
+                    for (var _f = __values(dependents.values()), _g = _f.next(); !_g.done; _g = _f.next()) {
+                        var pos = _g.value;
+                        moveFormulaAtPosition({
+                            draft: draft,
+                            position: pos,
+                            enqueueCalculation: enqueueCalculation,
+                            enqueueGraphOperation: enqueueGraphOperation,
+                            recalcCells: recalcCells,
+                            movedKeys: movedKeys,
+                            rowDelta: -count,
+                            columnDelta: 0,
+                            sourceRange: sourceRange,
+                            locale: locale,
+                            rowCount: rowCount,
+                            columnCount: columnCount,
+                            cellXfsRegistry: cellXfsRegistry,
+                            sharedStringRegistry: sharedStringRegistry,
+                        });
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                // Adjust formulas in the band and shift values up
+                for (var rowIndex = selection.range.startRowIndex; rowIndex < totalRows; rowIndex++) {
+                    var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    for (var columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                        moveFormulaAtPosition({
+                            draft: draft,
+                            position: { sheetId: sheetId, rowIndex: rowIndex, columnIndex: columnIndex },
+                            enqueueCalculation: enqueueCalculation,
+                            enqueueGraphOperation: enqueueGraphOperation,
+                            recalcCells: recalcCells,
+                            movedKeys: movedKeys,
+                            rowDelta: -count,
+                            columnDelta: 0,
+                            sourceRange: sourceRange,
+                            locale: locale,
+                            rowCount: rowCount,
+                            columnCount: columnCount,
+                            cellXfsRegistry: cellXfsRegistry,
+                            sharedStringRegistry: sharedStringRegistry,
+                        });
+                        currentSheet[rowIndex].values[columnIndex] =
+                            (_e = (_d = currentSheet[rowIndex + count]) === null || _d === void 0 ? void 0 : _d.values) === null || _e === void 0 ? void 0 : _e[columnIndex];
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                activeCell: { undo: getActiveCell(), redo: getActiveCell() },
+                selections: {
+                    undo: __spreadArray([], __read(getSelections()), false),
+                    redo: __spreadArray([], __read(getSelections()), false),
+                },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/cjs/interface/delete-cells.d.ts

@@ -0,0 +1,6 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, SelectionAttributes, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnDeleteProps } from "../hooks/use-on-delete";
+export type ClearType = "all" | "contents" | "formats";
+export declare const deleteCells: <T extends CellData, S extends Sheet>({ locale, rowCount, cellXfsRegistry, sharedStringRegistry, getDataValidationById, getDependents, getDataRowCount, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCitations, onChangeActiveCell, enqueueCalculation, enqueueStructureChange, createHistory, isArrayFormula, getRowHeight, }: UseOnDeleteProps<T, S>) => (sheetId: number, cell: CellInterface, selections: SelectionArea<SelectionAttributes>[], clearType?: ClearType) => void;
+//# sourceMappingURL=delete-cells.d.ts.map

package/dist/cjs/interface/delete-cells.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-cells.d.ts","sourceRoot":"","sources":["../../../interface/delete-cells.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EAEb,aAAa,EACd,MAAM,4BAA4B,CAAC;AAGpC,OAAO,KAAK,EACV,QAAQ,EAER,mBAAmB,EACnB,KAAK,EACN,MAAM,2BAA2B,CAAC;AAKnC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAI/D,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,UAAU,GAAG,SAAS,CAAC;AAEvD,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,wSAkB9D,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,MAErB,SAAS,MAAM,EACf,MAAM,aAAa,EACnB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,EAChD,YAAW,SAAsB,SAwPpC,CAAC"}

package/dist/cjs/interface/delete-cells.js

@@ -0,0 +1,231 @@
+import { __assign, __read, __values } from "tslib";
+import { areaInsideArea } from "@rowsncolumns/utils";
+import { selectionFromActiveCell } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+export var deleteCells = function (_a) {
+    var locale = _a.locale, rowCount = _a.rowCount, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getDataValidationById = _a.getDataValidationById, getDependents = _a.getDependents, getDataRowCount = _a.getDataRowCount, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeTables = _a.onChangeTables, onChangeCitations = _a.onChangeCitations, onChangeActiveCell = _a.onChangeActiveCell, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, createHistory = _a.createHistory, isArrayFormula = _a.isArrayFormula, getRowHeight = _a.getRowHeight;
+    return function (sheetId, cell, selections, clearType) {
+        var e_1, _a;
+        if (clearType === void 0) { clearType = "contents"; }
+        var shouldClearContents = clearType === "contents" || clearType === "all";
+        var shouldClearFormats = clearType === "formats" || clearType === "all";
+        var finalSelections = selections.length
+            ? selections
+            : selectionFromActiveCell(cell);
+        var saveHistory = createHistory();
+        var maxRowCount = getDataRowCount();
+        // Bulk writes go through `onChangeSheetData` directly, so the
+        // calculator's per-cell `invalidateCacheForCell` (which only fires on
+        // recompute) never runs for the cleared positions. Invalidate the
+        // union of the cleared rectangles up front; dependents recalc next
+        // will hit fresh range data.
+        if (shouldClearContents) {
+            try {
+                for (var finalSelections_1 = __values(finalSelections), finalSelections_1_1 = finalSelections_1.next(); !finalSelections_1_1.done; finalSelections_1_1 = finalSelections_1.next()) {
+                    var selection = finalSelections_1_1.value;
+                    enqueueStructureChange === null || enqueueStructureChange === void 0 ? void 0 : enqueueStructureChange({
+                        kind: "invalidate-range",
+                        sheetId: sheetId,
+                        startRowIndex: selection.range.startRowIndex,
+                        endRowIndex: Math.min(maxRowCount !== null && maxRowCount !== void 0 ? maxRowCount : rowCount, selection.range.endRowIndex),
+                        startColumnIndex: selection.range.startColumnIndex,
+                        endColumnIndex: selection.range.endColumnIndex,
+                    });
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (finalSelections_1_1 && !finalSelections_1_1.done && (_a = finalSelections_1.return)) _a.call(finalSelections_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        // We need to track this for history. Precedent cells
+        var recalcCells = new Map();
+        // Create a cell
+        var sheetCell = new SheetCell();
+        // Update sheet data
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_2, _a;
+                var _b;
+                try {
+                    for (var finalSelections_2 = __values(finalSelections), finalSelections_2_1 = finalSelections_2.next(); !finalSelections_2_1.done; finalSelections_2_1 = finalSelections_2.next()) {
+                        var selection = finalSelections_2_1.value;
+                        for (var rowIndex = selection.range.startRowIndex; rowIndex <=
+                            Math.min(maxRowCount !== null && maxRowCount !== void 0 ? maxRowCount : rowCount, selection.range.endRowIndex); rowIndex++) {
+                            var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                            var columnCount = currentSheet[rowIndex].values.length;
+                            for (var columnIndex = selection.range.startColumnIndex; columnIndex <=
+                                Math.min(columnCount, selection.range.endColumnIndex); columnIndex++) {
+                                var cellData = (_b = currentSheet[rowIndex].values) === null || _b === void 0 ? void 0 : _b[columnIndex];
+                                // Create a cell
+                                sheetCell.assign(sheetId, cell, cellData, {
+                                    locale: locale,
+                                    getDataValidationById: getDataValidationById,
+                                    cellXfsRegistry: cellXfsRegistry,
+                                    sharedStringRegistry: sharedStringRegistry,
+                                });
+                                // Check if its a formula
+                                var isFormula = sheetCell.isFormula();
+                                // Clear based on clearType. The Delete key is the one
+                                // surface where clearing an already-empty cell also strips
+                                // its data-validation stamp (double-delete).
+                                if (shouldClearContents) {
+                                    sheetCell.deleteContents({ clearDataValidation: true });
+                                }
+                                if (shouldClearFormats) {
+                                    sheetCell.deleteUserEnteredFormat();
+                                }
+                                // Set cell data
+                                if (sheetCell.isModified) {
+                                    currentSheet[rowIndex].values[columnIndex] =
+                                        sheetCell.getCellData();
+                                    // Unregister
+                                    cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.unRegister(sheetCell);
+                                }
+                                // Enqueue
+                                if (
+                                // Check if there are any cells that depend on this
+                                // We also need to check if this is a formula cell
+                                getDependents({ rowIndex: rowIndex, columnIndex: columnIndex, sheetId: sheetId }).length ||
+                                    isFormula ||
+                                    (
+                                    // Check if source formula was an array array
+                                    isArrayFormula === null || isArrayFormula === void 0 ? void 0 : isArrayFormula({
+                                        rowIndex: rowIndex,
+                                        columnIndex: columnIndex,
+                                        sheetId: sheetId,
+                                    }))) {
+                                    enqueueCalculation({
+                                        position: { rowIndex: rowIndex, columnIndex: columnIndex, sheetId: sheetId },
+                                        type: "remove",
+                                    });
+                                    // Add to recalc cells
+                                    recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                                        rowIndex: rowIndex,
+                                        columnIndex: columnIndex,
+                                        sheetId: sheetId,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (finalSelections_2_1 && !finalSelections_2_1.done && (_a = finalSelections_2.return)) _a.call(finalSelections_2);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheetData: {
+                    inversePatches: inversePatches,
+                    patches: patches,
+                },
+                activeCell: { undo: cell, redo: cell },
+                selections: { undo: selections, redo: selections },
+                sheetId: { undo: sheetId, redo: sheetId },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+        // Update tables
+        onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTables) {
+            var _a = __read(produceWithPatches(prevTables, function (draft) {
+                var tableIndex = draft.findIndex(function (table) {
+                    return table.sheetId === sheetId &&
+                        selections.some(function (sel) { return areaInsideArea(table.range, sel.range); });
+                });
+                if (tableIndex !== -1) {
+                    draft.splice(tableIndex, 1);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                tables: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update citations - remove citations that overlap with deleted cells
+        onChangeCitations === null || onChangeCitations === void 0 ? void 0 : onChangeCitations(function (prevCitations) {
+            var _a = __read(produceWithPatches(prevCitations, function (draft) {
+                var _loop_1 = function (idx) {
+                    var citation = draft[idx];
+                    // Check if citation is on the same sheet and overlaps with any deleted selection
+                    if (citation.range.sheetId === sheetId &&
+                        finalSelections.some(function (sel) {
+                            return areaInsideArea(citation.range, sel.range);
+                        })) {
+                        // Remove citation since its referenced cells are being deleted
+                        draft.splice(idx, 1);
+                    }
+                };
+                for (var idx = draft.length - 1; idx >= 0; idx--) {
+                    _loop_1(idx);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                citations: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update banded cells
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var e_3, _a;
+                var _b, _c, _d, _e, _f;
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                if (sheet) {
+                    var _loop_2 = function (selection) {
+                        for (var rowIndex = selection.range.startRowIndex; rowIndex <=
+                            Math.min(maxRowCount !== null && maxRowCount !== void 0 ? maxRowCount : rowCount, selection.range.endRowIndex); rowIndex++) {
+                            var isRowResizedByUser = !!((_c = (_b = sheet === null || sheet === void 0 ? void 0 : sheet.rowMetadata) === null || _b === void 0 ? void 0 : _b[rowIndex]) === null || _c === void 0 ? void 0 : _c.resizedByUser);
+                            if (!isRowResizedByUser) {
+                                var currentRowHeight = (_d = getRowHeight === null || getRowHeight === void 0 ? void 0 : getRowHeight(sheetId, rowIndex, 
+                                // Exclude columns within the selection
+                                function (colIndex) {
+                                    return colIndex >= selection.range.startColumnIndex &&
+                                        colIndex <= selection.range.endColumnIndex;
+                                })) !== null && _d !== void 0 ? _d : 0;
+                                if (currentRowHeight !== 0 &&
+                                    currentRowHeight !== ((_f = (_e = sheet.rowMetadata) === null || _e === void 0 ? void 0 : _e[rowIndex]) === null || _f === void 0 ? void 0 : _f.size)) {
+                                    if (!sheet.rowMetadata) {
+                                        sheet.rowMetadata = [];
+                                    }
+                                    sheet.rowMetadata[rowIndex] = __assign(__assign({}, sheet.rowMetadata[rowIndex]), { size: currentRowHeight, resizedByUser: false });
+                                }
+                            }
+                        }
+                    };
+                    try {
+                        // Adjust row height
+                        for (var finalSelections_3 = __values(finalSelections), finalSelections_3_1 = finalSelections_3.next(); !finalSelections_3_1.done; finalSelections_3_1 = finalSelections_3.next()) {
+                            var selection = finalSelections_3_1.value;
+                            _loop_2(selection);
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (finalSelections_3_1 && !finalSelections_3_1.done && (_a = finalSelections_3.return)) _a.call(finalSelections_3);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Trigger a re-render
+        onChangeActiveCell(sheetId, __assign({}, cell));
+    };
+};

package/dist/cjs/interface/delete-column.d.ts

@@ -0,0 +1,4 @@
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnDeleteColumnProps } from "../hooks/use-on-delete-column";
+export declare const deleteColumn: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getSelections, getDependents, getGraphNodes, getGraphNodesInSheet, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeActiveCell, onChangeSelections, onChangeConditionalFormats, onChangeDataValidations, onChangeCitations, onChangePivotTables, }: UseOnDeleteColumnProps<T, S>) => (sheetId: number, columnIndexes: number[]) => void;
+//# sourceMappingURL=delete-column.d.ts.map

package/dist/cjs/interface/delete-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-column.d.ts","sourceRoot":"","sources":["../../../interface/delete-column.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AASjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAG5E,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,qbAyB/D,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC,MACrB,SAAS,MAAM,EAAE,eAAe,MAAM,EAAE,SA8TjD,CAAC"}