@rowsncolumns/spreadsheet-state 28.0.75 → 29.0.0

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

@@ -1,12 +1,14 @@
 import { Direction } from "@rowsncolumns/common-types";
 import { produceWithPatches } from "immer";
+import { shiftChartsOnStructuralChange, shiftEmbedsOnStructuralChange, shiftProtectedRangesOnStructuralChange, } from "../api/anchored-objects";
 import { shrinkMergesOnColumnDelete } from "../api/merges";
+import { updateNamedRangesOnStructuralChange, updatePrintSettingsOnStructuralChange, } from "../api/named-range-structural";
 import { shiftPivotsOnDelete } from "../api/pivot-range";
 import { updateRangedRulesOnStructuralChange } from "../api/range-rule-helpers";
-import { updateSheetRangeOnDelete } from "../api/range";
 import { moveFilterView } from "../api/selection";
 import { updateFormulasForStructuralChange } from "../api/structural-formula-update";
-export const deleteColumn = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getSelections, getDependents, getGraphNodes, getGraphNodesInSheet, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeActiveCell, onChangeSelections, onChangeConditionalFormats, onChangeDataValidations, onChangeCitations, onChangePivotTables, }) => {
+import { breakStructuredRefsForRemovedTableParts, collectRemovedTableParts, removeSpillsOfDeletedAnchors, } from "../api/structural-table-refs";
+export const deleteColumn = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getSelections, getDependents, getGraphNodes, getGraphNodesInSheet, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeActiveCell, onChangeSelections, onChangeConditionalFormats, onChangeDataValidations, onChangeCitations, onChangePivotTables, tables, getArrayRange, onChangeNamedRanges, onChangeEmbeds, onChangeCharts, onChangeProtectedRanges, }) => {
     return (sheetId, columnIndexes) => {
         if (!columnIndexes.length)
             return;
@@ -27,43 +29,33 @@ export const deleteColumn = ({ rowCount, columnCount, locale, cellXfsRegistry, s
         const activeCell = getActiveCell();
         const selections = getSelections();
         const newColumnCount = Math.max(1, columnCount - count);
-        // NOTE: contiguity assumption — see delete-row.ts.
-        const inDeletedColumns = activeCell.columnIndex >= minColumnIndex &&
-            activeCell.columnIndex <= maxColumnIndex;
-        let nextActiveColumnIndex = activeCell.columnIndex;
-        if (inDeletedColumns) {
-            nextActiveColumnIndex = Math.max(1, minColumnIndex - 1);
-        }
-        else if (activeCell.columnIndex > maxColumnIndex) {
-            nextActiveColumnIndex = Math.max(1, activeCell.columnIndex - count);
-        }
-        if (nextActiveColumnIndex > newColumnCount) {
-            nextActiveColumnIndex = newColumnCount;
-        }
+        // Excel keeps the selection where it was (UI-02, column twin): after
+        // deleting columns C:D the selection still reads C:D — now over the
+        // columns that moved left — and the active cell sits in the first deleted
+        // column. Every coordinate loses the deleted columns that lie BEFORE it.
+        const deletedBefore = (columnIndex) => sortedColumnIndexes.filter((index) => index < columnIndex).length;
+        const clampColumn = (columnIndex) => Math.min(Math.max(1, columnIndex), newColumnCount);
+        const nextActiveColumnIndex = clampColumn(activeCell.columnIndex - deletedBefore(activeCell.columnIndex));
         const nextActiveCell = nextActiveColumnIndex === activeCell.columnIndex
             ? activeCell
             : { ...activeCell, columnIndex: nextActiveColumnIndex };
-        const fallbackSelectionColumnIndex = nextActiveCell.columnIndex;
         const nextSelections = selections.map((selection) => {
             if (!selection.range)
                 return selection;
-            const updatedRange = updateSheetRangeOnDelete({ ...selection.range, sheetId }, "column", minColumnIndex, count, sheetId);
-            if (updatedRange) {
-                return {
-                    ...selection,
-                    range: {
-                        ...selection.range,
-                        startColumnIndex: updatedRange.startColumnIndex,
-                        endColumnIndex: updatedRange.endColumnIndex,
-                    },
-                };
-            }
+            const { startColumnIndex, endColumnIndex } = selection.range;
+            const deletedWithin = sortedColumnIndexes.filter((index) => index >= startColumnIndex && index <= endColumnIndex).length;
+            const size = endColumnIndex - startColumnIndex + 1;
+            const nextStart = clampColumn(startColumnIndex - deletedBefore(startColumnIndex));
+            // A partially covered area shrinks by the columns it lost; an area
+            // deleted outright keeps its size (it now frames the columns that moved
+            // left).
+            const nextSize = deletedWithin < size ? size - deletedWithin : size;
             return {
                 ...selection,
                 range: {
                     ...selection.range,
-                    startColumnIndex: fallbackSelectionColumnIndex,
-                    endColumnIndex: fallbackSelectionColumnIndex,
+                    startColumnIndex: nextStart,
+                    endColumnIndex: clampColumn(nextStart + nextSize - 1),
                 },
             };
         });
@@ -118,7 +110,7 @@ export const deleteColumn = ({ rowCount, columnCount, locale, cellXfsRegistry, s
         // Data validations
         onChangeDataValidations?.((prevValidations) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevValidations, (draft) => {
-                updateRangedRulesOnStructuralChange(draft, "delete", "column", minColumnIndex, count, sheetId);
+                updateRangedRulesOnStructuralChange(draft, "delete", "column", minColumnIndex, count, sheetId, { getSheetName });
             });
             saveHistory({ dataValidations: { patches, inversePatches } });
             return nextState;
@@ -126,11 +118,20 @@ export const deleteColumn = ({ rowCount, columnCount, locale, cellXfsRegistry, s
         // Conditional formats
         onChangeConditionalFormats?.((prevConditionalFormats) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevConditionalFormats, (draft) => {
-                updateRangedRulesOnStructuralChange(draft, "delete", "column", minColumnIndex, count, sheetId);
+                updateRangedRulesOnStructuralChange(draft, "delete", "column", minColumnIndex, count, sheetId, { getSheetName });
             });
             saveHistory({ conditionalFormats: { patches, inversePatches } });
             return nextState;
         });
+        // Defined names: shift back / shrink; a name whose whole range is
+        // deleted is kept as `#REF!` so its users evaluate `#REF!`, like Excel.
+        onChangeNamedRanges?.((prevNamedRanges) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevNamedRanges, (draft) => {
+                updateNamedRangesOnStructuralChange(draft, "column", "delete", minColumnIndex, count, sheetId);
+            });
+            saveHistory({ namedRanges: { patches, inversePatches } });
+            return nextState;
+        });
         // Shift pivot tables.
         onChangePivotTables?.((prevPivots) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevPivots, (draft) => {
@@ -161,6 +162,31 @@ export const deleteColumn = ({ rowCount, columnCount, locale, cellXfsRegistry, s
             saveHistory({ citations: { patches, inversePatches } });
             return nextState;
         });
+        // Anchored objects (Excel ANC rules): floating charts / embeds move with
+        // their anchor cell, chart series ranges and AllowEditRange rectangles
+        // shift like references. Frozen panes are a positional viewport split
+        // and are deliberately NOT touched here.
+        onChangeEmbeds?.((prevEmbeds) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevEmbeds, (draft) => {
+                shiftEmbedsOnStructuralChange(draft, sheetId, "column", "delete", minColumnIndex, count);
+            });
+            saveHistory({ embeds: { patches, inversePatches } });
+            return nextState;
+        });
+        onChangeCharts?.((prevCharts) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+                shiftChartsOnStructuralChange(draft, sheetId, "column", "delete", minColumnIndex, count);
+            });
+            saveHistory({ charts: { patches, inversePatches } });
+            return nextState;
+        });
+        onChangeProtectedRanges?.((prevProtectedRanges) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevProtectedRanges, (draft) => {
+                shiftProtectedRangesOnStructuralChange(draft, sheetId, "column", "delete", minColumnIndex, count);
+            });
+            saveHistory({ protectedRanges: { patches, inversePatches } });
+            return nextState;
+        });
         // Sheet metadata
         onChangeSheets?.((prevSheets) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
@@ -195,24 +221,56 @@ export const deleteColumn = ({ rowCount, columnCount, locale, cellXfsRegistry, s
                         sheet.basicFilter.range.endColumnIndex -= delta;
                     }
                 }
-                if (sheet.frozenColumnCount) {
-                    for (const columnIndex of sortedColumnIndexes) {
-                        if (columnIndex <= sheet.frozenColumnCount) {
-                            sheet.frozenColumnCount--;
-                        }
-                    }
-                }
                 if (sheet.merges) {
                     sheet.merges = shrinkMergesOnColumnDelete(sheet.merges, minColumnIndex, count);
                 }
+                // `_xlnm.Print_Area` / `_xlnm.Print_Titles` follow the defined-name rule.
+                if (sheet.printSettings) {
+                    updatePrintSettingsOnStructuralChange(sheet.printSettings, "column", "delete", minColumnIndex, count);
+                }
                 sheet.columnCount = Math.max(1, (sheet.columnCount ?? columnCount) - count);
+                // Frozen panes are positional: the split stays where it is, only
+                // clamped so the freeze never exceeds the shrunk sheet.
+                if (sheet.frozenColumnCount &&
+                    sheet.frozenColumnCount > sheet.columnCount) {
+                    sheet.frozenColumnCount = sheet.columnCount;
+                }
             });
             saveHistory({ sheets: { patches, inversePatches } });
             return nextState;
         });
