@rowsncolumns/spreadsheet-state 28.0.75 → 28.0.76

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

@@ -1,12 +1,15 @@
 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 { updateRangedRulesOnStructuralChange } from "../api/range-rule-helpers";
 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;
@@ -118,7 +121,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 +129,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 +173,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 +232,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;AAuBjE,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,SAmZ9C,CAAC"}

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

@@ -1,12 +1,15 @@
 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 { updateRangedRulesOnStructuralChange } from "../api/range-rule-helpers";
 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;
@@ -96,7 +99,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 +107,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 +153,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 +201,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"}

package/dist/esm/interface/insert-cells-shift-down.js

@@ -1,37 +1,44 @@
-import { selectionFromActiveCell } from "@rowsncolumns/utils";
 import { produceWithPatches } from "immer";
-import { processSideEffectDependentCells } from "../api/dependency";
+import { collectUniqueDependentsForRange, processSideEffectDependentCells, } from "../api/dependency";
+import { createSheetCellIdentifier, expandRangesInFormula } from "../api/formula";
 import { cloneCellWithFormatting, createSheetDraft } from "../api/immer-utils";
-import { moveMergedCells } from "../api/merges";
-export const insertCellsShiftDown = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeCitations, }) => {
+import { shiftMergesInBand } from "../api/merges";
+import { isRangeInsideBand, resolveShiftSelection, shiftBand, } from "../api/structural-guards";
+import { SheetCell } from "../sheet-cell";
+/**
+ * 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 const insertCellsShiftDown = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, getSheetName, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCitations, }) => {
     return (sheetId, activeCell, selections) => {
         const saveHistory = createHistory();
         // We need to track this for history. Precedent cells
         const recalcCells = new Map();
-        // Count
-        const finalSelections = selections.length
-            ? selections
-            : selectionFromActiveCell(activeCell);
-        // Last selection
-        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("down", selection.range);
+        const sheetName = getSheetName?.(sheetId) ?? "";
         enqueueStructureChange?.({
             kind: "insert-cells-shift-down",
             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 sheets
+        // Update sheets — merges wholly inside the shifted columns ride down with their cells.
         onChangeSheets?.((prevSheets) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
                 const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
-                if (sheet) {
-                    for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
-                        sheet.merges = moveMergedCells(sheet.merges, "row-insert", rowIndex);
-                    }
+                if (sheet?.merges) {
+                    sheet.merges = shiftMergesInBand(sheet.merges, "row", r1, count, true, c1, c2);
                 }
             });
             // Save history
@@ -40,27 +47,37 @@ export const insertCellsShiftDown = ({ rowCount, columnCount, locale, cellXfsReg
             });
             return nextState;
         });
+        // Tables whose columns the band covers entirely move with it (a partial cover was refused).
+        onChangeTables?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                for (const table of draft) {
+                    if (table.sheetId !== sheetId ||
+                        !isRangeInsideBand(table.range, band)) {
+                        continue;
+                    }
+                    table.range.startRowIndex += count;
+                    table.range.endRowIndex += count;
+                }
+            });
+            saveHistory({ tables: { patches, inversePatches } });
+            return nextState;
+        });
         // Update citations - shift if in affected columns and after insertion row
         onChangeCitations?.((prevCitations) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
-                const affectedColStart = selection.range.startColumnIndex;
-                const affectedColEnd = selection.range.endColumnIndex;
-                const insertRowStart = selection.range.startRowIndex;
-                const shiftAmount = selection.range.endRowIndex - selection.range.startRowIndex + 1;
                 for (const citation of draft) {
                     // Skip citations on other sheets
                     if (citation.range.sheetId !== sheetId) {
                         continue;
                     }
                     // Check if citation overlaps with affected columns
-                    const citationColStart = citation.range.startColumnIndex;
-                    const citationColEnd = citation.range.endColumnIndex;
-                    const colsOverlap = !(citationColEnd < affectedColStart || citationColStart > affectedColEnd);
+                    const colsOverlap = !(citation.range.endColumnIndex < c1 ||
+                        citation.range.startColumnIndex > c2);
                     if (colsOverlap) {
                         // If citation starts at or after the insertion row, shift it down
-                        if (citation.range.startRowIndex >= insertRowStart) {
-                            citation.range.startRowIndex += shiftAmount;
-                            citation.range.endRowIndex += shiftAmount;
+                        if (citation.range.startRowIndex >= r1) {
+                            citation.range.startRowIndex += count;
+                            citation.range.endRowIndex += count;
                         }
                     }
                 }
@@ -74,16 +91,31 @@ export const insertCellsShiftDown = ({ rowCount, columnCount, locale, cellXfsReg
         onChangeSheetData?.((prevSheetData) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
                 const movedKeys = new Set();
-                const totalRows = draft[sheetId]?.length ?? rowCount;
-                for (let rowIndex = totalRows; rowIndex > 0; rowIndex--) {
+                const totalRows = Math.max(draft[sheetId]?.length ?? 0, r2 + 1);
+                // Everything at or below the insertion row in the band's columns moves down by `count`.
+                const sourceRange = {
+                    startRowIndex: r1,
+                    endRowIndex: totalRows + count,
+                    startColumnIndex: c1,
+                    endColumnIndex: c2,
+                };
+                // Formulas that read a moving cell — captured before the graph goes stale.
+                const dependents = collectUniqueDependentsForRange({
+                    draft,
+                    sheetId,
+                    sourceRange: {
+                        startRowIndex: r1,
+                        endRowIndex: totalRows,
+                        startColumnIndex: c1,
+                        endColumnIndex: c2,
+                    },
+                    getDependents,
+                });
+                for (let rowIndex = totalRows; rowIndex >= r1; rowIndex--) {
                     // We have a for loop
                     // to cater for table expansion
                     // which will push multiple columns down
-                    for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
-                        const sourceRange = {
-                            ...selection.range,
-                            endRowIndex: selection.range.endRowIndex + count,
-                        };
+                    for (let columnIndex = c1; columnIndex <= c2; columnIndex++) {
                         // Process dependents
                         processSideEffectDependentCells({
                             draft,
@@ -94,6 +126,7 @@ export const insertCellsShiftDown = ({ rowCount, columnCount, locale, cellXfsReg
                             enqueueGraphOperation,
                             enqueueCalculation,
                             getDependents,
+                            getSheetName,
                             recalcCells,
                             rowDelta: count,
                             sourceRange,
@@ -104,26 +137,62 @@ export const insertCellsShiftDown = ({ rowCount, columnCount, locale, cellXfsReg
                             cellXfsRegistry,
                             sharedStringRegistry,
                         });
-                        // Skip unaffected cells
-                        if (rowIndex < selection.range.startRowIndex) {
-                            continue;
-                        }
                     }
                 }
+                // SHF-08: a range living entirely inside the band's columns that straddles the insertion
+                // row grows by the inserted height (Excel's "insert inside a range expands it"). Runs on
+                // the pre-shift positions; the value shift below carries in-band dependents down.
+                const sheetCell = new SheetCell();
+                for (const pos of dependents.values()) {
+                    if (pos.sheetId !== sheetId)
+                        continue;
+                    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)
+                        continue;
+                    const expanded = expandRangesInFormula(formulaValue, r1, count, "row", sheetName, { bandSpan: { startIndex: c1, endIndex: c2 } });
+                    if (!expanded || expanded === formulaValue)
+                        continue;
+                    sheetCell.setFormulaValue(expanded, false);
+                    currentSheet[pos.rowIndex].values[pos.columnIndex] =
+                        sheetCell.getCellData();
+                    const movesWithBand = pos.rowIndex >= r1 && pos.columnIndex >= c1 && pos.columnIndex <= c2;
+                    const finalPosition = {
+                        sheetId,
+                        rowIndex: movesWithBand ? pos.rowIndex + count : pos.rowIndex,
+                        columnIndex: pos.columnIndex,
+                    };
+                    const enqueueOperation = sheetCell.ephemeral()
+                        ? enqueueCalculation
+                        : enqueueGraphOperation;
+                    enqueueOperation?.({ type: "add", position: finalPosition });
+                    enqueueCalculation?.({
+                        type: "dirty",
+                        position: finalPosition,
+                        force: true,
+                    });
+                    recalcCells.set(createSheetCellIdentifier(sheetId, finalPosition.rowIndex, finalPosition.columnIndex), finalPosition);
+                }
                 // Update values
-                for (let rowIndex = totalRows + count; rowIndex > selection.range.startRowIndex; rowIndex--) {
+                for (let rowIndex = totalRows + count; rowIndex > r1; rowIndex--) {
                     const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
-                    for (let columnIndex = selection.range.endColumnIndex; columnIndex >= selection.range.startColumnIndex; columnIndex--) {
+                    for (let columnIndex = c2; columnIndex >= c1; columnIndex--) {
                         const previousValue = currentSheet[rowIndex - count]?.values?.[columnIndex];
                         currentSheet[rowIndex].values[columnIndex] = previousValue;
                     }
                 }
-                // Update inserts cells
-                for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                // FMT-03: the inserted cells take the formatting of the cell directly ABOVE the
+                // insertion; at row 1 there is none, so they keep the displaced cell's formatting.
+                for (let rowIndex = r1; rowIndex <= r2; rowIndex++) {
                     const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
-                    for (let columnIndex = selection.range.endColumnIndex; columnIndex >= selection.range.startColumnIndex; columnIndex--) {
+                    for (let columnIndex = c2; columnIndex >= c1; columnIndex--) {
+                        const formatSource = r1 > 1
+                            ? currentSheet[r1 - 1]?.values?.[columnIndex]
+                            : currentSheet[rowIndex].values[columnIndex];
                         currentSheet[rowIndex].values[columnIndex] =
-                            cloneCellWithFormatting(currentSheet[rowIndex].values[columnIndex]);
+                            cloneCellWithFormatting(formatSource);
                     }
                 }
             });

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

@@ -1,5 +1,14 @@
 import type { CellData, CellInterface, SelectionArea } from "@rowsncolumns/common-types";
 import type { SelectionAttributes, Sheet } from "@rowsncolumns/spreadsheet";
 import type { UseOnInsertCellsShiftRight } from "../hooks/use-on-insert-cells-shift-right";
-export declare const insertCellsShiftRight: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeCitations, }: UseOnInsertCellsShiftRight<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+/**
+ * Insert cells ▸ Shift cells right (SHF-02, FMT-04) — the horizontal twin of
+ * `insertCellsShiftDown`: only the selection's rows move, every cell at or right of the selection's
+ * first column slides right by the selection's width. References follow shifted cells; a range
+ * entirely inside the shifted rows that straddles the insertion column widens (SHF-08 analog);
+ * the vacated cells take the formatting of the cell to the LEFT of the insertion (FMT-04). Refusals
+ * (torn merge/table/array, a non-blank cell pushed past `columnCount` — SHF-10) are decided by the
+ * hook before this runs.
+ */
+export declare const insertCellsShiftRight: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, getSheetName, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCitations, }: UseOnInsertCellsShiftRight<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
 //# sourceMappingURL=insert-cells-shift-right.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"insert-cells-shift-right.d.ts","sourceRoot":"","sources":["../../../interface/insert-cells-shift-right.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,0BAA0B,EAAE,MAAM,0CAA0C,CAAC;AAG3F,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,gQAgBxE,0BAA0B,CAAC,CAAC,EAAE,CAAC,CAAC,MAE/B,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,SA2LnD,CAAC"}
+{"version":3,"file":"insert-cells-shift-right.d.ts","sourceRoot":"","sources":["../../../interface/insert-cells-shift-right.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;AAgB5E,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAC;AAI3F;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,8RAkBxE,0BAA0B,CAAC,CAAC,EAAE,CAAC,CAAC,MAE/B,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,SAqQnD,CAAC"}