@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,306 @@
+import { __assign, __read, __spreadArray, __values } from "tslib";
+import { Direction } from "@rowsncolumns/common-types";
+import { produceWithPatches } from "immer";
+import { shrinkMergesOnColumnDelete } from "../api/merges";
+import { shiftPivotsOnDelete } from "../api/pivot-range";
+import { updateRangedRulesOnStructuralChange } from "../api/range-rule-helpers";
+import { updateSheetRangeOnDelete } from "../api/range";
+import { moveFilterView } from "../api/selection";
+import { updateFormulasForStructuralChange } from "../api/structural-formula-update";
+export var deleteColumn = function (_a) {
+    var rowCount = _a.rowCount, columnCount = _a.columnCount, locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getSheetName = _a.getSheetName, getActiveCell = _a.getActiveCell, getSelections = _a.getSelections, getDependents = _a.getDependents, getGraphNodes = _a.getGraphNodes, getGraphNodesInSheet = _a.getGraphNodesInSheet, createHistory = _a.createHistory, enqueueGraphOperation = _a.enqueueGraphOperation, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeTables = _a.onChangeTables, onChangeActiveCell = _a.onChangeActiveCell, onChangeSelections = _a.onChangeSelections, onChangeConditionalFormats = _a.onChangeConditionalFormats, onChangeDataValidations = _a.onChangeDataValidations, onChangeCitations = _a.onChangeCitations, onChangePivotTables = _a.onChangePivotTables;
+    return function (sheetId, columnIndexes) {
+        if (!columnIndexes.length)
+            return;
+        var sortedColumnIndexes = __spreadArray([], __read(columnIndexes), false).sort(function (a, b) { return a - b; });
+        var minColumnIndex = sortedColumnIndexes[0];
+        var maxColumnIndex = sortedColumnIndexes[sortedColumnIndexes.length - 1];
+        var count = sortedColumnIndexes.length;
+        var saveHistory = createHistory();
+        enqueueStructureChange === null || enqueueStructureChange === void 0 ? void 0 : enqueueStructureChange({
+            kind: "delete-column",
+            sheetId: sheetId,
+            index: minColumnIndex,
+            count: count,
+            rowCount: rowCount,
+            columnCount: columnCount,
+        });
+        var recalcCells = new Map();
+        var activeCell = getActiveCell();
+        var selections = getSelections();
+        var newColumnCount = Math.max(1, columnCount - count);
+        // NOTE: contiguity assumption — see delete-row.ts.
+        var inDeletedColumns = activeCell.columnIndex >= minColumnIndex &&
+            activeCell.columnIndex <= maxColumnIndex;
+        var nextActiveColumnIndex = activeCell.columnIndex;
+        if (inDeletedColumns) {
+            nextActiveColumnIndex = Math.max(1, minColumnIndex - 1);
+        }
+        else if (activeCell.columnIndex > maxColumnIndex) {
+            nextActiveColumnIndex = Math.max(1, activeCell.columnIndex - count);
+        }
+        if (nextActiveColumnIndex > newColumnCount) {
+            nextActiveColumnIndex = newColumnCount;
+        }
+        var nextActiveCell = nextActiveColumnIndex === activeCell.columnIndex
+            ? activeCell
+            : __assign(__assign({}, activeCell), { columnIndex: nextActiveColumnIndex });
+        var fallbackSelectionColumnIndex = nextActiveCell.columnIndex;
+        var nextSelections = selections.map(function (selection) {
+            if (!selection.range)
+                return selection;
+            var updatedRange = updateSheetRangeOnDelete(__assign(__assign({}, selection.range), { sheetId: sheetId }), "column", minColumnIndex, count, sheetId);
+            if (updatedRange) {
+                return __assign(__assign({}, selection), { range: __assign(__assign({}, selection.range), { startColumnIndex: updatedRange.startColumnIndex, endColumnIndex: updatedRange.endColumnIndex }) });
+            }
+            return __assign(__assign({}, selection), { range: __assign(__assign({}, selection.range), { startColumnIndex: fallbackSelectionColumnIndex, endColumnIndex: fallbackSelectionColumnIndex }) });
+        });
+        // Tables: shift / shrink, plus column-specific filter+sort spec updates
+        // and table-column splice for partially-overlapped tables.
+        onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTables) {
+            var _a = __read(produceWithPatches(prevTables, function (draft) {
+                var e_1, _a, e_2, _b, e_3, _c;
+                var _d;
+                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 (minColumnIndex < table.range.startColumnIndex) {
+                            moveFilterView(table, count, Direction.Left);
+                        }
+                        if (minColumnIndex >= table.range.startColumnIndex &&
+                            minColumnIndex <= table.range.endColumnIndex) {
+                            if (table.filterSpecs) {
+                                try {
+                                    for (var _e = (e_2 = void 0, __values(table.filterSpecs)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                        var spec = _f.value;
+                                        if (spec.columnIndex >= minColumnIndex) {
+                                            spec.columnIndex -= 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; }
+                                }
+                            }
+                            if (table.sortSpecs) {
+                                try {
+                                    for (var _g = (e_3 = void 0, __values(table.sortSpecs)), _h = _g.next(); !_h.done; _h = _g.next()) {
+                                        var spec = _h.value;
+                                        if (spec.dimensionIndex >= minColumnIndex) {
+                                            spec.dimensionIndex -= count;
+                                        }
+                                    }
+                                }
+                                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                                finally {
+                                    try {
+                                        if (_h && !_h.done && (_c = _g.return)) _c.call(_g);
+                                    }
+                                    finally { if (e_3) throw e_3.error; }
+                                }
+                            }
+                            var columnArrayIndex = minColumnIndex - table.range.startColumnIndex;
+                            (_d = table.columns) === null || _d === void 0 ? void 0 : _d.splice(columnArrayIndex, count);
+                            var delta = Math.min(table.range.endColumnIndex - minColumnIndex + 1, count);
+                            table.range.endColumnIndex -= delta;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (draft_1_1 && !draft_1_1.done && (_a = draft_1.return)) _a.call(draft_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ tables: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Data validations
+        onChangeDataValidations === null || onChangeDataValidations === void 0 ? void 0 : onChangeDataValidations(function (prevValidations) {
+            var _a = __read(produceWithPatches(prevValidations, function (draft) {
+                updateRangedRulesOnStructuralChange(draft, "delete", "column", minColumnIndex, count, sheetId);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ dataValidations: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Conditional formats
+        onChangeConditionalFormats === null || onChangeConditionalFormats === void 0 ? void 0 : onChangeConditionalFormats(function (prevConditionalFormats) {
+            var _a = __read(produceWithPatches(prevConditionalFormats, function (draft) {
+                updateRangedRulesOnStructuralChange(draft, "delete", "column", minColumnIndex, count, sheetId);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ conditionalFormats: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Shift pivot tables.
+        onChangePivotTables === null || onChangePivotTables === void 0 ? void 0 : onChangePivotTables(function (prevPivots) {
+            var _a = __read(produceWithPatches(prevPivots, function (draft) {
+                shiftPivotsOnDelete(draft, sheetId, "column", minColumnIndex, count);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ pivotTables: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Citations
+        onChangeCitations === null || onChangeCitations === void 0 ? void 0 : onChangeCitations(function (prevCitations) {
+            var _a = __read(produceWithPatches(prevCitations, function (draft) {
+                var deleteEnd = minColumnIndex + count - 1;
+                for (var idx = draft.length - 1; idx >= 0; idx--) {
+                    var citation = draft[idx];
+                    if (citation.range.sheetId !== sheetId)
+                        continue;
+                    var citationStart = citation.range.startColumnIndex;
+                    var citationEnd = citation.range.endColumnIndex;
+                    if (citationStart <= deleteEnd && citationEnd >= minColumnIndex) {
+                        draft.splice(idx, 1);
+                    }
+                    else if (citationStart > deleteEnd) {
+                        citation.range.startColumnIndex -= count;
+                        citation.range.endColumnIndex -= count;
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ citations: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Sheet metadata
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var e_4, _a, e_5, _b, e_6, _c;
+                var _d;
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                if (!sheet)
+                    return;
+                if (sheet.columnMetadata) {
+                    sheet.columnMetadata.splice(minColumnIndex, count);
+                }
+                if (sheet.basicFilter) {
+                    var _e = sheet.basicFilter.range, startColumnIndex = _e.startColumnIndex, endColumnIndex = _e.endColumnIndex;
+                    if (minColumnIndex < startColumnIndex) {
+                        moveFilterView(sheet.basicFilter, count, Direction.Left);
+                    }
+                    if (minColumnIndex > startColumnIndex &&
+                        minColumnIndex <= endColumnIndex) {
+                        if (sheet.basicFilter.filterSpecs) {
+                            try {
+                                for (var _f = __values(sheet.basicFilter.filterSpecs), _g = _f.next(); !_g.done; _g = _f.next()) {
+                                    var spec = _g.value;
+                                    if (spec.columnIndex >= minColumnIndex) {
+                                        spec.columnIndex -= count;
+                                    }
+                                }
+                            }
+                            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                            finally {
+                                try {
+                                    if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+                                }
+                                finally { if (e_4) throw e_4.error; }
+                            }
+                        }
+                        if (sheet.basicFilter.sortSpecs) {
+                            try {
+                                for (var _h = __values(sheet.basicFilter.sortSpecs), _j = _h.next(); !_j.done; _j = _h.next()) {
+                                    var spec = _j.value;
+                                    if (spec.dimensionIndex >= minColumnIndex) {
+                                        spec.dimensionIndex -= count;
+                                    }
+                                }
+                            }
+                            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                            finally {
+                                try {
+                                    if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
+                                }
+                                finally { if (e_5) throw e_5.error; }
+                            }
+                        }
+                        var delta = Math.min(endColumnIndex - minColumnIndex + 1, count);
+                        sheet.basicFilter.range.endColumnIndex -= delta;
+                    }
+                }
+                if (sheet.frozenColumnCount) {
+                    try {
+                        for (var sortedColumnIndexes_1 = __values(sortedColumnIndexes), sortedColumnIndexes_1_1 = sortedColumnIndexes_1.next(); !sortedColumnIndexes_1_1.done; sortedColumnIndexes_1_1 = sortedColumnIndexes_1.next()) {
+                            var columnIndex = sortedColumnIndexes_1_1.value;
+                            if (columnIndex <= sheet.frozenColumnCount) {
+                                sheet.frozenColumnCount--;
+                            }
+                        }
+                    }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                    finally {
+                        try {
+                            if (sortedColumnIndexes_1_1 && !sortedColumnIndexes_1_1.done && (_c = sortedColumnIndexes_1.return)) _c.call(sortedColumnIndexes_1);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                    }
+                }
+                if (sheet.merges) {
+                    sheet.merges = shrinkMergesOnColumnDelete(sheet.merges, minColumnIndex, count);
+                }
+                sheet.columnCount = Math.max(1, ((_d = sheet.columnCount) !== null && _d !== void 0 ? _d : columnCount) - count);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ sheets: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Sheet data: three-pass formula update, then per-row column splice.
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                updateFormulasForStructuralChange({
+                    draft: draft,
+                    axis: "column",
+                    op: "delete",
+                    sheetId: sheetId,
+                    referenceIndex: minColumnIndex,
+                    count: count,
+                    rowCount: rowCount,
+                    columnCount: columnCount,
+                    getDependents: getDependents,
+                    getGraphNodes: getGraphNodes,
+                    getGraphNodesInSheet: getGraphNodesInSheet,
+                    getSheetName: getSheetName,
+                    enqueueCalculation: enqueueCalculation,
+                    enqueueGraphOperation: enqueueGraphOperation,
+                    recalcCells: recalcCells,
+                    locale: locale,
+                    cellXfsRegistry: cellXfsRegistry,
+                    sharedStringRegistry: sharedStringRegistry,
+                });
+                // Splice deleted columns out of each row's values, end-first to
+                // keep indices stable.
+                var sheetRows = draft[sheetId];
+                if (sheetRows) {
+                    for (var rowIndex = 1; rowIndex < sheetRows.length; rowIndex++) {
+                        var row = sheetRows[rowIndex];
+                        if (!(row === null || row === void 0 ? void 0 : row.values))
+                            continue;
+                        for (var i = sortedColumnIndexes.length - 1; i >= 0; i--) {
+                            row.values.splice(sortedColumnIndexes[i], 1);
+                        }
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                selections: {
+                    undo: __spreadArray([], __read(selections), false),
+                    redo: __spreadArray([], __read(nextSelections), false),
+                },
+                activeCell: { undo: activeCell, redo: nextActiveCell },
+            });
+            return nextState;
+        });
+        if (nextActiveCell.columnIndex !== activeCell.columnIndex) {
+            onChangeActiveCell === null || onChangeActiveCell === void 0 ? void 0 : onChangeActiveCell(sheetId, nextActiveCell);
+        }
+        onChangeSelections === null || onChangeSelections === void 0 ? void 0 : onChangeSelections(sheetId, nextSelections);
+    };
+};

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

@@ -0,0 +1,4 @@
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import { type UseOnDeleteRowProps } from "../hooks/use-on-delete-row";
+export declare const deleteRow: <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, }: UseOnDeleteRowProps<T, S>) => (sheetId: number, rowIndexes: number[]) => void;
+//# sourceMappingURL=delete-row.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete-row.d.ts","sourceRoot":"","sources":["../../../interface/delete-row.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AASjE,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAGtE,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,qbAyB5D,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,MAClB,SAAS,MAAM,EAAE,YAAY,MAAM,EAAE,SAqR9C,CAAC"}

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

@@ -0,0 +1,227 @@
+import { __assign, __read, __spreadArray, __values } from "tslib";
+import { Direction } from "@rowsncolumns/common-types";
+import { produceWithPatches } from "immer";
+import { shrinkMergesOnRowDelete } from "../api/merges";
+import { shiftPivotsOnDelete } from "../api/pivot-range";
+import { updateRangedRulesOnStructuralChange } from "../api/range-rule-helpers";
+import { updateSheetRangeOnDelete } from "../api/range";
+import { moveFilterView } from "../api/selection";
+import { updateFormulasForStructuralChange } from "../api/structural-formula-update";
+export var deleteRow = function (_a) {
+    var rowCount = _a.rowCount, columnCount = _a.columnCount, locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getSheetName = _a.getSheetName, getActiveCell = _a.getActiveCell, getSelections = _a.getSelections, getDependents = _a.getDependents, getGraphNodes = _a.getGraphNodes, getGraphNodesInSheet = _a.getGraphNodesInSheet, createHistory = _a.createHistory, enqueueGraphOperation = _a.enqueueGraphOperation, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeTables = _a.onChangeTables, onChangeActiveCell = _a.onChangeActiveCell, onChangeSelections = _a.onChangeSelections, onChangeConditionalFormats = _a.onChangeConditionalFormats, onChangeDataValidations = _a.onChangeDataValidations, onChangeCitations = _a.onChangeCitations, onChangePivotTables = _a.onChangePivotTables;
+    return function (sheetId, rowIndexes) {
+        if (!rowIndexes.length)
+            return;
+        // Don't mutate caller's array.
+        var sortedRowIndexes = __spreadArray([], __read(rowIndexes), false).sort(function (a, b) { return a - b; });
+        var minRowIndex = sortedRowIndexes[0];
+        var maxRowIndex = sortedRowIndexes[sortedRowIndexes.length - 1];
+        var count = sortedRowIndexes.length;
+        var saveHistory = createHistory();
+        enqueueStructureChange === null || enqueueStructureChange === void 0 ? void 0 : enqueueStructureChange({
+            kind: "delete-row",
+            sheetId: sheetId,
+            index: minRowIndex,
+            count: count,
+            rowCount: rowCount,
+            columnCount: columnCount,
+        });
+        var recalcCells = new Map();
+        var activeCell = getActiveCell();
+        var selections = getSelections();
+        var newRowCount = Math.max(1, rowCount - count);
+        // NOTE: this treats `[minRowIndex..maxRowIndex]` as a contiguous block.
+        // Non-contiguous deletes (e.g. rows [2, 5, 10]) currently misclassify
+        // intermediate rows as deleted. Document/track separately.
+        var inDeletedRows = activeCell.rowIndex >= minRowIndex && activeCell.rowIndex <= maxRowIndex;
+        var nextActiveRowIndex = activeCell.rowIndex;
+        if (inDeletedRows) {
+            nextActiveRowIndex = Math.max(1, minRowIndex - 1);
+        }
+        else if (activeCell.rowIndex > maxRowIndex) {
+            nextActiveRowIndex = Math.max(1, activeCell.rowIndex - count);
+        }
+        if (nextActiveRowIndex > newRowCount) {
+            nextActiveRowIndex = newRowCount;
+        }
+        var nextActiveCell = nextActiveRowIndex === activeCell.rowIndex
+            ? activeCell
+            : __assign(__assign({}, activeCell), { rowIndex: nextActiveRowIndex });
+        var fallbackSelectionRowIndex = nextActiveCell.rowIndex;
+        var nextSelections = selections.map(function (selection) {
+            if (!selection.range)
+                return selection;
+            var updatedRange = updateSheetRangeOnDelete(__assign(__assign({}, selection.range), { sheetId: sheetId }), "row", minRowIndex, count, sheetId);
+            if (updatedRange) {
+                return __assign(__assign({}, selection), { range: __assign(__assign({}, selection.range), { startRowIndex: updatedRange.startRowIndex, endRowIndex: updatedRange.endRowIndex }) });
+            }
+            return __assign(__assign({}, selection), { range: __assign(__assign({}, selection.range), { startRowIndex: fallbackSelectionRowIndex, endRowIndex: fallbackSelectionRowIndex }) });
+        });
+        // Tables: shrink/move based on overlap with deletion; drop tables
+        // whose header row is removed.
+        onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTables) {
+            var _a = __read(produceWithPatches(prevTables, function (draft) {
+                for (var idx = draft.length - 1; idx >= 0; idx--) {
+                    var table = draft[idx];
+                    if (table.sheetId !== sheetId)
+                        continue;
+                    var _a = table.range, startRowIndex = _a.startRowIndex, endRowIndex = _a.endRowIndex;
+                    if (minRowIndex < startRowIndex) {
+                        moveFilterView(table, count, Direction.Up);
+                    }
+                    if (minRowIndex >= startRowIndex && minRowIndex <= endRowIndex) {
+                        var delta = Math.min(endRowIndex - minRowIndex + 1, count);
+                        table.range.endRowIndex -= delta;
+                    }
+                    if (startRowIndex >= minRowIndex && startRowIndex <= maxRowIndex) {
+                        draft.splice(idx, 1);
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ tables: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Data validations
+        onChangeDataValidations === null || onChangeDataValidations === void 0 ? void 0 : onChangeDataValidations(function (prevValidations) {
+            var _a = __read(produceWithPatches(prevValidations, function (draft) {
+                updateRangedRulesOnStructuralChange(draft, "delete", "row", minRowIndex, count, sheetId);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ dataValidations: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Conditional formats
+        onChangeConditionalFormats === null || onChangeConditionalFormats === void 0 ? void 0 : onChangeConditionalFormats(function (prevConditionalFormats) {
+            var _a = __read(produceWithPatches(prevConditionalFormats, function (draft) {
+                updateRangedRulesOnStructuralChange(draft, "delete", "row", minRowIndex, count, sheetId);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ conditionalFormats: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Shift pivot tables: ranges shrink/shift; targetPosition anchors to
+        // the start of the deletion when its row falls inside the deletion.
+        onChangePivotTables === null || onChangePivotTables === void 0 ? void 0 : onChangePivotTables(function (prevPivots) {
+            var _a = __read(produceWithPatches(prevPivots, function (draft) {
+                shiftPivotsOnDelete(draft, sheetId, "row", minRowIndex, count);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ pivotTables: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Citations: drop if overlapping with deletion, shift up if entirely
+        // after.
+        onChangeCitations === null || onChangeCitations === void 0 ? void 0 : onChangeCitations(function (prevCitations) {
+            var _a = __read(produceWithPatches(prevCitations, function (draft) {
+                var deleteEnd = minRowIndex + count - 1;
+                for (var idx = draft.length - 1; idx >= 0; idx--) {
+                    var citation = draft[idx];
+                    if (citation.range.sheetId !== sheetId)
+                        continue;
+                    var citationStart = citation.range.startRowIndex;
+                    var citationEnd = citation.range.endRowIndex;
+                    if (citationStart <= deleteEnd && citationEnd >= minRowIndex) {
+                        draft.splice(idx, 1);
+                    }
+                    else if (citationStart > deleteEnd) {
+                        citation.range.startRowIndex -= count;
+                        citation.range.endRowIndex -= count;
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ citations: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Sheet metadata
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var e_1, _a;
+                var _b;
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                if (!sheet)
+                    return;
+                if (sheet.rowMetadata) {
+                    sheet.rowMetadata.splice(minRowIndex, count);
+                }
+                if (sheet.basicFilter) {
+                    var _c = sheet.basicFilter.range, startRowIndex = _c.startRowIndex, endRowIndex = _c.endRowIndex;
+                    if (minRowIndex < startRowIndex) {
+                        moveFilterView(sheet.basicFilter, count, Direction.Up);
+                    }
+                    if (minRowIndex > startRowIndex && minRowIndex <= endRowIndex) {
+                        var delta = Math.min(endRowIndex - minRowIndex + 1, count);
+                        sheet.basicFilter.range.endRowIndex -= delta;
+                    }
+                    if (sheet.basicFilter.range.startRowIndex >= minRowIndex &&
+                        sheet.basicFilter.range.startRowIndex <= maxRowIndex) {
+                        delete sheet.basicFilter;
+                    }
+                }
+                if (sheet.frozenRowCount) {
+                    try {
+                        for (var sortedRowIndexes_1 = __values(sortedRowIndexes), sortedRowIndexes_1_1 = sortedRowIndexes_1.next(); !sortedRowIndexes_1_1.done; sortedRowIndexes_1_1 = sortedRowIndexes_1.next()) {
+                            var rowIndex = sortedRowIndexes_1_1.value;
+                            if (rowIndex <= sheet.frozenRowCount) {
+                                sheet.frozenRowCount--;
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (sortedRowIndexes_1_1 && !sortedRowIndexes_1_1.done && (_a = sortedRowIndexes_1.return)) _a.call(sortedRowIndexes_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+                if (sheet.merges) {
+                    sheet.merges = shrinkMergesOnRowDelete(sheet.merges, minRowIndex, count);
+                }
+                sheet.rowCount = Math.max(1, ((_b = sheet.rowCount) !== null && _b !== void 0 ? _b : rowCount) - count);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ sheets: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Sheet data: three-pass formula update, then splice the rows out.
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var _a;
+                updateFormulasForStructuralChange({
+                    draft: draft,
+                    axis: "row",
+                    op: "delete",
+                    sheetId: sheetId,
+                    referenceIndex: minRowIndex,
+                    count: count,
+                    rowCount: rowCount,
+                    columnCount: columnCount,
+                    getDependents: getDependents,
+                    getGraphNodes: getGraphNodes,
+                    getGraphNodesInSheet: getGraphNodesInSheet,
+                    getSheetName: getSheetName,
+                    enqueueCalculation: enqueueCalculation,
+                    enqueueGraphOperation: enqueueGraphOperation,
+                    recalcCells: recalcCells,
+                    locale: locale,
+                    cellXfsRegistry: cellXfsRegistry,
+                    sharedStringRegistry: sharedStringRegistry,
+                });
+                // Splice from the end so indices don't shift mid-loop.
+                for (var i = sortedRowIndexes.length - 1; i >= 0; i--) {
+                    (_a = draft[sheetId]) === null || _a === void 0 ? void 0 : _a.splice(sortedRowIndexes[i], 1);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                activeCell: { undo: activeCell, redo: nextActiveCell },
+                selections: {
+                    undo: __spreadArray([], __read(selections), false),
+                    redo: __spreadArray([], __read(nextSelections), false),
+                },
+            });
+            return nextState;
+        });
+        if (nextActiveCell.rowIndex !== activeCell.rowIndex) {
+            onChangeActiveCell === null || onChangeActiveCell === void 0 ? void 0 : onChangeActiveCell(sheetId, nextActiveCell);
+        }
+        onChangeSelections === null || onChangeSelections === void 0 ? void 0 : onChangeSelections(sheetId, nextSelections);
+    };
+};

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

@@ -0,0 +1,4 @@
+import { type CellData, type Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnDeleteSheetProps } from "../hooks/use-on-delete-sheet";
+export declare const deleteSheet: <T extends CellData, S extends Sheet>({ sheets, onChangeSheetData, onChangeActiveSheet, onChangeSheets, createHistory, enqueueGraphOperation, }: UseOnDeleteSheetProps<T, S>) => (sheetId: number) => void;
+//# sourceMappingURL=delete-sheet.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete-sheet.d.ts","sourceRoot":"","sources":["../../../interface/delete-sheet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAKtE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAG1E,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,2GAO9D,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,MACpB,SAAS,MAAM,SAkGxB,CAAC"}

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

@@ -0,0 +1,81 @@
+import { __read } from "tslib";
+import { sortSheetsByIndex } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { createSheetCellIdentifier } from "../api/formula";
+export var deleteSheet = function (_a) {
+    var sheets = _a.sheets, onChangeSheetData = _a.onChangeSheetData, onChangeActiveSheet = _a.onChangeActiveSheet, onChangeSheets = _a.onChangeSheets, createHistory = _a.createHistory, enqueueGraphOperation = _a.enqueueGraphOperation;
+    return function (sheetId) {
+        var saveHistory = createHistory();
+        var sortedSheets = sortSheetsByIndex(sheets).filter(function (sheet) { return !sheet.hidden; });
+        // Cannot delete the last sheet
+        if (sortedSheets.length <= 1) {
+            console.error("Cannot delete the last sheet");
+            return;
+        }
+        var index = sortedSheets.findIndex(function (sheet) { return sheet.sheetId === sheetId; });
+        if (index === -1) {
+            console.error("Sheet ".concat(sheetId, " not found"));
+            return;
+        }
+        var prevSheetId = index === 0
+            ? sortedSheets[index + 1].sheetId
+            : sortedSheets[Math.max(0, index - 1)].sheetId;
+        var recalcCells = new Map();
+        // Switch to new sheet
+        onChangeActiveSheet(prevSheetId);
+        // Update sheets
+        onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var idx = draft.findIndex(function (sheet) { return sheet.sheetId === sheetId; });
+                if (idx !== -1) {
+                    draft.splice(idx, 1);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save sheets history
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+                sheetId: { undo: sheetId, redo: prevSheetId },
+            });
+            return nextState;
+        });
+        // Add cells to recalc
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var _a, _b;
+                var targetSheetData = draft[sheetId];
+                if (!targetSheetData) {
+                    return;
+                }
+                for (var row in targetSheetData) {
+                    for (var col in (_b = (_a = targetSheetData[row]) === null || _a === void 0 ? void 0 : _a.values) !== null && _b !== void 0 ? _b : []) {
+                        var rowIndex = Number(row);
+                        var columnIndex = Number(col);
+                        // Trigger recalc
+                        enqueueGraphOperation({
+                            type: "remove",
+                            position: {
+                                rowIndex: rowIndex,
+                                columnIndex: columnIndex,
+                                sheetId: sheetId,
+                            },
+                        });
+                        // Undo cells
+                        recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                            rowIndex: rowIndex,
+                            columnIndex: columnIndex,
+                            sheetId: sheetId,
+                        });
+                    }
+                }
+                // Remove sheet id from sheetdata
+                delete draft[sheetId];
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save sheets history
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+    };
+};

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

@@ -0,0 +1,4 @@
+import type { CellData, Sheet, TableView } from "@rowsncolumns/spreadsheet";
+import type { UseOnTableProps } from "../hooks/use-on-table";
+export declare const deleteTableColumn: <T extends CellData, S extends Sheet>({ columnCount, rowCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, createHistory, onChangeTables, onChangeSheets, onChangeSheetData, enqueueCalculation, enqueueStructureChange, enqueueGraphOperation, getDependents, }: Pick<UseOnTableProps<T, S>, "columnCount" | "rowCount" | "locale" | "cellXfsRegistry" | "sharedStringRegistry" | "getSheetName" | "createHistory" | "onChangeTables" | "onChangeSheets" | "onChangeSheetData" | "enqueueCalculation" | "enqueueStructureChange" | "enqueueGraphOperation" | "getDependents">) => (tableView: TableView, dimensionIndex: number) => void;
+//# sourceMappingURL=delete-table-column.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete-table-column.d.ts","sourceRoot":"","sources":["../../../interface/delete-table-column.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAY5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAI7D,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,6OAepE,IAAI,CACL,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EACnB,aAAa,GACb,UAAU,GACV,QAAQ,GACR,iBAAiB,GACjB,sBAAsB,GACtB,cAAc,GACd,eAAe,GACf,gBAAgB,GAChB,gBAAgB,GAChB,mBAAmB,GACnB,oBAAoB,GACpB,wBAAwB,GACxB,uBAAuB,GACvB,eAAe,CAClB,MACS,WAAW,SAAS,EAAE,gBAAgB,MAAM,SA4VrD,CAAC"}