+        // Table columns spliced out above (and tables dropped whole): their
+        // structured refs break to `#REF!`, computed from the PRE-edit definitions.
+        const removedTableParts = collectRemovedTableParts(tables, sheetId, "column", minColumnIndex, maxColumnIndex);
         // Sheet data: three-pass formula update, then per-row column splice.
         onChangeSheetData?.((prevSheetData) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                removeSpillsOfDeletedAnchors({
+                    draft,
+                    sheetId,
+                    axis: "column",
+                    minIndex: minColumnIndex,
+                    maxIndex: maxColumnIndex,
+                    getArrayRange,
+                    locale,
+                    cellXfsRegistry,
+                    sharedStringRegistry,
+                });
+                breakStructuredRefsForRemovedTableParts({
+                    draft,
+                    sheetId,
+                    axis: "column",
+                    referenceIndex: minColumnIndex,
+                    count,
+                    removed: removedTableParts,
+                    getGraphNodes,
+                    enqueueCalculation,
+                    enqueueGraphOperation,
+                    recalcCells,
+                    locale,
+                    cellXfsRegistry,
+                    sharedStringRegistry,
+                });
                 updateFormulasForStructuralChange({
                     draft,
                     axis: "column",

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

@@ -1,4 +1,4 @@
 import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
 import { type UseOnDeleteRowProps } from "../hooks/use-on-delete-row";
-export declare const deleteRow: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getSelections, getDependents, getGraphNodes, getGraphNodesInSheet, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeActiveCell, onChangeSelections, onChangeConditionalFormats, onChangeDataValidations, onChangeCitations, onChangePivotTables, }: UseOnDeleteRowProps<T, S>) => (sheetId: number, rowIndexes: number[]) => void;
+export declare const deleteRow: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getSelections, getDependents, getGraphNodes, getGraphNodesInSheet, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeActiveCell, onChangeSelections, onChangeConditionalFormats, onChangeDataValidations, onChangeCitations, onChangePivotTables, tables, getArrayRange, onChangeNamedRanges, onChangeEmbeds, onChangeCharts, onChangeProtectedRanges, }: UseOnDeleteRowProps<T, S>) => (sheetId: number, rowIndexes: number[]) => void;
 //# sourceMappingURL=delete-row.d.ts.map

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

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

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

