@rowsncolumns/spreadsheet-state 28.0.75 → 29.0.0

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

@@ -1,60 +1,88 @@
-import { selectionFromActiveCell } from "@rowsncolumns/utils";
 import { produceWithPatches } from "immer";
 import { collectUniqueDependentsForRange, moveFormulaAtPosition, } from "../api/dependency";
-import { moveMergedCells } from "../api/merges";
-export const deleteCellsShiftLeft = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeCitations, }) => {
+import { contractRangesInFormula } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { shiftMergesInBand } from "../api/merges";
+import { isRangeInsideBand, isRangeInsideBlock, resolveShiftSelection, shiftBand, } from "../api/structural-guards";
+import { SheetCell } from "../sheet-cell";
+/**
+ * Delete cells ▸ Shift cells left (SHF-04) — the horizontal twin of `deleteCellsShiftUp`: only the
+ * selection's rows move, the selected block is removed and every cell to its right slides left by
+ * the block's width. A reference to a deleted cell becomes `#REF!`; one to a cell that slid left
+ * follows it; a range entirely inside the block's rows that the block partially covers contracts.
+ * Refusals (torn merge/table/array) are decided by the hook before this runs.
+ */
+export const deleteCellsShiftLeft = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, getSheetName, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCitations, }) => {
     return (sheetId, activeCell, selections) => {
         const saveHistory = createHistory();
         const recalcCells = new Map();
-        // Calculate selection
-        const finalSelections = selections.length
-            ? selections
-            : selectionFromActiveCell(activeCell);
-        const selection = finalSelections[finalSelections.length - 1];
-        const count = selection.range.endColumnIndex - selection.range.startColumnIndex + 1;
+        const selection = resolveShiftSelection(activeCell, selections);
+        const { startRowIndex: r1, endRowIndex: r2, startColumnIndex: c1, endColumnIndex: c2, } = selection.range;
+        const count = c2 - c1 + 1;
+        const band = shiftBand("left", selection.range);
+        const deletedRange = { ...selection.range };
+        const sheetName = getSheetName?.(sheetId) ?? "";
         enqueueStructureChange?.({
             kind: "delete-cells-shift-left",
             sheetId,
-            startRowIndex: selection.range.startRowIndex,
-            endRowIndex: selection.range.endRowIndex,
-            startColumnIndex: selection.range.startColumnIndex,
-            endColumnIndex: selection.range.endColumnIndex,
+            startRowIndex: r1,
+            endRowIndex: r2,
+            startColumnIndex: c1,
+            endColumnIndex: c2,
             columnCount,
         });
-        // Update merges on sheet
+        // Update merges on sheet — merges wholly inside the deleted block go with it; merges wholly
+        // inside the shifted rows right of it ride left.
         onChangeSheets?.((prevSheets) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
                 const sheet = draft.find((s) => s.sheetId === sheetId);
                 if (sheet?.merges) {
-                    for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
-                        sheet.merges = moveMergedCells(sheet.merges, "column-remove", columnIndex);
-                    }
+                    sheet.merges = shiftMergesInBand(sheet.merges, "column", c1, count, false, r1, r2);
                 }
             });
             saveHistory({ sheets: { patches, inversePatches } });
             return nextState;
         });
