@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,138 @@
+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 const deleteCellsShiftUp = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeCitations, }) => {
+    return (sheetId, activeCell, selections) => {
+        const saveHistory = createHistory();
+        const recalcCells = new Map();
+        const finalSelections = selections.length
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        const selection = finalSelections[finalSelections.length - 1];
+        const count = selection.range.endRowIndex - selection.range.startRowIndex + 1;
+        enqueueStructureChange?.({
+            kind: "delete-cells-shift-up",
+            sheetId,
+            startRowIndex: selection.range.startRowIndex,
+            endRowIndex: selection.range.endRowIndex,
+            startColumnIndex: selection.range.startColumnIndex,
+            endColumnIndex: selection.range.endColumnIndex,
+            rowCount,
+        });
+        // Update merges on sheet rows
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((s) => s.sheetId === sheetId);
+                if (sheet?.merges) {
+                    for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                        sheet.merges = moveMergedCells(sheet.merges, "row-remove", rowIndex);
+                    }
+                }
+            });
+            saveHistory({ sheets: { patches, inversePatches } });
+            return nextState;
+        });
+        // Update citations - delete if overlapping, shift back if after
+        onChangeCitations?.((prevCitations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
+                const deleteRowStart = selection.range.startRowIndex;
+                const deleteRowEnd = selection.range.endRowIndex;
+                const deleteColStart = selection.range.startColumnIndex;
+                const deleteColEnd = selection.range.endColumnIndex;
+                const shiftAmount = deleteRowEnd - deleteRowStart + 1;
+                for (let idx = draft.length - 1; idx >= 0; idx--) {
+                    const citation = draft[idx];
+                    if (citation.range.sheetId !== sheetId)
+                        continue;
+                    const colsOverlap = !(citation.range.endColumnIndex < deleteColStart || citation.range.startColumnIndex > deleteColEnd);
+                    if (colsOverlap) {
+                        const 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;
+                        }
+                    }
+                }
+            });
+            saveHistory({ citations: { patches, inversePatches } });
+            return nextState;
+        });
+        // Update sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                const movedKeys = new Set();
+                const totalRows = draft[sheetId]?.length ?? 0;
+                // Collect unique dependents across the vertical band
+                const sourceRange = {
+                    startRowIndex: selection.range.startRowIndex,
+                    endRowIndex: totalRows,
+                    startColumnIndex: selection.range.startColumnIndex,
+                    endColumnIndex: selection.range.endColumnIndex,
+                };
+                const dependents = collectUniqueDependentsForRange({
+                    draft,
+                    sheetId,
+                    sourceRange,
+                    getDependents,
+                });
+                for (const pos of dependents.values()) {
+                    moveFormulaAtPosition({
+                        draft,
+                        position: pos,
+                        enqueueCalculation,
+                        enqueueGraphOperation,
+                        recalcCells,
+                        movedKeys,
+                        rowDelta: -count,
+                        columnDelta: 0,
+                        sourceRange,
+                        locale,
+                        rowCount,
+                        columnCount,
+                        cellXfsRegistry,
+                        sharedStringRegistry,
+                    });
+                }
+                // Adjust formulas in the band and shift values up
+                for (let rowIndex = selection.range.startRowIndex; rowIndex < totalRows; rowIndex++) {
+                    const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                        moveFormulaAtPosition({
+                            draft,
+                            position: { sheetId, rowIndex, columnIndex },
+                            enqueueCalculation,
+                            enqueueGraphOperation,
+                            recalcCells,
+                            movedKeys,
+                            rowDelta: -count,
+                            columnDelta: 0,
+                            sourceRange,
+                            locale,
+                            rowCount,
+                            columnCount,
+                            cellXfsRegistry,
+                            sharedStringRegistry,
+                        });
+                        currentSheet[rowIndex].values[columnIndex] =
+                            currentSheet[rowIndex + count]?.values?.[columnIndex];
+                    }
+                }
+            });
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                activeCell: { undo: getActiveCell(), redo: getActiveCell() },
+                selections: {
+                    undo: [...getSelections()],
+                    redo: [...getSelections()],
+                },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/esm/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/esm/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/esm/interface/delete-cells.js