@@ -1,12 +1,14 @@
 import { Direction } from "@rowsncolumns/common-types";
 import { produceWithPatches } from "immer";
+import { shiftChartsOnStructuralChange, shiftEmbedsOnStructuralChange, shiftProtectedRangesOnStructuralChange, } from "../api/anchored-objects";
 import { shrinkMergesOnRowDelete } from "../api/merges";
+import { updateNamedRangesOnStructuralChange, updatePrintSettingsOnStructuralChange, } from "../api/named-range-structural";
 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, }) => {
+import { breakStructuredRefsForRemovedTableParts, collectRemovedTableParts, removeSpillsOfDeletedAnchors, } from "../api/structural-table-refs";
+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, tables, getArrayRange, onChangeNamedRanges, onChangeEmbeds, onChangeCharts, onChangeProtectedRanges, }) => {
     return (sheetId, rowIndexes) => {
         if (!rowIndexes.length)
             return;
@@ -28,44 +30,34 @@ export const deleteRow = ({ rowCount, columnCount, locale, cellXfsRegistry, shar
         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;
-        }
+        // Excel keeps the selection where it was (UI-02): after deleting rows 3:4
+        // the selection still reads 3:4 — now over the rows that moved up — and
+        // the active cell sits in the first deleted row. Every coordinate simply
+        // loses the deleted rows that lie BEFORE it, so an area entirely inside
+        // the deleted band keeps its place while areas below slide up; partially
+        // overlapping areas shrink like any other range.
+        const deletedBefore = (rowIndex) => sortedRowIndexes.filter((index) => index < rowIndex).length;
+        const clampRow = (rowIndex) => Math.min(Math.max(1, rowIndex), newRowCount);
+        const nextActiveRowIndex = clampRow(activeCell.rowIndex - deletedBefore(activeCell.rowIndex));
         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,
-                    },
-                };
-            }
+            const { startRowIndex, endRowIndex } = selection.range;
+            const deletedWithin = sortedRowIndexes.filter((index) => index >= startRowIndex && index <= endRowIndex).length;
+            const size = endRowIndex - startRowIndex + 1;
+            const nextStart = clampRow(startRowIndex - deletedBefore(startRowIndex));
+            // A partially covered area shrinks by the rows it lost; an area deleted
+            // outright keeps its size (it now frames the rows that moved up).
+            const nextSize = deletedWithin < size ? size - deletedWithin : size;
             return {
                 ...selection,
                 range: {
                     ...selection.range,
-                    startRowIndex: fallbackSelectionRowIndex,
-                    endRowIndex: fallbackSelectionRowIndex,
+                    startRowIndex: nextStart,
+                    endRowIndex: clampRow(nextStart + nextSize - 1),
                 },
             };
         });
