@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,226 @@
+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 const deleteRow = ({ 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, rowIndexes) => {
+        if (!rowIndexes.length)
+            return;
+        // Don't mutate caller's array.
+        const sortedRowIndexes = [...rowIndexes].sort((a, b) => a - b);
+        const minRowIndex = sortedRowIndexes[0];
+        const maxRowIndex = sortedRowIndexes[sortedRowIndexes.length - 1];
+        const count = sortedRowIndexes.length;
+        const saveHistory = createHistory();
+        enqueueStructureChange?.({
+            kind: "delete-row",
+            sheetId,
+            index: minRowIndex,
+            count,
+            rowCount,
+            columnCount,
+        });
+        const recalcCells = new Map();
+        const activeCell = getActiveCell();
+        const selections = getSelections();
+        const 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.
+        const inDeletedRows = activeCell.rowIndex >= minRowIndex && activeCell.rowIndex <= maxRowIndex;
+        let 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;
+        }
+        const nextActiveCell = nextActiveRowIndex === activeCell.rowIndex
+            ? activeCell
+            : { ...activeCell, rowIndex: nextActiveRowIndex };
+        const fallbackSelectionRowIndex = nextActiveCell.rowIndex;
+        const nextSelections = selections.map((selection) => {
+            if (!selection.range)
+                return selection;
+            const updatedRange = updateSheetRangeOnDelete({ ...selection.range, sheetId }, "row", minRowIndex, count, sheetId);
+            if (updatedRange) {
+                return {
+                    ...selection,
+                    range: {
+                        ...selection.range,
+                        startRowIndex: updatedRange.startRowIndex,
+                        endRowIndex: updatedRange.endRowIndex,
+                    },
+                };
+            }
+            return {
+                ...selection,
+                range: {
+                    ...selection.range,
+                    startRowIndex: fallbackSelectionRowIndex,
+                    endRowIndex: fallbackSelectionRowIndex,
+                },
+            };
+        });
+        // Tables: shrink/move based on overlap with deletion; drop tables
+        // whose header row is removed.
+        onChangeTables?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                for (let idx = draft.length - 1; idx >= 0; idx--) {
+                    const table = draft[idx];
+                    if (table.sheetId !== sheetId)
+                        continue;
+                    const { startRowIndex, endRowIndex } = table.range;
+                    if (minRowIndex < startRowIndex) {
+                        moveFilterView(table, count, Direction.Up);
+                    }
+                    if (minRowIndex >= startRowIndex && minRowIndex <= endRowIndex) {
+                        const delta = Math.min(endRowIndex - minRowIndex + 1, count);
+                        table.range.endRowIndex -= delta;
+                    }
+                    if (startRowIndex >= minRowIndex && startRowIndex <= maxRowIndex) {
+                        draft.splice(idx, 1);
+                    }
+                }
+            });
+            saveHistory({ tables: { patches, inversePatches } });
+            return nextState;
+        });
+        // Data validations
+        onChangeDataValidations?.((prevValidations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevValidations, (draft) => {
+                updateRangedRulesOnStructuralChange(draft, "delete", "row", minRowIndex, count, sheetId);
+            });
+            saveHistory({ dataValidations: { patches, inversePatches } });
+            return nextState;
+        });
+        // Conditional formats
+        onChangeConditionalFormats?.((prevConditionalFormats) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevConditionalFormats, (draft) => {
+                updateRangedRulesOnStructuralChange(draft, "delete", "row", minRowIndex, count, sheetId);
+            });
+            saveHistory({ conditionalFormats: { patches, 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?.((prevPivots) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevPivots, (draft) => {
+                shiftPivotsOnDelete(draft, sheetId, "row", minRowIndex, count);
+            });
+            saveHistory({ pivotTables: { patches, inversePatches } });
+            return nextState;
+        });
+        // Citations: drop if overlapping with deletion, shift up if entirely
+        // after.
+        onChangeCitations?.((prevCitations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
+                const deleteEnd = minRowIndex + 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.startRowIndex;
+                    const 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;
+                    }
+                }
+            });
+            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.rowMetadata) {
+                    sheet.rowMetadata.splice(minRowIndex, count);
+                }
+                if (sheet.basicFilter) {
+                    const { startRowIndex, endRowIndex } = sheet.basicFilter.range;
+                    if (minRowIndex < startRowIndex) {
+                        moveFilterView(sheet.basicFilter, count, Direction.Up);
+                    }
+                    if (minRowIndex > startRowIndex && minRowIndex <= endRowIndex) {
+                        const 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) {
+                    for (const rowIndex of sortedRowIndexes) {
+                        if (rowIndex <= sheet.frozenRowCount) {
+                            sheet.frozenRowCount--;
+                        }
+                    }
+                }
+                if (sheet.merges) {
+                    sheet.merges = shrinkMergesOnRowDelete(sheet.merges, minRowIndex, count);
+                }
+                sheet.rowCount = Math.max(1, (sheet.rowCount ?? rowCount) - count);
+            });
+            saveHistory({ sheets: { patches, inversePatches } });
+            return nextState;
+        });
+        // Sheet data: three-pass formula update, then splice the rows out.
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                updateFormulasForStructuralChange({
+                    draft,
+                    axis: "row",
+                    op: "delete",
+                    sheetId,
+                    referenceIndex: minRowIndex,
+                    count,
+                    rowCount,
+                    columnCount,
+                    getDependents,
+                    getGraphNodes,
+                    getGraphNodesInSheet,
+                    getSheetName,
+                    enqueueCalculation,
+                    enqueueGraphOperation,
+                    recalcCells,
+                    locale,
+                    cellXfsRegistry,
+                    sharedStringRegistry,
+                });
+                // Splice from the end so indices don't shift mid-loop.
+                for (let i = sortedRowIndexes.length - 1; i >= 0; i--) {
+                    draft[sheetId]?.splice(sortedRowIndexes[i], 1);
+                }
+            });
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                activeCell: { undo: activeCell, redo: nextActiveCell },
+                selections: {
+                    undo: [...selections],
+                    redo: [...nextSelections],
+                },
+            });
+            return nextState;
+        });
+        if (nextActiveCell.rowIndex !== activeCell.rowIndex) {
+            onChangeActiveCell?.(sheetId, nextActiveCell);
+        }
+        onChangeSelections?.(sheetId, nextSelections);
+    };
+};

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

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

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

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

