@rowsncolumns/spreadsheet-state 28.0.76 → 29.1.0

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

@@ -1,6 +1,8 @@
 import { Direction } from "@rowsncolumns/common-types";
+import { getDeletableTableRowIndexes } from "@rowsncolumns/spreadsheet";
 import { getCellUserEnteredValue, getExtendedValueFormula } from "@rowsncolumns/utils";
 import { produceWithPatches } from "immer";
+import { shiftChartsOnTableEdit, tableBinding } from "../api/anchored-objects";
 import { collectUniqueDependentsForRange, moveFormulaAtPosition, } from "../api/dependency";
 import { contractRangesInFormula, createSheetCellIdentifier, } from "../api/formula";
 import { createSheetDraft } from "../api/immer-utils";
@@ -8,250 +10,289 @@ import { moveMergedCells } from "../api/merges";
 import { updateSheetRangeOnDelete } from "../api/range";
 import { moveFilterView } from "../api/selection";
 import { SheetCell } from "../sheet-cell";
-export const deleteTableRow = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, }) => {
+export const deleteTableRow = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCharts, onChangeDataValidations, onChangeConditionalFormats, }) => {
     return (tableView, rowIndexes) => {
         const { sheetId } = tableView;
-        rowIndexes = rowIndexes.sort((a, b) => a - b);
-        const saveHistory = createHistory();
-        const { 0: minRowIndex, [rowIndexes.length - 1]: maxRowIndex } = rowIndexes;
-        const count = rowIndexes.length;
         const { startColumnIndex, endColumnIndex } = tableView.range;
-        const isInsideColumnBand = (range) => range.startColumnIndex >= startColumnIndex &&
-            range.endColumnIndex <= endColumnIndex;
-        enqueueStructureChange?.({
-            kind: "delete-table-row",
-            sheetId,
-            index: minRowIndex,
-            count,
-            rowCount,
-            startColumnIndex: tableView.range.startColumnIndex,
-            endColumnIndex: tableView.range.endColumnIndex,
-        });
+        // Excel's "Delete table rows" never removes the header row or the totals row: they are
+        // dropped from the request, and a request holding nothing else changes nothing.
+        rowIndexes = getDeletableTableRowIndexes(tableView, rowIndexes).sort((a, b) => a - b);
+        if (!rowIndexes.length) {
+            return;
+        }
+        // Excel never leaves a table without a data row: deleting every body row
+        // keeps ONE blank row — the lowest selected row is cleared in place while
+        // rows below it shift away.
+        const bodyStartRowIndex = tableView.range.startRowIndex + (tableView.headerRow !== false ? 1 : 0);
+        const bodyEndRowIndex = tableView.range.endRowIndex - (tableView.totalRow ? 1 : 0);
+        const blankRowIndex = rowIndexes.length > bodyEndRowIndex - bodyStartRowIndex
+            ? rowIndexes[0]
+            : undefined;
+        if (blankRowIndex !== undefined) {
+            rowIndexes = rowIndexes.slice(1);
+        }
+        const saveHistory = createHistory();
         // We need to track this for history. Precedent cells
         const recalcCells = new Map();
-        // Update table position
-        onChangeTables?.((prevTables) => {
-            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
-                for (const table of draft) {
-                    if (table.sheetId !== sheetId || !isInsideColumnBand(table.range)) {
-                        continue;
-                    }
-                    if (table.id === tableView.id) {
-                        table.range.endRowIndex -= count;
-                    }
-                    else if (maxRowIndex < table.range.startRowIndex) {
-                        moveFilterView(table, count, Direction.Up);
-                    }
-                }
+        const clearBlankRow = (draft) => {
+            if (blankRowIndex === undefined)
+                return;
+            const currentSheet = createSheetDraft(draft, sheetId, blankRowIndex);
+            for (let columnIndex = startColumnIndex; columnIndex <= endColumnIndex; columnIndex++) {
+                currentSheet[blankRowIndex].values[columnIndex] = undefined;
+                enqueueCalculation?.({
+                    type: "dirty",
+                    position: { sheetId, rowIndex: blankRowIndex, columnIndex },
+                });
+                recalcCells.set(createSheetCellIdentifier(sheetId, blankRowIndex, columnIndex), { sheetId, rowIndex: blankRowIndex, columnIndex });
+            }
+        };
+        if (!rowIndexes.length) {
+            // The only body row: nothing shifts, the row is just blanked.
+            onChangeSheetData?.((prevSheetData) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, clearBlankRow);
+                saveHistory({
+                    sheetData: { patches, inversePatches },
+                    recalcCells: { undo: recalcCells, redo: recalcCells },
+                });
+                return nextState;
             });
-            // Save history
-            saveHistory({
-                tables: { patches, inversePatches },
+            return;
+        }
+        const isInsideColumnBand = (range) => range.startColumnIndex >= startColumnIndex &&
+            range.endColumnIndex <= endColumnIndex;
+        // A non-contiguous selection is not one block from its lowest row: each contiguous run of
+        // rows is one shift, and the runs go highest-first so the lower rows' indexes stay valid
+        // (the Rust engine deletes row by row the same way).
+        const runs = [];
+        for (const rowIndex of rowIndexes) {
+            const run = runs[runs.length - 1];
+            if (run && run[1] + 1 === rowIndex) {
+                run[1] = rowIndex;
+            }
+            else {
+                runs.push([rowIndex, rowIndex]);
+            }
+        }
+        let binding = tableBinding(tableView);
+        const deleteRun = (minRowIndex, maxRowIndex) => {
+            const count = maxRowIndex - minRowIndex + 1;
+            enqueueStructureChange?.({
+                kind: "delete-table-row",
+                sheetId,
+                index: minRowIndex,
+                count,
+                rowCount,
+                startColumnIndex: tableView.range.startColumnIndex,
+                endColumnIndex: tableView.range.endColumnIndex,
             });
-            return nextState;
-        });
-        // Update data validations
-        onChangeDataValidations?.((prevValidations) => {
-            const [nextState, patches, inversePatches] = produceWithPatches(prevValidations, (draft) => {
-                for (let idx = draft.length - 1; idx >= 0; idx--) {
-                    const rule = draft[idx];
-                    const ranges = rule.ranges
-                        ?.map((range) => isInsideColumnBand(range)
-                        ? updateSheetRangeOnDelete(range, "row", minRowIndex, count, sheetId)
-                        : range)
-                        .filter((range) => !!range) ?? [];
-                    if (ranges.length) {
-                        rule.ranges = ranges;
-                    }
-                    else {
-                        draft.splice(idx, 1);
+            // Update table position
+            onChangeTables?.((prevTables) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                    for (const table of draft) {
+                        if (table.sheetId !== sheetId || !isInsideColumnBand(table.range)) {
+                            continue;
+                        }
+                        if (table.id === tableView.id) {
+                            table.range.endRowIndex -= count;
+                        }
+                        else if (maxRowIndex < table.range.startRowIndex) {
+                            moveFilterView(table, count, Direction.Up);
+                        }
                     }
-                }
+                });
+                // Save history
+                saveHistory({
+                    tables: { patches, inversePatches },
+                });
+                return nextState;
             });
-            saveHistory({
-                dataValidations: { patches, inversePatches },
+            // Chart ranges inside the table's columns follow the shifted cells; a range bound to the table
+            // (a column's body, or header + body) shrinks with it.
+            onChangeCharts?.((prevCharts) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+                    shiftChartsOnTableEdit(draft, sheetId, binding, "row", "delete", minRowIndex, count);
+                });
+                saveHistory({ charts: { patches, inversePatches } });
+                return nextState;
             });
-            return nextState;
-        });
-        // Update conditional formats
-        onChangeConditionalFormats?.((prevConditionalFormats) => {
-            const [nextState, patches, inversePatches] = produceWithPatches(prevConditionalFormats, (draft) => {
-                for (let idx = draft.length - 1; idx >= 0; idx--) {
-                    const rule = draft[idx];
-                    const ranges = rule.ranges
-                        ?.map((range) => isInsideColumnBand(range)
-                        ? updateSheetRangeOnDelete(range, "row", minRowIndex, count, sheetId)
-                        : range)
-                        .filter((range) => !!range) ?? [];
-                    if (ranges.length) {
-                        rule.ranges = ranges;
-                    }
-                    else {
-                        draft.splice(idx, 1);
+            // Update data validations
+            onChangeDataValidations?.((prevValidations) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevValidations, (draft) => {
+                    for (let idx = draft.length - 1; idx >= 0; idx--) {
+                        const rule = draft[idx];
+                        const ranges = rule.ranges
+                            ?.map((range) => isInsideColumnBand(range)
+                            ? updateSheetRangeOnDelete(range, "row", minRowIndex, count, sheetId)
+                            : range)
+                            .filter((range) => !!range) ?? [];
+                        if (ranges.length) {
+                            rule.ranges = ranges;
+                        }
+                        else {
+                            draft.splice(idx, 1);
+                        }
                     }
-                }
-            });
-            saveHistory({
-                conditionalFormats: { patches, inversePatches },
+                });
+                saveHistory({
+                    dataValidations: { patches, inversePatches },
+                });
+                return nextState;
             });
-            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.rowMetadata) {
-                        sheet.rowMetadata.splice(minRowIndex, count);
-                    }
-                    if (sheet.basicFilter &&
-                        isInsideColumnBand(sheet.basicFilter.range)) {
-                        if (minRowIndex < sheet.basicFilter.range.startRowIndex) {
-                            moveFilterView(sheet.basicFilter, count, Direction.Up);
+            // Update conditional formats
+            onChangeConditionalFormats?.((prevConditionalFormats) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevConditionalFormats, (draft) => {
+                    for (let idx = draft.length - 1; idx >= 0; idx--) {
+                        const rule = draft[idx];
+                        const ranges = rule.ranges
+                            ?.map((range) => isInsideColumnBand(range)
+                            ? updateSheetRangeOnDelete(range, "row", minRowIndex, count, sheetId)
+                            : range)
+                            .filter((range) => !!range) ?? [];
+                        if (ranges.length) {
+                            rule.ranges = ranges;
                         }
-                        if (minRowIndex > sheet.basicFilter.range.startRowIndex &&
-                            minRowIndex <= sheet.basicFilter.range.endRowIndex) {
-                            sheet.basicFilter.range.endRowIndex -= count;
+                        else {
+                            draft.splice(idx, 1);
                         }
                     }
-                    if (sheet.merges) {
-                        sheet.merges = moveMergedCells(sheet.merges, "row-remove", minRowIndex, count, (area) => {
-                            return (area.startColumnIndex >= tableView.range.startColumnIndex &&
-                                area.endColumnIndex <= tableView.range.endColumnIndex);
-                        });
-                    }
-                    sheet.rowCount = Math.max(1, (sheet.rowCount ?? rowCount) - count);
-                }
-            });
-            // Save history
-            saveHistory({
-                sheets: { patches, inversePatches },
+                });
+                saveHistory({
+                    conditionalFormats: { patches, inversePatches },
+                });
+                return nextState;
             });
-            return nextState;
-        });
-        // Sheet data
-        onChangeSheetData?.((prevSheetData) => {
-            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
-                const movedKeys = new Set();
-                const totalRows = draft[sheetId]?.length ?? 0;
-                const sourceRange = {
-                    ...tableView.range,
-                    startRowIndex: maxRowIndex + 1,
-                };
-                /**
-                 * THREE-PASS FORMULA UPDATE STRATEGY FOR DELETION:
-                 *
-                 * PASS 1 (lines below): Contract ranges when deletion overlaps with them
-                 *   Example: Delete table row 5, =SUM(A1:A10) → =SUM(A1:A9)
-                 *   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 A10 is moved to A9, formulas referencing A10 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 A11 contains =A1+A2 and moves to A10, references stay the same
-                 *   But if it contains =A15, 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: minRowIndex,
-                    endRowIndex: minRowIndex + count - 1,
-                    startColumnIndex: tableView.range.startColumnIndex,
-                    endColumnIndex: tableView.range.endColumnIndex,
-                };
-                const formulasToContract = collectUniqueDependentsForRange({
-                    draft,
-                    sheetId,
-                    sourceRange: deletionRange,
-                    getDependents,
+            // Update sheets
+            onChangeSheets?.((prevSheets) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                    const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                    if (sheet) {
+                        if (sheet.rowMetadata) {
+                            sheet.rowMetadata.splice(minRowIndex, count);
+                        }
+                        if (sheet.basicFilter &&
+                            isInsideColumnBand(sheet.basicFilter.range)) {
+                            if (minRowIndex < sheet.basicFilter.range.startRowIndex) {
+                                moveFilterView(sheet.basicFilter, count, Direction.Up);
+                            }
+                            if (minRowIndex > sheet.basicFilter.range.startRowIndex &&
+                                minRowIndex <= sheet.basicFilter.range.endRowIndex) {
+                                sheet.basicFilter.range.endRowIndex -= count;
+                            }
+                        }
+                        if (sheet.merges) {
+                            sheet.merges = moveMergedCells(sheet.merges, "row-remove", minRowIndex, count, (area) => {
+                                return (area.startColumnIndex >= tableView.range.startColumnIndex &&
+                                    area.endColumnIndex <= tableView.range.endColumnIndex);
+                            });
+                        }
+                        sheet.rowCount = Math.max(1, (sheet.rowCount ?? rowCount) - count);
+                    }
+                });
+                // Save history
+                saveHistory({
+                    sheets: { patches, inversePatches },
                 });
-                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, minRowIndex, count, "row", 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 row index for formulas below the deleted range
-                            // (they will shift up by `count` after the splice)
-                            const adjustedRowIndex = pos.sheetId === sheetId && pos.rowIndex > maxRowIndex
-                                ? pos.rowIndex - count
-                                : pos.rowIndex;
-                            enqueueCalculation?.({
-                                type: "add",
-                                position: {
+                return nextState;
+            });
+            // Sheet data
+            onChangeSheetData?.((prevSheetData) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                    const movedKeys = new Set();
+                    const totalRows = draft[sheetId]?.length ?? 0;
+                    // Every cell of the table's columns below the deleted run shifts up — through the
+                    // sheet's last used row, not just the table's — so formulas inside that band and
+                    // references into it re-anchor over the whole band (mirrors `insertTableRow`).
+                    const sourceRange = {
+                        ...tableView.range,
+                        startRowIndex: maxRowIndex + 1,
+                        endRowIndex: Math.max(tableView.range.endRowIndex, totalRows - 1),
+                    };
+                    /**
+                     * THREE-PASS FORMULA UPDATE STRATEGY FOR DELETION:
+                     *
+                     * PASS 1 (lines below): Contract ranges when deletion overlaps with them
+                     *   Example: Delete table row 5, =SUM(A1:A10) → =SUM(A1:A9)
+                     *   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 A10 is moved to A9, formulas referencing A10 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 A11 contains =A1+A2 and moves to A10, references stay the same
+                     *   But if it contains =A15, 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: minRowIndex,
+                        endRowIndex: minRowIndex + count - 1,
+                        startColumnIndex: tableView.range.startColumnIndex,
+                        endColumnIndex: tableView.range.endColumnIndex,
+                    };
+                    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, minRowIndex, count, "row", 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 row index for formulas below the deleted range
+                                // (they will shift up by `count` after the splice)
+                                const adjustedRowIndex = pos.sheetId === sheetId && pos.rowIndex > maxRowIndex
+                                    ? pos.rowIndex - count
+                                    : pos.rowIndex;
+                                enqueueCalculation?.({
+                                    type: "add",
+                                    position: {
+                                        sheetId: pos.sheetId,
+                                        rowIndex: adjustedRowIndex,
+                                        columnIndex: pos.columnIndex,
+                                    },
+                                    force: true,
+                                });
+                                recalcCells.set(createSheetCellIdentifier(pos.sheetId, adjustedRowIndex, pos.columnIndex), {
                                     sheetId: pos.sheetId,
                                     rowIndex: adjustedRowIndex,
                                     columnIndex: pos.columnIndex,
-                                },
-                                force: true,
-                            });
-                            recalcCells.set(createSheetCellIdentifier(pos.sheetId, adjustedRowIndex, pos.columnIndex), {
-                                sheetId: pos.sheetId,
-                                rowIndex: adjustedRowIndex,
-                                columnIndex: pos.columnIndex,
-                                force: true,
-                            });
+                                    force: true,
+                                });
+                            }
                         }
                     }
-                }
-                // PASS 2: Collect and process formulas that DEPEND ON the moved cells
-                const dependents = collectUniqueDependentsForRange({
-                    draft,
-                    sheetId,
-                    sourceRange,
-                    getDependents,
-                });
-                for (const pos of dependents.values()) {
-                    moveFormulaAtPosition({
+                    // PASS 2: Collect and process formulas that DEPEND ON the moved cells
+                    const dependents = collectUniqueDependentsForRange({
                         draft,
-                        position: pos,
-                        activeSheetName: getSheetName(pos.sheetId),
-                        enqueueCalculation,
-                        enqueueGraphOperation,
-                        recalcCells,
-                        movedKeys,
-                        rowDelta: -count,
-                        columnDelta: 0,
+                        sheetId,
                         sourceRange,
-                        locale,
-                        rowCount,
-                        columnCount,
-                        cellXfsRegistry,
-                        sharedStringRegistry,
+                        getDependents,
                     });
-                }
-                // PASS 3: Process formulas WITHIN the moved cells themselves
-                for (let rowIndex = minRowIndex; rowIndex <= tableView.range.endRowIndex; rowIndex++) {
-                    const rowValues = draft[sheetId]?.[rowIndex]?.values;
-                    if (!rowValues) {
-                        continue;
-                    }
-                    for (let columnIndex = tableView.range.startColumnIndex; columnIndex <= tableView.range.endColumnIndex; columnIndex++) {
-                        const cellData = rowValues?.[columnIndex];
-                        const hasFormula = !!getExtendedValueFormula(getCellUserEnteredValue(cellData));
-                        if (!hasFormula) {
-                            continue;
-                        }
+                    for (const pos of dependents.values()) {
                         moveFormulaAtPosition({
                             draft,
-                            position: { sheetId, rowIndex, columnIndex },
+                            position: pos,
+                            activeSheetName: getSheetName(pos.sheetId),
                             enqueueCalculation,
                             enqueueGraphOperation,
                             recalcCells,
@@ -266,22 +307,61 @@ export const deleteTableRow = ({ rowCount, columnCount, locale, cellXfsRegistry,
                             sharedStringRegistry,
                         });
                     }
-                }
-                // Shift values up inside the table range
-                for (let rowIndex = minRowIndex; rowIndex < totalRows; rowIndex++) {
-                    const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
-                    for (let columnIndex = tableView.range.startColumnIndex; columnIndex <= tableView.range.endColumnIndex; columnIndex++) {
-                        currentSheet[rowIndex].values[columnIndex] =
-                            currentSheet[rowIndex + count]?.values?.[columnIndex];
+                    // PASS 3: Process formulas WITHIN the moved cells themselves
+                    for (let rowIndex = minRowIndex; rowIndex <= sourceRange.endRowIndex; rowIndex++) {
+                        const rowValues = draft[sheetId]?.[rowIndex]?.values;
+                        if (!rowValues) {
+                            continue;
+                        }
+                        for (let columnIndex = tableView.range.startColumnIndex; columnIndex <= tableView.range.endColumnIndex; columnIndex++) {
+                            const cellData = rowValues?.[columnIndex];
+                            const hasFormula = !!getExtendedValueFormula(getCellUserEnteredValue(cellData));
+                            if (!hasFormula) {
+                                continue;
+                            }
+                            moveFormulaAtPosition({
+                                draft,
+                                position: { sheetId, rowIndex, columnIndex },
+                                enqueueCalculation,
+                                enqueueGraphOperation,
+                                recalcCells,
+                                movedKeys,
+                                rowDelta: -count,
+                                columnDelta: 0,
+                                sourceRange,
+                                locale,
+                                rowCount,
+                                columnCount,
+                                cellXfsRegistry,
+                                sharedStringRegistry,
+                            });
+                        }
+                    }
+                    clearBlankRow(draft);
+                    // Shift values up inside the table range
+                    for (let rowIndex = minRowIndex; rowIndex < totalRows; rowIndex++) {
+                        const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                        for (let columnIndex = tableView.range.startColumnIndex; columnIndex <= tableView.range.endColumnIndex; columnIndex++) {
+                            currentSheet[rowIndex].values[columnIndex] =
+                                currentSheet[rowIndex + count]?.values?.[columnIndex];
+                        }
                     }
-                }
-            });
-            // Save history
-            saveHistory({
-                sheetData: { patches, inversePatches },
-                recalcCells: { undo: recalcCells, redo: recalcCells },
+                });
+                // Save history
+                saveHistory({
+                    sheetData: { patches, inversePatches },
+                    recalcCells: { undo: recalcCells, redo: recalcCells },
+                });
+                return nextState;
             });
-            return nextState;
-        });
+            binding = {
+                ...binding,
+                range: { ...binding.range, endRowIndex: binding.range.endRowIndex - count },
+                bodyEndRowIndex: binding.bodyEndRowIndex - count,
+            };
+        };
+        for (let idx = runs.length - 1; idx >= 0; idx--) {
+            deleteRun(runs[idx][0], runs[idx][1]);
+        }
     };
 };

package/dist/esm/interface/duplicate-sheet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"duplicate-sheet.d.ts","sourceRoot":"","sources":["../../../interface/duplicate-sheet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAc,MAAM,2BAA2B,CAAC;AAO7E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAGhF,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,sPAejE,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,MACvB,SAAS,MAAM,EAAE,0BAA0B,MAAM,uBAmQ1D,CAAC"}
+{"version":3,"file":"duplicate-sheet.d.ts","sourceRoot":"","sources":["../../../interface/duplicate-sheet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAc,MAAM,2BAA2B,CAAC;AAc7E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAGhF,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,sPAejE,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,MACvB,SAAS,MAAM,EAAE,0BAA0B,MAAM,uBAkT1D,CAAC"}