@@ -96,7 +88,7 @@ export const deleteRow = ({ rowCount, columnCount, locale, cellXfsRegistry, shar
         // Data validations
         onChangeDataValidations?.((prevValidations) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevValidations, (draft) => {
-                updateRangedRulesOnStructuralChange(draft, "delete", "row", minRowIndex, count, sheetId);
+                updateRangedRulesOnStructuralChange(draft, "delete", "row", minRowIndex, count, sheetId, { getSheetName });
             });
             saveHistory({ dataValidations: { patches, inversePatches } });
             return nextState;
@@ -104,11 +96,20 @@ export const deleteRow = ({ rowCount, columnCount, locale, cellXfsRegistry, shar
         // Conditional formats
         onChangeConditionalFormats?.((prevConditionalFormats) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevConditionalFormats, (draft) => {
-                updateRangedRulesOnStructuralChange(draft, "delete", "row", minRowIndex, count, sheetId);
+                updateRangedRulesOnStructuralChange(draft, "delete", "row", minRowIndex, count, sheetId, { getSheetName });
             });
             saveHistory({ conditionalFormats: { patches, inversePatches } });
             return nextState;
         });
+        // Defined names: shift back / shrink; a name whose whole range is
+        // deleted is kept as `#REF!` so its users evaluate `#REF!`, like Excel.
+        onChangeNamedRanges?.((prevNamedRanges) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevNamedRanges, (draft) => {
+                updateNamedRangesOnStructuralChange(draft, "row", "delete", minRowIndex, count, sheetId);
+            });
+            saveHistory({ namedRanges: { 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) => {
@@ -141,6 +142,31 @@ export const deleteRow = ({ rowCount, columnCount, locale, cellXfsRegistry, shar
             saveHistory({ citations: { patches, inversePatches } });
             return nextState;
         });
+        // Anchored objects (Excel ANC rules): floating charts / embeds move with
+        // their anchor cell, chart series ranges and AllowEditRange rectangles
+        // shift like references. Frozen panes are a positional viewport split
+        // and are deliberately NOT touched here.
+        onChangeEmbeds?.((prevEmbeds) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevEmbeds, (draft) => {
+                shiftEmbedsOnStructuralChange(draft, sheetId, "row", "delete", minRowIndex, count);
+            });
+            saveHistory({ embeds: { patches, inversePatches } });
+            return nextState;
+        });
+        onChangeCharts?.((prevCharts) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+                shiftChartsOnStructuralChange(draft, sheetId, "row", "delete", minRowIndex, count);
+            });
+            saveHistory({ charts: { patches, inversePatches } });
+            return nextState;
+        });
+        onChangeProtectedRanges?.((prevProtectedRanges) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevProtectedRanges, (draft) => {
+                shiftProtectedRangesOnStructuralChange(draft, sheetId, "row", "delete", minRowIndex, count);
+            });
+            saveHistory({ protectedRanges: { patches, inversePatches } });
+            return nextState;
+        });
         // Sheet metadata
         onChangeSheets?.((prevSheets) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
@@ -164,24 +190,57 @@ export const deleteRow = ({ rowCount, columnCount, locale, cellXfsRegistry, shar
                         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);
                 }
+                // `_xlnm.Print_Area` / `_xlnm.Print_Titles` follow the defined-name rule.
+                if (sheet.printSettings) {
+                    updatePrintSettingsOnStructuralChange(sheet.printSettings, "row", "delete", minRowIndex, count);
+                }
                 sheet.rowCount = Math.max(1, (sheet.rowCount ?? rowCount) - count);
+                // Frozen panes are positional: the split stays where it is, only
+                // clamped so the freeze never exceeds the shrunk sheet.
+                if (sheet.frozenRowCount && sheet.frozenRowCount > sheet.rowCount) {
+                    sheet.frozenRowCount = sheet.rowCount;
+                }
             });
             saveHistory({ sheets: { patches, inversePatches } });
             return nextState;
         });