@@ -0,0 +1,274 @@
+import { Direction } from "@rowsncolumns/common-types";
+import { getCellUserEnteredValue, getExtendedValueFormula } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { collectUniqueDependentsForRange, moveFormulaAtPosition, } from "../api/dependency";
+import { contractRangesInFormula, createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { moveMergedCells } from "../api/merges";
+import { moveFilterView } from "../api/selection";
+import { SheetCell } from "../sheet-cell";
+export const deleteTableColumn = ({ columnCount, rowCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, createHistory, onChangeTables, onChangeSheets, onChangeSheetData, enqueueCalculation, enqueueStructureChange, enqueueGraphOperation, getDependents, }) => {
+    return (tableView, dimensionIndex) => {
+        const { sheetId, range } = tableView;
+        const saveHistory = createHistory();
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        const referenceColumnIndex = tableView.range.startColumnIndex + dimensionIndex;
+        const minColumnIndex = referenceColumnIndex;
+        const count = 1;
+        enqueueStructureChange?.({
+            kind: "delete-table-column",
+            sheetId,
+            index: minColumnIndex,
+            count,
+            columnCount,
+            startRowIndex: range.startRowIndex,
+            endRowIndex: range.endRowIndex,
+        });
+        // Update table position
+        onChangeTables?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                for (const table of draft) {
+                    if (minColumnIndex < table.range.startColumnIndex &&
+                        table.range.startRowIndex >= tableView.range.startRowIndex &&
+                        table.range.endRowIndex <= tableView.range.endRowIndex &&
+                        table.id !== tableView.id) {
+                        moveFilterView(table, count, Direction.Left);
+                    }
+                }
+                const table = draft.find((table) => table.id === tableView.id);
+                if (table) {
+                    if (minColumnIndex >= table.range.startColumnIndex &&
+                        minColumnIndex <= table.range.endColumnIndex) {
+                        // Update filter specs for columns after
+                        if (table.filterSpecs) {
+                            for (const spec of table.filterSpecs) {
+                                if (spec.columnIndex >= minColumnIndex) {
+                                    spec.columnIndex -= count;
+                                }
+                            }
+                        }
+                        // Update filter specs for columns after
+                        if (table.sortSpecs) {
+                            for (const spec of table.sortSpecs) {
+                                if (spec.dimensionIndex >= minColumnIndex) {
+                                    spec.dimensionIndex -= count;
+                                }
+                            }
+                        }
+                        // Remove columns
+                        const columnArrayIndex = minColumnIndex - table.range.startColumnIndex;
+                        table.columns?.splice(columnArrayIndex, count);
+                        table.range.endColumnIndex -= count;
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                tables: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update sheets
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (sheet) {
+                    if (sheet.columnMetadata) {
+                        sheet.columnMetadata.splice(minColumnIndex, count);
+                    }
+                    if (sheet.basicFilter) {
+                        if (minColumnIndex < sheet.basicFilter.range.startColumnIndex) {
+                            moveFilterView(sheet.basicFilter, count, Direction.Left);
+                        }
+                        if (minColumnIndex > sheet.basicFilter.range.startColumnIndex &&
+                            minColumnIndex <= sheet.basicFilter.range.endColumnIndex) {
+                            // Update filter specs for columns after
+                            if (sheet.basicFilter.filterSpecs) {
+                                for (const spec of sheet.basicFilter.filterSpecs) {
+                                    if (spec.columnIndex >= minColumnIndex) {
+                                        spec.columnIndex -= count;
+                                    }
+                                }
+                            }
+                            // Update filter specs for columns after
+                            if (sheet.basicFilter.sortSpecs) {
+                                for (const spec of sheet.basicFilter.sortSpecs) {
+                                    if (spec.dimensionIndex >= minColumnIndex) {
+                                        spec.dimensionIndex -= count;
+                                    }
+                                }
+                            }
+                            sheet.basicFilter.range.endColumnIndex -= count;
+                        }
+                    }
+                    // Move merges
+                    if (sheet.merges) {
+                        sheet.merges = moveMergedCells(sheet.merges, "column-remove", minColumnIndex, count, (area) => {
+                            return (area.startRowIndex >= tableView.range.startRowIndex &&
+                                area.endRowIndex <= tableView.range.endRowIndex);
+                        });
+                    }
+                    sheet.columnCount = Math.max(1, (sheet.columnCount ?? columnCount) - count);
+                }
+            });
+            // Save history
+            saveHistory({
+                sheets: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                const sourceRange = {
+                    ...range,
+                    startColumnIndex: referenceColumnIndex + count,
+                };
+                const movedKeys = new Set();
+                /**
+                 * THREE-PASS FORMULA UPDATE STRATEGY FOR DELETION:
+                 *
+                 * PASS 1 (lines below): Contract ranges when deletion overlaps with them
+                 *   Example: Delete table column B, =SUM(A1:D1) → =SUM(A1:C1)
+                 *   Uses dependency graph to find only formulas that reference the deletion range (efficient!)
+                 *
+                 * PASS 2 (after this loop): Shift references in formulas that DEPEND ON the moved cells
+                 *   Example: If B10 is moved to A10, formulas referencing B10 must update
+                 *   Uses dependency graph to find only affected formulas (efficient)
+                 *
+                 * PASS 3 (final loop): Shift references in formulas WITHIN the moved cells themselves
+                 *   Example: If C10 contains =A1+A2 and moves to B10, references stay the same
+                 *   But if it contains =D1, it needs adjustment based on sourceRange exclusion
+                 *
+                 * The 'movedKeys' Set ensures no formula is processed twice across passes 2 & 3.
+                 * Range contraction (Pass 1) doesn't interfere with reference shifting (Pass 2 & 3).
+                 */
+                // PASS 1: Contract ranges using dependency graph (OPTIMIZED!)
+                // Collect formulas that reference cells in the deletion range
+                const deletionRange = {
+                    startRowIndex: range.startRowIndex,
+                    endRowIndex: range.endRowIndex,
+                    startColumnIndex: minColumnIndex,
+                    endColumnIndex: minColumnIndex + count - 1,
+                };
+                const formulasToContract = collectUniqueDependentsForRange({
+                    draft,
+                    sheetId,
+                    sourceRange: deletionRange,
+                    getDependents,
+                });
+                const sheetCell = new SheetCell();
+                for (const pos of formulasToContract.values()) {
+                    const currentSheet = createSheetDraft(draft, sheetId, pos.rowIndex);
+                    const cellData = currentSheet[pos.rowIndex]?.values?.[pos.columnIndex];
+                    if (!cellData)
+                        continue;
+                    // Check if cell has a formula
+                    sheetCell.assign(pos.sheetId, { rowIndex: pos.rowIndex, columnIndex: pos.columnIndex }, cellData, { locale });
+                    const formulaValue = sheetCell.formula;
+                    if (formulaValue) {
+                        const activeSheetName = getSheetName(pos.sheetId);
+                        const contractedFormula = contractRangesInFormula(formulaValue, minColumnIndex, count, "column", activeSheetName);
+                        // Update the formula if it changed
+                        if (contractedFormula && contractedFormula !== formulaValue) {
+                            // Preserve stale effective value until recalculation completes
+                            sheetCell.setFormulaValue(contractedFormula, false);
+                            currentSheet[pos.rowIndex].values[pos.columnIndex] =
+                                sheetCell.getCellData();
+                            // Adjust column index for formulas to the right of the deleted column
+                            // (they will shift left by `count` after the splice)
+                            const adjustedColumnIndex = pos.sheetId === sheetId && pos.columnIndex > minColumnIndex
+                                ? pos.columnIndex - count
+                                : pos.columnIndex;
+                            enqueueCalculation?.({
+                                type: "add",
+                                position: {
+                                    sheetId: pos.sheetId,
+                                    rowIndex: pos.rowIndex,
+                                    columnIndex: adjustedColumnIndex,
+                                },
+                                force: true,
+                            });
+                            recalcCells.set(createSheetCellIdentifier(pos.sheetId, pos.rowIndex, adjustedColumnIndex), {
+                                sheetId: pos.sheetId,
+                                rowIndex: pos.rowIndex,
+                                columnIndex: adjustedColumnIndex,
+                                force: true,
+                            });
+                        }
+                    }
+                }
+                // PASS 2: Collect and process formulas that DEPEND ON the moved cells
+                const tableDependents = collectUniqueDependentsForRange({
+                    draft,
+                    sheetId,
+                    sourceRange,
+                    getDependents,
+                });
+                for (const pos of tableDependents.values()) {
+                    moveFormulaAtPosition({
+                        draft,
+                        position: pos,
+                        activeSheetName: getSheetName(pos.sheetId),
+                        enqueueCalculation,
+                        enqueueGraphOperation,
+                        recalcCells,
+                        movedKeys,
+                        rowDelta: 0,
+                        columnDelta: -count,
+                        sourceRange,
+                        locale,
+                        rowCount,
+                        columnCount,
+                        cellXfsRegistry,
+                        sharedStringRegistry,
+                    });
+                }
+                // PASS 3: Process formulas WITHIN the moved cells themselves
+                for (let rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                    const rowValues = draft[sheetId]?.[rowIndex]?.values;
+                    const dataColumnCount = rowValues?.length ?? 0;
+                    if (!dataColumnCount) {
+                        continue;
+                    }
+                    const startCol = Math.min(Math.max(range.startColumnIndex, 1), dataColumnCount);
+                    const endCol = Math.min(range.endColumnIndex, dataColumnCount);
+                    for (let columnIndex = startCol; columnIndex < endCol; columnIndex++) {
+                        const cellData = rowValues?.[columnIndex];
+                        const hasFormula = !!getExtendedValueFormula(getCellUserEnteredValue(cellData));
+                        if (!hasFormula) {
+                            continue;
+                        }
+                        moveFormulaAtPosition({
+                            draft,
+                            position: { sheetId, rowIndex, columnIndex },
+                            enqueueCalculation,
+                            enqueueGraphOperation,
+                            recalcCells,
+                            movedKeys,
+                            rowDelta: 0,
+                            columnDelta: -count,
+                            sourceRange,
+                            locale,
+                            rowCount,
+                            columnCount,
+                            cellXfsRegistry,
+                            sharedStringRegistry,
+                        });
+                    }
+                    // Delete column values from the row
+                    if (draft[sheetId]?.[rowIndex]?.values) {
+                        draft[sheetId][rowIndex]?.values?.splice(minColumnIndex, count);
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/esm/interface/delete-table-row.d.ts

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

package/dist/esm/interface/delete-table-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-table-row.d.ts","sourceRoot":"","sources":["../../../interface/delete-table-row.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAgB5E,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAIjF,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,kSAiBjE,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,MACvB,WAAW,SAAS,EAAE,YAAY,MAAM,EAAE,SAyXnD,CAAC"}