+        // Tables: one wholly inside the deleted block is deleted with it; one wholly inside the
+        // shifted rows right of the block rides left. A partial cover was refused by the hook.
+        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;
+                    if (isRangeInsideBlock(deletedRange, table.range)) {
+                        draft.splice(idx, 1);
+                        continue;
+                    }
+                    if (isRangeInsideBand(table.range, band) &&
+                        table.range.startColumnIndex > c2) {
+                        table.range.startColumnIndex -= count;
+                        table.range.endColumnIndex -= count;
+                    }
+                }
+            });
+            saveHistory({ tables: { 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 = deleteColEnd - deleteColStart + 1;
                 for (let idx = draft.length - 1; idx >= 0; idx--) {
                     const citation = draft[idx];
                     if (citation.range.sheetId !== sheetId)
                         continue;
-                    const rowsOverlap = !(citation.range.endRowIndex < deleteRowStart || citation.range.startRowIndex > deleteRowEnd);
+                    const rowsOverlap = !(citation.range.endRowIndex < r1 ||
+                        citation.range.startRowIndex > r2);
                     if (rowsOverlap) {
-                        const colsOverlap = !(citation.range.endColumnIndex < deleteColStart || citation.range.startColumnIndex > deleteColEnd);
+                        const colsOverlap = !(citation.range.endColumnIndex < c1 ||
+                            citation.range.startColumnIndex > c2);
                         if (colsOverlap) {
                             draft.splice(idx, 1);
                         }
-                        else if (citation.range.startColumnIndex > deleteColEnd) {
-                            citation.range.startColumnIndex -= shiftAmount;
-                            citation.range.endColumnIndex -= shiftAmount;
+                        else if (citation.range.startColumnIndex > c2) {
+                            citation.range.startColumnIndex -= count;
+                            citation.range.endColumnIndex -= count;
                         }
                     }
                 }
@@ -66,65 +94,113 @@ export const deleteCellsShiftLeft = ({ rowCount, columnCount, locale, cellXfsReg
         onChangeSheetData?.((prevSheetData) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
                 const movedKeys = new Set();
-                // Build a broad source range across the selection rows, clamped per row by helper
-                const sourceRange = {
-                    startRowIndex: selection.range.startRowIndex,
-                    endRowIndex: selection.range.endRowIndex,
-                    startColumnIndex: selection.range.startColumnIndex,
-                    endColumnIndex: columnCount,
+                let totalColumns = Math.max(columnCount, c2 + 1);
+                for (let rowIndex = r1; rowIndex <= r2; rowIndex++) {
+                    totalColumns = Math.max(totalColumns, draft[sheetId]?.[rowIndex]?.values?.length ?? 0);
+                }
+                // The cells that actually move: everything RIGHT of the deleted block in its rows.
+                const movingRange = {
+                    startRowIndex: r1,
+                    endRowIndex: r2,
+                    startColumnIndex: c2 + 1,
+                    endColumnIndex: totalColumns,
                 };
-                // Collect unique dependents only once
+                // Dependents of the deleted block AND of the moving cells, each processed once.
                 const dependents = collectUniqueDependentsForRange({
                     draft,
                     sheetId,
-                    sourceRange,
+                    sourceRange: {
+                        startRowIndex: r1,
+                        endRowIndex: r2,
+                        startColumnIndex: c1,
+                        endColumnIndex: totalColumns,
+                    },
                     getDependents,
                 });
-                // Move each dependent exactly once (shift left by count)
-                for (const pos of dependents.values()) {
+                const sheetCell = new SheetCell();
+                const contractAt = (pos) => {
+                    if (pos.sheetId !== sheetId)
+                        return;
+                    const currentSheet = createSheetDraft(draft, sheetId, pos.rowIndex);
+                    const cellData = currentSheet[pos.rowIndex]?.values?.[pos.columnIndex];
+                    sheetCell.assign(sheetId, { rowIndex: pos.rowIndex, columnIndex: pos.columnIndex }, cellData, { locale, cellXfsRegistry, sharedStringRegistry });
+                    const formulaValue = sheetCell.formula;
+                    if (!formulaValue)
+                        return;
+                    const contracted = contractRangesInFormula(formulaValue, c1, count, "column", sheetName, { bandSpan: { startIndex: r1, endIndex: r2 } });
+                    if (!contracted || contracted === formulaValue)
+                        return;
+                    sheetCell.setFormulaValue(contracted, false);
+                    currentSheet[pos.rowIndex].values[pos.columnIndex] =
+                        sheetCell.getCellData();
+                };
+                const rebaseAt = (pos) => {
+                    const insideBlock = pos.sheetId === sheetId &&
+                        pos.rowIndex >= r1 &&
+                        pos.rowIndex <= r2 &&
+                        pos.columnIndex >= c1 &&
+                        pos.columnIndex <= c2;
+                    if (insideBlock)
+                        return;
+                    const moves = pos.sheetId === sheetId &&
+                        pos.columnIndex > c2 &&
+                        pos.rowIndex >= r1 &&
+                        pos.rowIndex <= r2;
+                    contractAt(pos);
                     moveFormulaAtPosition({
                         draft,
                         position: pos,
+                        activeSheetName: getSheetName?.(pos.sheetId),
                         enqueueCalculation,
                         enqueueGraphOperation,
                         recalcCells,
                         movedKeys,
                         rowDelta: 0,
                         columnDelta: -count,
-                        sourceRange,
+                        destinationPosition: {
+                            rowIndex: pos.rowIndex,
+                            columnIndex: moves ? pos.columnIndex - count : pos.columnIndex,
+                        },
+                        sourceRange: movingRange,
+                        deletedRange,
                         locale,
                         rowCount,
                         columnCount,
                         cellXfsRegistry,
                         sharedStringRegistry,
                     });
+                };
+                for (const pos of dependents.values()) {
+                    rebaseAt(pos);
                 }
-                // Also adjust formulas that live within the selection band itself
-                for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
-                    const dataColumnCount = draft[sheetId]?.[rowIndex]?.values?.length ?? 0;
-                    const startCol = Math.min(Math.max(selection.range.startColumnIndex, 1), dataColumnCount);
-                    for (let columnIndex = startCol; columnIndex < dataColumnCount; columnIndex++) {
-                        moveFormulaAtPosition({
-                            draft,
-                            position: { sheetId, rowIndex, columnIndex },
-                            enqueueCalculation,
-                            enqueueGraphOperation,
-                            recalcCells,
-                            movedKeys,
-                            rowDelta: 0,
-                            columnDelta: -count,
-                            sourceRange,
+                // Formulas inside the deleted block leave the graph with their cells.
+                for (let rowIndex = r1; rowIndex <= r2; rowIndex++) {
+                    for (let columnIndex = c1; columnIndex <= c2; columnIndex++) {
+                        const cellData = draft[sheetId]?.[rowIndex]?.values?.[columnIndex];
+                        sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
                             locale,
-                            rowCount,
-                            columnCount,
-                            cellXfsRegistry,
-                            sharedStringRegistry,
                         });
+                        if (!sheetCell.isFormula())
+                            continue;
+                        const enqueueOperation = sheetCell.ephemeral()
+                            ? enqueueCalculation
+                            : enqueueGraphOperation;
+                        enqueueOperation?.({
+                            type: "remove",
+                            position: { sheetId, rowIndex, columnIndex },
+                        });
+                    }
+                }
+                // Re-base the moving formulas themselves
+                for (let rowIndex = r1; rowIndex <= r2; rowIndex++) {
+                    const dataColumnCount = draft[sheetId]?.[rowIndex]?.values?.length ?? 0;
+                    for (let columnIndex = c2 + 1; columnIndex < dataColumnCount; columnIndex++) {
+                        rebaseAt({ sheetId, rowIndex, columnIndex });
                     }
                 }
                 // Finally delete the selected cells by splicing from right to left
-                for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
-                    for (let columnIndex = selection.range.endColumnIndex; columnIndex >= selection.range.startColumnIndex; columnIndex--) {
+                for (let rowIndex = r1; rowIndex <= r2; rowIndex++) {
+                    for (let columnIndex = c2; columnIndex >= c1; columnIndex--) {
                         if (draft[sheetId]?.[rowIndex]?.values) {
                             draft[sheetId][rowIndex]?.values?.splice(columnIndex, 1);
                         }

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

@@ -1,5 +1,13 @@
 import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
 import type { CellData, SelectionAttributes, Sheet } from "@rowsncolumns/spreadsheet";
 import type { UseOnDeleteCellsShiftUpProps } from "../hooks/use-on-delete-cells-shift-up";
-export declare const deleteCellsShiftUp: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeCitations, }: UseOnDeleteCellsShiftUpProps<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+/**
+ * Delete cells ▸ Shift cells up (SHF-03, SHF-09). Only the selection's columns move: the selected
+ * block is removed and every cell below it slides up by the block's height. A reference to a
+ * deleted cell (or to a range the block covers entirely) becomes `#REF!` (SHF-09); a reference to a
+ * cell that slid up follows it (SHF-03); a range entirely inside the block's columns that the block
+ * partially covers contracts by the overlap. Refusals (torn merge/table/array) are decided by the
+ * hook via `getShiftCellsRefusal` before this runs.
+ */
+export declare const deleteCellsShiftUp: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, getSheetName, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCitations, }: UseOnDeleteCellsShiftUpProps<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
 //# sourceMappingURL=delete-cells-shift-up.d.ts.map

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

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

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

@@ -1,60 +1,89 @@
-import { selectionFromActiveCell } from "@rowsncolumns/utils";
 import { produceWithPatches } from "immer";
 import { collectUniqueDependentsForRange, moveFormulaAtPosition, } from "../api/dependency";
+import { contractRangesInFormula } from "../api/formula";
 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, }) => {
+import { shiftMergesInBand } from "../api/merges";
+import { isRangeInsideBand, isRangeInsideBlock, resolveShiftSelection, shiftBand, } from "../api/structural-guards";
+import { SheetCell } from "../sheet-cell";
+/**
+ * Delete cells ▸ Shift cells up (SHF-03, SHF-09). Only the selection's columns move: the selected
+ * block is removed and every cell below it slides up by the block's height. A reference to a
+ * deleted cell (or to a range the block covers entirely) becomes `#REF!` (SHF-09); a reference to a
+ * cell that slid up follows it (SHF-03); a range entirely inside the block's columns that the block
+ * partially covers contracts by the overlap. Refusals (torn merge/table/array) are decided by the
+ * hook via `getShiftCellsRefusal` before this runs.
+ */
+export const deleteCellsShiftUp = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, getSheetName, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, 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;
+        const selection = resolveShiftSelection(activeCell, selections);
+        const { startRowIndex: r1, endRowIndex: r2, startColumnIndex: c1, endColumnIndex: c2, } = selection.range;
+        const count = r2 - r1 + 1;
+        const band = shiftBand("up", selection.range);
+        const deletedRange = { ...selection.range };
+        const sheetName = getSheetName?.(sheetId) ?? "";
         enqueueStructureChange?.({
             kind: "delete-cells-shift-up",
             sheetId,
-            startRowIndex: selection.range.startRowIndex,
-            endRowIndex: selection.range.endRowIndex,
-            startColumnIndex: selection.range.startColumnIndex,
-            endColumnIndex: selection.range.endColumnIndex,
+            startRowIndex: r1,
+            endRowIndex: r2,
+            startColumnIndex: c1,
+            endColumnIndex: c2,
             rowCount,
         });
-        // Update merges on sheet rows
+        // Update merges on sheet rows — merges wholly inside the deleted block go with it; merges
+        // wholly inside the shifted columns below it ride up.
         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);
-                    }
+                    sheet.merges = shiftMergesInBand(sheet.merges, "row", r1, count, false, c1, c2);
                 }
             });
             saveHistory({ sheets: { patches, inversePatches } });
             return nextState;
         });
+        // Tables: one wholly inside the deleted block is deleted with it (TBL-06); one wholly inside
+        // the shifted columns below the block rides up. A partial cover was refused by the hook.
+        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;
+                    if (isRangeInsideBlock(deletedRange, table.range)) {
+                        draft.splice(idx, 1);
+                        continue;
+                    }
+                    if (isRangeInsideBand(table.range, band) &&
+                        table.range.startRowIndex > r2) {
+                        table.range.startRowIndex -= count;
+                        table.range.endRowIndex -= count;
+                    }
+                }
+            });
+            saveHistory({ tables: { 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);
+                    const colsOverlap = !(citation.range.endColumnIndex < c1 ||
+                        citation.range.startColumnIndex > c2);
                     if (colsOverlap) {
-                        const rowsOverlap = !(citation.range.endRowIndex < deleteRowStart || citation.range.startRowIndex > deleteRowEnd);
+                        const rowsOverlap = !(citation.range.endRowIndex < r1 ||
+                            citation.range.startRowIndex > r2);
                         if (rowsOverlap) {
                             draft.splice(idx, 1);
                         }
-                        else if (citation.range.startRowIndex > deleteRowEnd) {
-                            citation.range.startRowIndex -= shiftAmount;
-                            citation.range.endRowIndex -= shiftAmount;
+                        else if (citation.range.startRowIndex > r2) {
+                            citation.range.startRowIndex -= count;
+                            citation.range.endRowIndex -= count;
                         }
                     }
                 }
@@ -67,57 +96,108 @@ export const deleteCellsShiftUp = ({ rowCount, columnCount, locale, cellXfsRegis
             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,
+                // The cells that actually move: everything BELOW the deleted block in its columns.
+                const movingRange = {
+                    startRowIndex: r2 + 1,
+                    endRowIndex: Math.max(totalRows, r2 + 1),
+                    startColumnIndex: c1,
+                    endColumnIndex: c2,
                 };
+                // Dependents of the deleted block AND of the moving cells, each processed once.
                 const dependents = collectUniqueDependentsForRange({
                     draft,
                     sheetId,
-                    sourceRange,
+                    sourceRange: {
+                        startRowIndex: r1,
+                        endRowIndex: Math.max(totalRows, r2),
+                        startColumnIndex: c1,
+                        endColumnIndex: c2,
+                    },
                     getDependents,
                 });
-                for (const pos of dependents.values()) {
+                // Contract ranges the block partially covers, then re-base: a range wholly inside the
+                // block is left to `moveFormulaAtPosition`, which turns it into `#REF!`.
+                const sheetCell = new SheetCell();
+                const contractAt = (pos) => {
+                    if (pos.sheetId !== sheetId)
+                        return;
+                    const currentSheet = createSheetDraft(draft, sheetId, pos.rowIndex);
+                    const cellData = currentSheet[pos.rowIndex]?.values?.[pos.columnIndex];
+                    sheetCell.assign(sheetId, { rowIndex: pos.rowIndex, columnIndex: pos.columnIndex }, cellData, { locale, cellXfsRegistry, sharedStringRegistry });
+                    const formulaValue = sheetCell.formula;
+                    if (!formulaValue)
+                        return;
+                    const contracted = contractRangesInFormula(formulaValue, r1, count, "row", sheetName, { bandSpan: { startIndex: c1, endIndex: c2 } });
+                    if (!contracted || contracted === formulaValue)
+                        return;
+                    sheetCell.setFormulaValue(contracted, false);
+                    currentSheet[pos.rowIndex].values[pos.columnIndex] =
+                        sheetCell.getCellData();
+                };
+                const rebaseAt = (pos) => {
+                    const insideBlock = pos.sheetId === sheetId &&
+                        pos.rowIndex >= r1 &&
+                        pos.rowIndex <= r2 &&
+                        pos.columnIndex >= c1 &&
+                        pos.columnIndex <= c2;
+                    if (insideBlock)
+                        return;
+                    const moves = pos.sheetId === sheetId &&
+                        pos.rowIndex > r2 &&
+                        pos.columnIndex >= c1 &&
+                        pos.columnIndex <= c2;
+                    contractAt(pos);
                     moveFormulaAtPosition({
                         draft,
                         position: pos,
+                        activeSheetName: getSheetName?.(pos.sheetId),
                         enqueueCalculation,
                         enqueueGraphOperation,
                         recalcCells,
                         movedKeys,
                         rowDelta: -count,
                         columnDelta: 0,
-                        sourceRange,
+                        destinationPosition: {
+                            rowIndex: moves ? pos.rowIndex - count : pos.rowIndex,
+                            columnIndex: pos.columnIndex,
+                        },
+                        sourceRange: movingRange,
+                        deletedRange,
                         locale,
                         rowCount,
                         columnCount,
                         cellXfsRegistry,
                         sharedStringRegistry,
                     });
+                };
+                for (const pos of dependents.values()) {
+                    rebaseAt(pos);
                 }
-                // 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,
+                // Formulas inside the deleted block leave the graph with their cells.
+                for (let rowIndex = r1; rowIndex <= r2; rowIndex++) {
+                    for (let columnIndex = c1; columnIndex <= c2; columnIndex++) {
+                        const cellData = draft[sheetId]?.[rowIndex]?.values?.[columnIndex];
+                        sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
                             locale,
-                            rowCount,
-                            columnCount,
-                            cellXfsRegistry,
-                            sharedStringRegistry,
                         });
+                        if (!sheetCell.isFormula())
+                            continue;
+                        const enqueueOperation = sheetCell.ephemeral()
+                            ? enqueueCalculation
+                            : enqueueGraphOperation;
+                        enqueueOperation?.({
+                            type: "remove",
+                            position: { sheetId, rowIndex, columnIndex },
+                        });
+                    }
+                }
+                // Re-base the moving formulas themselves, then shift values up
+                for (let rowIndex = r1; rowIndex < totalRows; rowIndex++) {
+                    const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    for (let columnIndex = c1; columnIndex <= c2; columnIndex++) {
+                        if (rowIndex > r2) {
+                            rebaseAt({ sheetId, rowIndex, columnIndex });
+                        }
                         currentSheet[rowIndex].values[columnIndex] =
                             currentSheet[rowIndex + count]?.values?.[columnIndex];
                     }

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

@@ -1,4 +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;
+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, tables, getArrayRange, onChangeNamedRanges, onChangeEmbeds, onChangeCharts, onChangeProtectedRanges, }: UseOnDeleteColumnProps<T, S>) => (sheetId: number, columnIndexes: number[]) => void;
 //# sourceMappingURL=delete-column.d.ts.map

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

@@ -1 +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,SAuUjD,CAAC"}
+{"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;AAsBjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAG5E,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,0hBA+B/D,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC,MACrB,SAAS,MAAM,EAAE,eAAe,MAAM,EAAE,SA8bjD,CAAC"}