+        // Tables whose header row goes (dropped above): their structured refs
+        // break to `#REF!`, computed from the PRE-edit definitions.
+        const removedTableParts = collectRemovedTableParts(tables, sheetId, "row", minRowIndex, maxRowIndex);
         // Sheet data: three-pass formula update, then splice the rows out.
         onChangeSheetData?.((prevSheetData) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                // A dynamic array whose anchor row is deleted takes its spill with
+                // it — drop the projected cells before the rows close up.
+                removeSpillsOfDeletedAnchors({
+                    draft,
+                    sheetId,
+                    axis: "row",
+                    minIndex: minRowIndex,
+                    maxIndex: maxRowIndex,
+                    getArrayRange,
+                    locale,
+                    cellXfsRegistry,
+                    sharedStringRegistry,
+                });
+                breakStructuredRefsForRemovedTableParts({
+                    draft,
+                    sheetId,
+                    axis: "row",
+                    referenceIndex: minRowIndex,
+                    count,
+                    removed: removedTableParts,
+                    getGraphNodes,
+                    enqueueCalculation,
+                    enqueueGraphOperation,
+                    recalcCells,
+                    locale,
+                    cellXfsRegistry,
+                    sharedStringRegistry,
+                });
                 updateFormulasForStructuralChange({
                     draft,
                     axis: "row",

package/dist/esm/interface/insert-cells-shift-down.d.ts

@@ -1,5 +1,14 @@
 import type { CellData, CellInterface, SelectionArea } from "@rowsncolumns/common-types";
 import type { SelectionAttributes, Sheet } from "@rowsncolumns/spreadsheet";
 import type { UseOnInsertCellsShiftDown } from "../hooks/use-on-insert-cells-shift-down";
-export declare const insertCellsShiftDown: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeCitations, }: UseOnInsertCellsShiftDown<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+/**
+ * Insert cells ▸ Shift cells down (SHF-01, SHF-06, SHF-07, SHF-08, FMT-03). Only the selection's
+ * columns move: every cell at or below the selection's first row slides down by the selection's
+ * height. References that target a shifted cell follow it; a range that lies entirely inside the
+ * shifted columns and straddles the insertion row grows by the inserted height (SHF-08); a wider
+ * range keeps its address (SHF-07). The vacated cells take the formatting of the cell above the
+ * insertion (FMT-03). Refusals (torn merge/table/array, off-sheet push) are decided by the hook via
+ * `getShiftCellsRefusal` before this runs.
+ */
+export declare const insertCellsShiftDown: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, getSheetName, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCitations, }: UseOnInsertCellsShiftDown<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
 //# sourceMappingURL=insert-cells-shift-down.d.ts.map

package/dist/esm/interface/insert-cells-shift-down.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"insert-cells-shift-down.d.ts","sourceRoot":"","sources":["../../../interface/insert-cells-shift-down.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EAEb,aAAa,EACd,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAM5E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AAGzF,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,gQAgBvE,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,MAE9B,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,SAoMnD,CAAC"}
+{"version":3,"file":"insert-cells-shift-down.d.ts","sourceRoot":"","sources":["../../../interface/insert-cells-shift-down.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EAEb,aAAa,EACd,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAe5E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AAIzF;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,8RAkBvE,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,MAE9B,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,SAoQnD,CAAC"}