@@ -0,0 +1,184 @@
+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 const deleteCells = ({ locale, rowCount, cellXfsRegistry, sharedStringRegistry, getDataValidationById, getDependents, getDataRowCount, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCitations, onChangeActiveCell, enqueueCalculation, enqueueStructureChange, createHistory, isArrayFormula, getRowHeight, }) => {
+    return (sheetId, cell, selections, clearType = "contents") => {
+        const shouldClearContents = clearType === "contents" || clearType === "all";
+        const shouldClearFormats = clearType === "formats" || clearType === "all";
+        const finalSelections = selections.length
+            ? selections
+            : selectionFromActiveCell(cell);
+        const saveHistory = createHistory();
+        const 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) {
+            for (const selection of finalSelections) {
+                enqueueStructureChange?.({
+                    kind: "invalidate-range",
+                    sheetId,
+                    startRowIndex: selection.range.startRowIndex,
+                    endRowIndex: Math.min(maxRowCount ?? rowCount, selection.range.endRowIndex),
+                    startColumnIndex: selection.range.startColumnIndex,
+                    endColumnIndex: selection.range.endColumnIndex,
+                });
+            }
+        }
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        // Create a cell
+        const sheetCell = new SheetCell();
+        // Update sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                for (const selection of finalSelections) {
+                    for (let rowIndex = selection.range.startRowIndex; rowIndex <=
+                        Math.min(maxRowCount ?? rowCount, selection.range.endRowIndex); rowIndex++) {
+                        const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                        const columnCount = currentSheet[rowIndex].values.length;
+                        for (let columnIndex = selection.range.startColumnIndex; columnIndex <=
+                            Math.min(columnCount, selection.range.endColumnIndex); columnIndex++) {
+                            const cellData = currentSheet[rowIndex].values?.[columnIndex];
+                            // Create a cell
+                            sheetCell.assign(sheetId, cell, cellData, {
+                                locale,
+                                getDataValidationById,
+                                cellXfsRegistry,
+                                sharedStringRegistry,
+                            });
+                            // Check if its a formula
+                            const 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?.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, columnIndex, sheetId }).length ||
+                                isFormula ||
+                                // Check if source formula was an array array
+                                isArrayFormula?.({
+                                    rowIndex,
+                                    columnIndex,
+                                    sheetId,
+                                })) {
+                                enqueueCalculation({
+                                    position: { rowIndex, columnIndex, sheetId },
+                                    type: "remove",
+                                });
+                                // Add to recalc cells
+                                recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                                    rowIndex,
+                                    columnIndex,
+                                    sheetId,
+                                });
+                            }
+                        }
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                sheetData: {
+                    inversePatches,
+                    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?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                const tableIndex = draft.findIndex((table) => table.sheetId === sheetId &&
+                    selections.some((sel) => areaInsideArea(table.range, sel.range)));
+                if (tableIndex !== -1) {
+                    draft.splice(tableIndex, 1);
+                }
+            });
+            saveHistory({
+                tables: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update citations - remove citations that overlap with deleted cells
+        onChangeCitations?.((prevCitations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
+                for (let idx = draft.length - 1; idx >= 0; idx--) {
+                    const citation = draft[idx];
+                    // Check if citation is on the same sheet and overlaps with any deleted selection
+                    if (citation.range.sheetId === sheetId &&
+                        finalSelections.some((sel) => areaInsideArea(citation.range, sel.range))) {
+                        // Remove citation since its referenced cells are being deleted
+                        draft.splice(idx, 1);
+                    }
+                }
+            });
+            saveHistory({
+                citations: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update banded cells
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (sheet) {
+                    // Adjust row height
+                    for (const selection of finalSelections) {
+                        for (let rowIndex = selection.range.startRowIndex; rowIndex <=
+                            Math.min(maxRowCount ?? rowCount, selection.range.endRowIndex); rowIndex++) {
+                            const isRowResizedByUser = !!sheet?.rowMetadata?.[rowIndex]?.resizedByUser;
+                            if (!isRowResizedByUser) {
+                                const currentRowHeight = getRowHeight?.(sheetId, rowIndex, 
+                                // Exclude columns within the selection
+                                (colIndex) => colIndex >= selection.range.startColumnIndex &&
+                                    colIndex <= selection.range.endColumnIndex) ?? 0;
+                                if (currentRowHeight !== 0 &&
+                                    currentRowHeight !== sheet.rowMetadata?.[rowIndex]?.size) {
+                                    if (!sheet.rowMetadata) {
+                                        sheet.rowMetadata = [];
+                                    }
+                                    sheet.rowMetadata[rowIndex] = {
+                                        ...sheet.rowMetadata[rowIndex],
+                                        size: currentRowHeight,
+                                        resizedByUser: false,
+                                    };
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            saveHistory({
+                sheets: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Trigger a re-render
+        onChangeActiveCell(sheetId, { ...cell });
+    };
+};

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

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

@@ -0,0 +1,254 @@
+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 const deleteColumn = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getSelections, getDependents, getGraphNodes, getGraphNodesInSheet, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeActiveCell, onChangeSelections, onChangeConditionalFormats, onChangeDataValidations, onChangeCitations, onChangePivotTables, }) => {
+    return (sheetId, columnIndexes) => {
+        if (!columnIndexes.length)
+            return;
+        const sortedColumnIndexes = [...columnIndexes].sort((a, b) => a - b);
+        const minColumnIndex = sortedColumnIndexes[0];
+        const maxColumnIndex = sortedColumnIndexes[sortedColumnIndexes.length - 1];
+        const count = sortedColumnIndexes.length;
+        const saveHistory = createHistory();
+        enqueueStructureChange?.({
+            kind: "delete-column",
+            sheetId,
+            index: minColumnIndex,
+            count,
+            rowCount,
+            columnCount,
+        });
+        const recalcCells = new Map();
+        const activeCell = getActiveCell();
+        const selections = getSelections();
+        const newColumnCount = Math.max(1, columnCount - count);
+        // NOTE: contiguity assumption — see delete-row.ts.
+        const inDeletedColumns = activeCell.columnIndex >= minColumnIndex &&
+            activeCell.columnIndex <= maxColumnIndex;
+        let 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;
+        }
+        const nextActiveCell = nextActiveColumnIndex === activeCell.columnIndex
+            ? activeCell
+            : { ...activeCell, columnIndex: nextActiveColumnIndex };
+        const fallbackSelectionColumnIndex = nextActiveCell.columnIndex;
+        const nextSelections = selections.map((selection) => {
+            if (!selection.range)
+                return selection;
+            const updatedRange = updateSheetRangeOnDelete({ ...selection.range, sheetId }, "column", minColumnIndex, count, sheetId);
+            if (updatedRange) {
+                return {
+                    ...selection,
+                    range: {
+                        ...selection.range,
+                        startColumnIndex: updatedRange.startColumnIndex,
+                        endColumnIndex: updatedRange.endColumnIndex,
+                    },
+                };
+            }
+            return {
+                ...selection,
+                range: {
+                    ...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?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                for (const table of draft) {
+                    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) {
+                            for (const spec of table.filterSpecs) {
+                                if (spec.columnIndex >= minColumnIndex) {
+                                    spec.columnIndex -= count;
+                                }
+                            }
+                        }
+                        if (table.sortSpecs) {
+                            for (const spec of table.sortSpecs) {
+                                if (spec.dimensionIndex >= minColumnIndex) {
+                                    spec.dimensionIndex -= count;
+                                }
+                            }
+                        }
+                        const columnArrayIndex = minColumnIndex - table.range.startColumnIndex;
+                        table.columns?.splice(columnArrayIndex, count);
+                        const delta = Math.min(table.range.endColumnIndex - minColumnIndex + 1, count);
+                        table.range.endColumnIndex -= delta;
+                    }
+                }
+            });
+            saveHistory({ tables: { patches, inversePatches } });
+            return nextState;
+        });
+        // Data validations
+        onChangeDataValidations?.((prevValidations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevValidations, (draft) => {
+                updateRangedRulesOnStructuralChange(draft, "delete", "column", minColumnIndex, count, sheetId);
+            });
+            saveHistory({ dataValidations: { patches, inversePatches } });
+            return nextState;
+        });
+        // Conditional formats
+        onChangeConditionalFormats?.((prevConditionalFormats) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevConditionalFormats, (draft) => {
+                updateRangedRulesOnStructuralChange(draft, "delete", "column", minColumnIndex, count, sheetId);
+            });
+            saveHistory({ conditionalFormats: { patches, inversePatches } });
+            return nextState;
+        });
+        // Shift pivot tables.
+        onChangePivotTables?.((prevPivots) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevPivots, (draft) => {
+                shiftPivotsOnDelete(draft, sheetId, "column", minColumnIndex, count);
+            });
+            saveHistory({ pivotTables: { patches, inversePatches } });
+            return nextState;
+        });
+        // Citations
+        onChangeCitations?.((prevCitations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
+                const deleteEnd = minColumnIndex + count - 1;
+                for (let idx = draft.length - 1; idx >= 0; idx--) {
+                    const citation = draft[idx];
+                    if (citation.range.sheetId !== sheetId)
+                        continue;
+                    const citationStart = citation.range.startColumnIndex;
+                    const 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;
+                    }
+                }
+            });
+            saveHistory({ citations: { patches, inversePatches } });
+            return nextState;
+        });
+        // Sheet metadata
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (!sheet)
+                    return;
+                if (sheet.columnMetadata) {
+                    sheet.columnMetadata.splice(minColumnIndex, count);
+                }
+                if (sheet.basicFilter) {
+                    const { startColumnIndex, endColumnIndex } = sheet.basicFilter.range;
+                    if (minColumnIndex < startColumnIndex) {
+                        moveFilterView(sheet.basicFilter, count, Direction.Left);
+                    }
+                    if (minColumnIndex > startColumnIndex &&
+                        minColumnIndex <= endColumnIndex) {
+                        if (sheet.basicFilter.filterSpecs) {
+                            for (const spec of sheet.basicFilter.filterSpecs) {
+                                if (spec.columnIndex >= minColumnIndex) {
+                                    spec.columnIndex -= count;
+                                }
+                            }
+                        }
+                        if (sheet.basicFilter.sortSpecs) {
+                            for (const spec of sheet.basicFilter.sortSpecs) {
+                                if (spec.dimensionIndex >= minColumnIndex) {
+                                    spec.dimensionIndex -= count;
+                                }
+                            }
+                        }
+                        const delta = Math.min(endColumnIndex - minColumnIndex + 1, count);
+                        sheet.basicFilter.range.endColumnIndex -= delta;
+                    }
+                }
+                if (sheet.frozenColumnCount) {
+                    for (const columnIndex of sortedColumnIndexes) {
+                        if (columnIndex <= sheet.frozenColumnCount) {
+                            sheet.frozenColumnCount--;
+                        }
+                    }
+                }
+                if (sheet.merges) {
+                    sheet.merges = shrinkMergesOnColumnDelete(sheet.merges, minColumnIndex, count);
+                }
+                sheet.columnCount = Math.max(1, (sheet.columnCount ?? columnCount) - count);
+            });
+            saveHistory({ sheets: { patches, inversePatches } });
+            return nextState;
+        });
+        // Sheet data: three-pass formula update, then per-row column splice.
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                updateFormulasForStructuralChange({
+                    draft,
+                    axis: "column",
+                    op: "delete",
+                    sheetId,
+                    referenceIndex: minColumnIndex,
+                    count,
+                    rowCount,
+                    columnCount,
+                    getDependents,
+                    getGraphNodes,
+                    getGraphNodesInSheet,
+                    getSheetName,
+                    enqueueCalculation,
+                    enqueueGraphOperation,
+                    recalcCells,
+                    locale,
+                    cellXfsRegistry,
+                    sharedStringRegistry,
+                });
+                // Splice deleted columns out of each row's values, end-first to
+                // keep indices stable.
+                const sheetRows = draft[sheetId];
+                if (sheetRows) {
+                    for (let rowIndex = 1; rowIndex < sheetRows.length; rowIndex++) {
+                        const row = sheetRows[rowIndex];
+                        if (!row?.values)
+                            continue;
+                        for (let i = sortedColumnIndexes.length - 1; i >= 0; i--) {
+                            row.values.splice(sortedColumnIndexes[i], 1);
+                        }
+                    }
+                }
+            });
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                selections: {
+                    undo: [...selections],
+                    redo: [...nextSelections],
+                },
+                activeCell: { undo: activeCell, redo: nextActiveCell },
+            });
+            return nextState;
+        });
+        if (nextActiveCell.columnIndex !== activeCell.columnIndex) {
+            onChangeActiveCell?.(sheetId, nextActiveCell);
+        }
+        onChangeSelections?.(sheetId, nextSelections);
+    };
+};

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