@rowsncolumns/spreadsheet-state 28.0.76 → 29.1.0

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

@@ -1,4 +1,4 @@
 import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
 import type { UseOnInsertRowProps } from "../hooks/use-on-insert-row";
-export declare const insertRow: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, maxRowCount, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getSelections, getDependents, getGraphNodes, getGraphNodesInSheet, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, onChangeCitations, onChangePivotTables, onChangeNamedRanges, onChangeEmbeds, onChangeCharts, onChangeProtectedRanges, }: UseOnInsertRowProps<T, S>) => (sheetId: number, referenceRowIndex: number, numRows?: number) => void;
+export declare const insertRow: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, maxRowCount, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getSelections, getDependents, getGraphNodes, getGraphNodesInSheet, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, onChangeCitations, onChangePivotTables, onChangeNamedRanges, onChangeEmbeds, onChangeSlicers, onChangeCharts, onChangeProtectedRanges, }: UseOnInsertRowProps<T, S>) => (sheetId: number, referenceRowIndex: number, numRows?: number) => void;
 //# sourceMappingURL=insert-row.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"insert-row.d.ts","sourceRoot":"","sources":["../../../interface/insert-row.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAkBjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAGtE,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,weA4B5D,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,MAClB,SAAS,MAAM,EAAE,mBAAmB,MAAM,EAAE,gBAAW,SA4ShE,CAAC"}
+{"version":3,"file":"insert-row.d.ts","sourceRoot":"","sources":["../../../interface/insert-row.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAuBjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAGtE,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,yfA6B5D,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,MAClB,SAAS,MAAM,EAAE,mBAAmB,MAAM,EAAE,gBAAW,SA4UhE,CAAC"}

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

@@ -1,14 +1,14 @@
 import { Direction } from "@rowsncolumns/common-types";
 import { produceWithPatches } from "immer";
-import { shiftChartsOnStructuralChange, shiftEmbedsOnStructuralChange, shiftProtectedRangesOnStructuralChange, } from "../api/anchored-objects";
-import { cloneRowWithFormatting, createSheetDraft } from "../api/immer-utils";
+import { shiftChartsOnStructuralChange, shiftEmbedsOnStructuralChange, shiftSlicersOnStructuralChange, shiftProtectedRangesOnStructuralChange, } from "../api/anchored-objects";
+import { cloneRowWithFormatting, createSheetDraft, inheritedDimensionMetadata, } from "../api/immer-utils";
 import { expandMergesOnRowInsert } from "../api/merges";
 import { updateNamedRangesOnStructuralChange, updatePrintSettingsOnStructuralChange, } from "../api/named-range-structural";
 import { shiftPivotsOnInsert } from "../api/pivot-range";
 import { updateRangedRulesOnStructuralChange } from "../api/range-rule-helpers";
 import { moveFilterView } from "../api/selection";
 import { updateFormulasForStructuralChange } from "../api/structural-formula-update";
-export const insertRow = ({ rowCount, columnCount, locale, maxRowCount, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getSelections, getDependents, getGraphNodes, getGraphNodesInSheet, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, onChangeCitations, onChangePivotTables, onChangeNamedRanges, onChangeEmbeds, onChangeCharts, onChangeProtectedRanges, }) => {
+export const insertRow = ({ rowCount, columnCount, locale, maxRowCount, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getSelections, getDependents, getGraphNodes, getGraphNodesInSheet, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, onChangeCitations, onChangePivotTables, onChangeNamedRanges, onChangeEmbeds, onChangeSlicers, onChangeCharts, onChangeProtectedRanges, }) => {
     return (sheetId, referenceRowIndex, numRows = 1) => {
         if (numRows <= 0)
             return;
@@ -104,6 +104,13 @@ export const insertRow = ({ rowCount, columnCount, locale, maxRowCount, cellXfsR
             saveHistory({ embeds: { patches, inversePatches } });
             return nextState;
         });
+        onChangeSlicers?.((prevSlicers) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSlicers, (draft) => {
+                shiftSlicersOnStructuralChange(draft, sheetId, "row", "insert", referenceRowIndex, numRows);
+            });
+            saveHistory({ slicers: { patches, inversePatches } });
+            return nextState;
+        });
         onChangeCharts?.((prevCharts) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
                 shiftChartsOnStructuralChange(draft, sheetId, "row", "insert", referenceRowIndex, numRows);
@@ -125,7 +132,11 @@ export const insertRow = ({ rowCount, columnCount, locale, maxRowCount, cellXfsR
                 if (!sheet)
                     return;
                 if (sheet.rowMetadata) {
-                    sheet.rowMetadata.splice(referenceRowIndex, 0, ...Array.from({ length: numRows }, () => null));
+                    // Excel "Format Same As Above" (FMT-01) covers the row height and
+                    // hidden state too: the inserted rows inherit the row above's
+                    // metadata (row 1 has none above and takes the pushed-down row's).
+                    const inherited = inheritedDimensionMetadata(sheet.rowMetadata, referenceRowIndex);
+                    sheet.rowMetadata.splice(referenceRowIndex, 0, ...Array.from({ length: numRows }, () => inherited ? { ...inherited } : null));
                 }
                 if (sheet.basicFilter) {
                     const { startRowIndex, endRowIndex } = sheet.basicFilter.range;
@@ -175,8 +186,13 @@ export const insertRow = ({ rowCount, columnCount, locale, maxRowCount, cellXfsR
                     sharedStringRegistry,
                 });
                 const currentSheet = createSheetDraft(draft, sheetId, referenceRowIndex);
-                const formattingSourceRow = currentSheet[referenceRowIndex] ??
-                    currentSheet[referenceRowIndex - 1];
+                // Excel "Format Same As Above" (FMT-01): the new rows take the
+                // per-cell formatting (never values) of the row ABOVE the insertion
+                // point. Only an insert at row 1 has no row above and seeds from the
+                // row being pushed down instead.
+                const formattingSourceRow = referenceRowIndex > 1
+                    ? currentSheet[referenceRowIndex - 1]
+                    : currentSheet[referenceRowIndex];
                 const newRows = Array.from({ length: numRows }, () => cloneRowWithFormatting(formattingSourceRow));
                 currentSheet.splice(referenceRowIndex, 0, ...newRows);
             });

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

@@ -1,4 +1,5 @@
 import type { CellData, Sheet, TableView } from "@rowsncolumns/spreadsheet";
 import type { UseOnInsertTableRowProps } from "../hooks/use-on-insert-table-row";
-export declare const insertTableRow: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, }: UseOnInsertTableRowProps<T, S>) => (tableView: TableView, relativeRowIndex?: number, rowData?: Record<string, string | undefined | null>[]) => void;
+import type { SpreadsheetPatch } from "../hooks/use-undo-redo";
+export declare const insertTableRow: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCharts, onChangeDataValidations, onChangeConditionalFormats, }: UseOnInsertTableRowProps<T, S>) => (tableView: TableView, relativeRowIndex?: number, rowData?: Record<string, string | undefined | null>[], saveHistory?: (patches: SpreadsheetPatch) => void) => void;
 //# sourceMappingURL=insert-table-row.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"insert-table-row.d.ts","sourceRoot":"","sources":["../../../interface/insert-table-row.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAa5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAIjF,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,iTAkBjE,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,MAE7B,WAAW,SAAS,EACpB,mBAAmB,MAAM,EACzB,UAAU,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,SAubxD,CAAC"}
+{"version":3,"file":"insert-table-row.d.ts","sourceRoot":"","sources":["../../../interface/insert-table-row.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAc5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AACjF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAS/D,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,iUAmBjE,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,MAE7B,WAAW,SAAS,EACpB,mBAAmB,MAAM,EACzB,UAAU,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAIrD,cAAa,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAsB,SAugBrE,CAAC"}

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

@@ -1,6 +1,7 @@
 import { Direction } from "@rowsncolumns/common-types";
 import { getCellUserEnteredValue, getExtendedValueFormula } from "@rowsncolumns/utils";
 import { produceWithPatches } from "immer";
+import { shiftChartsOnTableEdit, tableBinding } from "../api/anchored-objects";
 import { collectUniqueDependentsForRange, moveFormulaAtPosition, } from "../api/dependency";
 import { createSheetCellIdentifier, expandRangesInFormula } from "../api/formula";
 import { createSheetDraft } from "../api/immer-utils";
@@ -8,16 +9,30 @@ import { moveMergedCells } from "../api/merges";
 import { updateSheetRangeOnInsert } from "../api/range";
 import { moveFilterView } from "../api/selection";
 import { SheetCell } from "../sheet-cell";
-export const insertTableRow = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, }) => {
-    return (tableView, relativeRowIndex, rowData) => {
-        const referenceRowIndex = tableView.range.startRowIndex +
+import { getCalculatedColumnTemplate, getRowRelativeFormula, getTableFirstBodyRowIndex, } from "./change-table-column";
+export const insertTableRow = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCharts, onChangeDataValidations, onChangeConditionalFormats, }) => {
+    return (tableView, relativeRowIndex, rowData, 
+    // A caller folding the insert into its own history step (the totals-row
+    // toggle that must first shift occupied cells out of the way) passes its
+    // `saveHistory`; otherwise the insert is one undo step of its own.
+    saveHistory = createHistory()) => {
+        // `relativeRowIndex` counts from `range.startRowIndex` (the header row when
+        // there is one), clamped to the body: never above the first body row and,
+        // with a totals row, never below it — the new data row goes ABOVE the
+        // totals row, which moves down (Excel never inserts a data row below the
+        // totals).
+        const firstBodyRowIndex = tableView.range.startRowIndex + (tableView.headerRow ? 1 : 0);
+        const lastInsertRowIndex = tableView.range.endRowIndex + (tableView.totalRow ? 0 : 1);
+        const referenceRowIndex = Math.min(Math.max(tableView.range.startRowIndex +
             (relativeRowIndex ??
-                tableView.range.endRowIndex - tableView.range.startRowIndex + 1);
+                tableView.range.endRowIndex - tableView.range.startRowIndex + 1), Math.min(firstBodyRowIndex, lastInsertRowIndex)), lastInsertRowIndex);
+        const insertsAboveTotalRow = !!tableView.totalRow && referenceRowIndex === tableView.range.endRowIndex;
         const numRows = rowData?.length ?? 1;
         const { sheetId } = tableView;
         const { startColumnIndex, endColumnIndex } = tableView.range;
         const isInsideColumnBand = (range) => range.startColumnIndex >= startColumnIndex &&
             range.endColumnIndex <= endColumnIndex;
+        const binding = tableBinding(tableView);
         enqueueStructureChange?.({
             kind: "insert-table-row",
             sheetId,
@@ -27,7 +42,6 @@ export const insertTableRow = ({ rowCount, columnCount, locale, cellXfsRegistry,
             startColumnIndex: tableView.range.startColumnIndex,
             endColumnIndex: tableView.range.endColumnIndex,
         });
-        const saveHistory = createHistory();
         // We need to track this for history. Precedent cells
         const recalcCells = new Map();
         // Update table position
@@ -51,6 +65,15 @@ export const insertTableRow = ({ rowCount, columnCount, locale, cellXfsRegistry,
             });
             return nextState;
         });
+        // Chart ranges inside the table's columns follow the shifted cells; a range bound to the table
+        // (a column's body, or header + body) grows with it even when the rows land below the last one.
+        onChangeCharts?.((prevCharts) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+                shiftChartsOnTableEdit(draft, sheetId, binding, "row", "insert", referenceRowIndex, numRows);
+            });
+            saveHistory({ charts: { patches, inversePatches } });
+            return nextState;
+        });
         // Update data validations
         onChangeDataValidations?.((prevValidations) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevValidations, (draft) => {
@@ -139,11 +162,32 @@ export const insertTableRow = ({ rowCount, columnCount, locale, cellXfsRegistry,
         onChangeSheetData?.((prevSheetData) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
                 const totalRows = draft[sheetId]?.length ?? rowCount;
+                // Every cell of the table's columns from the insertion point shifts down — through the
+                // sheet's last used row, not just the table's — so formulas inside that band and
+                // references into it re-anchor over the whole band (mirrors `deleteTableRow`).
                 const sourceRange = {
                     ...tableView.range,
                     startRowIndex: referenceRowIndex,
+                    endRowIndex: Math.max(tableView.range.endRowIndex, totalRows - 1),
                 };
                 const movedKeys = new Set();
+                // Each calculated column's formula (written for the first body row), read from the
+                // body BEFORE the shift: the inserted rows inherit it (Excel).
+                const activeSheetName = getSheetName(sheetId);
+                const firstBodyRowIndex = getTableFirstBodyRowIndex(tableView);
+                const calculatedTemplates = new Map();
+                for (let columnIndex = tableView.range.startColumnIndex; columnIndex <= tableView.range.endColumnIndex; columnIndex++) {
+                    const template = getCalculatedColumnTemplate({
+                        draft,
+                        sheetId,
+                        table: tableView,
+                        columnIndex,
+                        activeSheetName,
+                    });
+                    if (template) {
+                        calculatedTemplates.set(columnIndex, template);
+                    }
+                }
                 /**
                  * THREE-PASS FORMULA UPDATE STRATEGY:
                  *
@@ -244,12 +288,12 @@ export const insertTableRow = ({ rowCount, columnCount, locale, cellXfsRegistry,
                     });
                 }
                 // PASS 3: Process formulas WITHIN the moved cells themselves
-                for (let rowIndex = referenceRowIndex; rowIndex < tableView.range.endRowIndex; rowIndex++) {
+                for (let rowIndex = referenceRowIndex; rowIndex <= sourceRange.endRowIndex; rowIndex++) {
                     const rowValues = draft[sheetId]?.[rowIndex]?.values;
                     if (!rowValues) {
                         continue;
                     }
-                    for (let columnIndex = tableView.range.startColumnIndex; columnIndex < tableView.range.endColumnIndex; columnIndex++) {
+                    for (let columnIndex = tableView.range.startColumnIndex; columnIndex <= tableView.range.endColumnIndex; columnIndex++) {
                         const cellData = rowValues?.[columnIndex];
                         const hasFormula = !!getExtendedValueFormula(getCellUserEnteredValue(cellData));
                         if (!hasFormula) {
@@ -281,29 +325,39 @@ export const insertTableRow = ({ rowCount, columnCount, locale, cellXfsRegistry,
                         currentSheet[rowIndex].values[columnIndex] = previousValue;
                     }
                 }
-                // Inserted rows: clone formatting from the row that shifted down (referenceRowIndex + numRows)
+                // Inserted rows: clone formatting from the row that shifted down (referenceRowIndex + numRows);
+                // when that row is the totals row, from the last data row above instead.
                 for (let r = 0; r < numRows; r++) {
                     const rowIndex = referenceRowIndex + r;
                     const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
                     const input = rowData?.[r];
+                    const formatSourceRowIndex = insertsAboveTotalRow
+                        ? referenceRowIndex - 1
+                        : rowIndex + numRows;
                     // Clone entire row formatting once
-                    const formatSourceRow = createSheetDraft(draft, sheetId, rowIndex + numRows);
+                    const formatSourceRow = createSheetDraft(draft, sheetId, formatSourceRowIndex);
                     const tempCell = new SheetCell();
                     for (let columnIndex = tableView.range.startColumnIndex; columnIndex <= tableView.range.endColumnIndex; columnIndex++) {
-                        const sourceCell = formatSourceRow[rowIndex + numRows]?.values?.[columnIndex];
+                        const sourceCell = formatSourceRow[formatSourceRowIndex]?.values?.[columnIndex];
                         const cloned = tempCell
                             .assign(sheetId, { rowIndex, columnIndex }, sourceCell)
                             .cloneWithFormatting();
                         const relativeColumnIndex = columnIndex - tableView.range.startColumnIndex;
                         const columnName = tableView.columns?.[relativeColumnIndex]?.name;
                         const cellValue = columnName ? input?.[columnName] : undefined;
+                        const template = calculatedTemplates.get(columnIndex);
+                        let inherited = false;
                         if (cellValue !== undefined && cellValue !== null) {
                             cloned.setUserEnteredValue(cellValue);
                         }
+                        else if (template) {
+                            cloned.setUserEnteredValue(getRowRelativeFormula(template, columnIndex, firstBodyRowIndex, rowIndex, activeSheetName));
+                            inherited = true;
+                        }
                         currentSheet[rowIndex].values[columnIndex] = cloned.getCellData();
                         // Enqueue for calculation
                         enqueueCalculation({
-                            type: "dirty",
+                            type: inherited ? "add" : "dirty",
                             position: { rowIndex, columnIndex, sheetId },
                         });
                         recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), { sheetId, rowIndex, columnIndex });
@@ -311,10 +365,11 @@ export const insertTableRow = ({ rowCount, columnCount, locale, cellXfsRegistry,
                 }
             });
             // Save history
+            const activeCell = getActiveCell?.();
             saveHistory({
                 sheetData: { patches, inversePatches },
                 recalcCells: { undo: recalcCells, redo: recalcCells },
-                activeCell: { undo: getActiveCell(), redo: getActiveCell() },
+                ...(activeCell ? { activeCell: { undo: activeCell, redo: activeCell } } : {}),
             });
             return nextState;
         });

package/dist/esm/interface/remove-duplicates.d.ts

@@ -8,5 +8,5 @@ export type RemoveDuplicatesResult = {
     uniqueRemaining: number;
 };
 export type { RemoveDuplicatesOptions };
-export declare const removeDuplicates: <T extends CellData>({ getFormattedValue, onChangeSheetData, enqueueCalculation, createHistory, }: UseOnRemoveDuplicatesProps<T>) => (sheetId: number, activeCell: CellInterface, selections?: SelectionArea<SelectionAttributes>[], options?: RemoveDuplicatesOptions) => RemoveDuplicatesResult;
+export declare const removeDuplicates: <T extends CellData>({ getFormattedValue, onChangeSheetData, onChangeTables, enqueueCalculation, createHistory, tables, }: UseOnRemoveDuplicatesProps<T>) => (sheetId: number, activeCell: CellInterface, selections?: SelectionArea<SelectionAttributes>[], options?: RemoveDuplicatesOptions) => RemoveDuplicatesResult;
 //# sourceMappingURL=remove-duplicates.d.ts.map

package/dist/esm/interface/remove-duplicates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remove-duplicates.d.ts","sourceRoot":"","sources":["../../../interface/remove-duplicates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EAEb,aAAa,EACd,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EACV,QAAQ,EACR,uBAAuB,EACvB,mBAAmB,EACpB,MAAM,2BAA2B,CAAC;AAKnC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAGpF,MAAM,MAAM,sBAAsB,GAAG;IACnC,iDAAiD;IACjD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,wCAAwC;IACxC,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,YAAY,EAAE,uBAAuB,EAAE,CAAC;AAiCxC,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,QAAQ,EAAE,8EAKlD,0BAA0B,CAAC,CAAC,CAAC,MAE5B,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,aAAa,aAAa,CAAC,mBAAmB,CAAC,EAAE,EACjD,UAAU,uBAAuB,KAChC,sBAyKJ,CAAC"}
+{"version":3,"file":"remove-duplicates.d.ts","sourceRoot":"","sources":["../../../interface/remove-duplicates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EAEb,aAAa,EACd,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EACV,QAAQ,EACR,uBAAuB,EACvB,mBAAmB,EAEpB,MAAM,2BAA2B,CAAC;AAKnC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAGpF,MAAM,MAAM,sBAAsB,GAAG;IACnC,iDAAiD;IACjD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,wCAAwC;IACxC,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,YAAY,EAAE,uBAAuB,EAAE,CAAC;AAgDxC,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,QAAQ,EAAE,sGAOlD,0BAA0B,CAAC,CAAC,CAAC,MAE5B,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,aAAa,aAAa,CAAC,mBAAmB,CAAC,EAAE,EACjD,UAAU,uBAAuB,KAChC,sBA0MJ,CAAC"}

package/dist/esm/interface/remove-duplicates.js

@@ -23,15 +23,35 @@ const resolveCompareColumns = (compareColumns, range) => {
         columnIndex <= range.endColumnIndex));
     return inRange.size ? inRange : undefined;
 };
-export const removeDuplicates = ({ getFormattedValue, onChangeSheetData, enqueueCalculation, createHistory, }) => {
+/** The table on `sheetId` whose range holds `cell`. */
+const findTableAtCell = (tables, sheetId, cell) => tables?.find(({ sheetId: tableSheetId, range }) => tableSheetId === sheetId &&
+    cell.rowIndex >= range.startRowIndex &&
+    cell.rowIndex <= range.endRowIndex &&
+    cell.columnIndex >= range.startColumnIndex &&
+    cell.columnIndex <= range.endColumnIndex);
+export const removeDuplicates = ({ getFormattedValue, onChangeSheetData, onChangeTables, enqueueCalculation, createHistory, tables, }) => {
     return (sheetId, activeCell, selections, options) => {
-        const finalSelections = selections?.length
-            ? selections
-            : selectionFromActiveCell(activeCell);
+        // Excel de-dupes the TABLE the active cell sits in, not the selection: the
+        // header row is pinned ("My data has headers" is forced on), the totals row
+        // stays out of the comparison and closes up under the survivors, and the
+        // table shrinks by the removed rows. Cells below the table never move.
+        const table = findTableAtCell(tables, sheetId, activeCell);
+        const finalSelections = table
+            ? [{ range: table.range }]
+            : selections?.length
+                ? selections
+                : selectionFromActiveCell(activeCell);
         const compareColumns = options?.columnIndices?.length
             ? new Set(options.columnIndices)
             : undefined;
-        const headerOffset = options?.hasHeader ? 1 : 0;
+        const headerOffset = table
+            ? table.headerRow !== false
+                ? 1
+                : 0
+            : options?.hasHeader
+                ? 1
+                : 0;
+        const pinnedTail = table?.totalRow ? 1 : 0;
         const saveHistory = createHistory();
         const recalcCells = new Map();
         const seenRows = new Set();
@@ -39,7 +59,7 @@ export const removeDuplicates = ({ getFormattedValue, onChangeSheetData, enqueue
         // First pass: collect all row data and identify duplicates
         for (const sel of finalSelections) {
             const selectionCompareColumns = resolveCompareColumns(compareColumns, sel.range);
-            for (let rowIndex = sel.range.startRowIndex + headerOffset; rowIndex <= sel.range.endRowIndex; rowIndex++) {
+            for (let rowIndex = sel.range.startRowIndex + headerOffset; rowIndex <= sel.range.endRowIndex - pinnedTail; rowIndex++) {
                 const rowValues = [];
                 for (let columnIndex = sel.range.startColumnIndex; columnIndex <= sel.range.endColumnIndex; columnIndex++) {
                     if (selectionCompareColumns &&
@@ -133,6 +153,21 @@ export const removeDuplicates = ({ getFormattedValue, onChangeSheetData, enqueue
             });
             return nextState;
         });
+        // The pinned totals row closed up under the survivors; the table shrinks
+        // onto it (the first occurrence of every row survives, so at least one data
+        // row always remains).
+        if (table) {
+            onChangeTables?.((prevTables) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                    const current = draft.find((t) => t.id === table.id);
+                    if (current) {
+                        current.range.endRowIndex -= duplicateRows.size;
+                    }
+                });
+                saveHistory({ tables: { patches, inversePatches } });
+                return nextState;
+            });
+        }
         return result;
     };
 };

package/dist/esm/interface/remove-table.d.ts

@@ -1,4 +1,4 @@
 import type { CellData, Sheet, TableView } from "@rowsncolumns/spreadsheet";
 import type { UseOnTableProps } from "../hooks/use-on-table";
-export declare const removeTable: <T extends CellData, S extends Sheet>({ onChangeTables, onChangeSheets, createHistory, getDependents, enqueueCalculation, }: Pick<UseOnTableProps<T, S>, "onChangeTables" | "onChangeSheets" | "getDependents" | "enqueueCalculation" | "createHistory">) => (tableView: TableView) => void;
+export declare const removeTable: <T extends CellData, S extends Sheet>({ locale, cellXfsRegistry, sharedStringRegistry, getSheetName, onChangeTables, onChangeSheets, onChangeSheetData, createHistory, getDependents, getGraphNodes, getBandedCells, enqueueCalculation, enqueueGraphOperation, }: Pick<UseOnTableProps<T, S>, "locale" | "cellXfsRegistry" | "sharedStringRegistry" | "getSheetName" | "onChangeTables" | "onChangeSheets" | "onChangeSheetData" | "getDependents" | "getGraphNodes" | "getBandedCells" | "enqueueCalculation" | "enqueueGraphOperation" | "createHistory">) => (tableView: TableView) => void;
 //# sourceMappingURL=remove-table.d.ts.map

package/dist/esm/interface/remove-table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remove-table.d.ts","sourceRoot":"","sources":["../../../interface/remove-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAG5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,uFAM9D,IAAI,CACL,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EACnB,gBAAgB,GAChB,gBAAgB,GAChB,eAAe,GACf,oBAAoB,GACpB,eAAe,CAClB,MACS,WAAW,SAAS,SAmE7B,CAAC"}
+{"version":3,"file":"remove-table.d.ts","sourceRoot":"","sources":["../../../interface/remove-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAK5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAI7D,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,6NAc9D,IAAI,CACL,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EACnB,QAAQ,GACR,iBAAiB,GACjB,sBAAsB,GACtB,cAAc,GACd,gBAAgB,GAChB,gBAAgB,GAChB,mBAAmB,GACnB,eAAe,GACf,eAAe,GACf,gBAAgB,GAChB,oBAAoB,GACpB,uBAAuB,GACvB,eAAe,CAClB,MACS,WAAW,SAAS,SAwH7B,CAAC"}

package/dist/esm/interface/remove-table.js

@@ -1,7 +1,48 @@
 import { produceWithPatches } from "immer";
-export const removeTable = ({ onChangeTables, onChangeSheets, createHistory, getDependents, enqueueCalculation, }) => {
+import { bakeBandedFormats } from "../api/paint-format";
+import { convertTableReferencesToA1InFormulas } from "../api/structural-table-refs";
+import { markTableAsDirty } from "./helpers";
+export const removeTable = ({ locale, cellXfsRegistry, sharedStringRegistry, getSheetName, onChangeTables, onChangeSheets, onChangeSheetData, createHistory, getDependents, getGraphNodes, getBandedCells, enqueueCalculation, enqueueGraphOperation, }) => {
     return (tableView) => {
         const saveHistory = createHistory();
+        const recalcCells = new Map();
+        // Convert to Range keeps every formula working and the table's look (Excel):
+        // the structured references into the table become the A1 ranges they
+        // resolved to, and the banding the grid painted under it becomes static cell
+        // formats, in this same history step, before the table (and with it their
+        // resolution and its style) goes away.
+        const bandedCells = getBandedCells?.(tableView.sheetId);
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                convertTableReferencesToA1InFormulas({
+                    draft,
+                    table: tableView,
+                    getSheetName,
+                    getGraphNodes,
+                    enqueueCalculation,
+                    enqueueGraphOperation,
+                    recalcCells,
+                    locale,
+                    cellXfsRegistry,
+                    sharedStringRegistry,
+                });
+                bakeBandedFormats({
+                    draft,
+                    sheetId: tableView.sheetId,
+                    range: tableView.range,
+                    bandedCells,
+                    locale,
+                    cellXfsRegistry,
+                    sharedStringRegistry,
+                });
+            });
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+        cellXfsRegistry?.getPatches(saveHistory);
         // Move tables if necessary
         onChangeTables?.((prevTables) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
@@ -11,20 +52,16 @@ export const removeTable = ({ onChangeTables, onChangeSheets, createHistory, get
                     draft.splice(tableIndex, 1);
                 }
             });
-            // Mark table cells as dirty
-            // const recalcCells = markTableAsDirty(
-            //   tableView.sheetId,
-            //   tableView.range,
-            //   getDependents,
-            //   enqueueCalculation
-            // );
             saveHistory({
                 tables: { patches, inversePatches },
-                // recalcCells: { undo: recalcCells, redo: recalcCells },
             });
             return nextState;
         });
-        // Remove hidden columns if user is removing table
+        // The table's filter goes with it: rows it hid become visible again. Their values did not
+        // change, so only the formulas that read visibility — `SUBTOTAL(101…111)` / `AGGREGATE` over
+        // those rows — are stale; dirtying the un-hidden cells recalculates exactly those dependents
+        // (the rewritten structured references were re-entered above with `force`).
+        const unhiddenRecalcCells = new Map();
         onChangeSheets((prevSheets) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
                 const sheet = draft.find((sheet) => sheet.sheetId === tableView.sheetId);
@@ -36,6 +73,9 @@ export const removeTable = ({ onChangeTables, onChangeSheets, createHistory, get
                     for (let rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
                         if (sheet.rowMetadata[rowIndex]?.hiddenByFilter) {
                             sheet.rowMetadata[rowIndex].hiddenByFilter = false;
+                            for (const [key, position] of markTableAsDirty(tableView.sheetId, { ...range, startRowIndex: rowIndex, endRowIndex: rowIndex }, getDependents, enqueueCalculation)) {
+                                unhiddenRecalcCells.set(key, position);
+                            }
                         }
                     }
                 }
@@ -43,6 +83,14 @@ export const removeTable = ({ onChangeTables, onChangeSheets, createHistory, get
             // Save to history
             saveHistory({
                 sheets: { patches, inversePatches },
+                ...(unhiddenRecalcCells.size
+                    ? {
+                        recalcCells: {
+                            undo: unhiddenRecalcCells,
+                            redo: unhiddenRecalcCells,
+                        },
+                    }
+                    : {}),
             });
             return nextState;
         });

package/dist/esm/interface/slicers.d.ts

@@ -1,6 +1,17 @@
-import type { Slicer } from "@rowsncolumns/spreadsheet";
+import type { Slicer, TableView } from "@rowsncolumns/spreadsheet";
 import { type CanvasGridProps, type CellData } from "@rowsncolumns/spreadsheet";
 import type { UseOnSlicersProps } from "../hooks/use-slicers";
+/** Excel's default slicer frame, and the cascade step between slicers inserted together. */
+export declare const TABLE_SLICER_WIDTH_PIXELS = 160;
+export declare const TABLE_SLICER_HEIGHT_PIXELS = 220;
+/** The column names Excel's Insert Slicers dialog lists for `table` (its columns, `Column N` for a gap). */
+export declare const getTableSlicerColumnNames: (table: TableView) => string[];
+/**
+ * The slicers Excel's Insert Slicers dialog creates for the checked `columnIndexes` (table-relative,
+ * 0-based) of `table`: one table-bound slicer per column, titled after the column, placed as a
+ * floating object just right of the table and cascaded so they don't stack exactly.
+ */
+export declare const buildTableSlicers: (table: TableView, columnIndexes: number[], createId?: (columnIndex: number) => Slicer["slicerId"]) => Slicer[];
 export declare const deleteSlicer: <T extends CellData>({ onChangeSlicers, createHistory, }: Omit<UseOnSlicersProps<T>, "sheetId">) => (slicerId: Slicer["slicerId"]) => void;
 export declare const updateSlicer: <T extends CellData>({ onChangeSlicers, createHistory, }: Omit<UseOnSlicersProps<T>, "sheetId">) => (slicer: Slicer) => void;
 export declare const moveSlicer: <T extends CellData>({ onChangeSlicers, createHistory, }: UseOnSlicersProps<T>) => NonNullable<CanvasGridProps["onMoveSlicer"]>;

package/dist/esm/interface/slicers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slicers.d.ts","sourceRoot":"","sources":["../../../interface/slicers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,QAAQ,EACd,MAAM,2BAA2B,CAAC;AAInC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAQ9D,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,qCAG9C,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC9B,UAAU,MAAM,CAAC,UAAU,CAAC,SAsBrC,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,qCAG9C,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC9B,QAAQ,MAAM,SAsBvB,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,QAAQ,EAAE,qCAG5C,iBAAiB,CAAC,CAAC,CAAC,KAAG,WAAW,CAAC,eAAe,CAAC,cAAc,CAAC,CA6BpE,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,qCAG9C,iBAAiB,CAAC,CAAC,CAAC,KAAG,WAAW,CAAC,eAAe,CAAC,gBAAgB,CAAC,CAuCtE,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,qCAG9C,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC9B,MAAM,MAAM,SAiBrB,CAAC"}
+{"version":3,"file":"slicers.d.ts","sourceRoot":"","sources":["../../../interface/slicers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,QAAQ,EACd,MAAM,2BAA2B,CAAC;AAKnC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAQ9D,4FAA4F;AAC5F,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAC7C,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAG9C,4GAA4G;AAC5G,eAAO,MAAM,yBAAyB,GAAI,OAAO,SAAS,KAAG,MAAM,EAOlE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAC5B,OAAO,SAAS,EAChB,eAAe,MAAM,EAAE,EACvB,WAAU,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,CAAC,UAAU,CACY,KAC/D,MAAM,EAwBR,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,qCAG9C,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC9B,UAAU,MAAM,CAAC,UAAU,CAAC,SAsBrC,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,qCAG9C,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC9B,QAAQ,MAAM,SAsBvB,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,QAAQ,EAAE,qCAG5C,iBAAiB,CAAC,CAAC,CAAC,KAAG,WAAW,CAAC,eAAe,CAAC,cAAc,CAAC,CAqCpE,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,qCAG9C,iBAAiB,CAAC,CAAC,CAAC,KAAG,WAAW,CAAC,eAAe,CAAC,gBAAgB,CAAC,CAyCtE,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,qCAG9C,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC9B,MAAM,MAAM,SAiBrB,CAAC"}

package/dist/esm/interface/slicers.js

@@ -1,10 +1,50 @@
 import { DEFAULT_ACTIVE_CELL } from "@rowsncolumns/utils";
 import { produceWithPatches } from "immer";
+import { setOverlayToAnchor } from "../api/anchored-objects";
 const DEFAULT_OVERLAY_POSITION = {
     anchorCell: DEFAULT_ACTIVE_CELL,
     heightPixels: 400,
     widthPixels: 400,
 };
+/** Excel's default slicer frame, and the cascade step between slicers inserted together. */
+export const TABLE_SLICER_WIDTH_PIXELS = 160;
+export const TABLE_SLICER_HEIGHT_PIXELS = 220;
+const TABLE_SLICER_CASCADE_PIXELS = 24;
+/** The column names Excel's Insert Slicers dialog lists for `table` (its columns, `Column N` for a gap). */
+export const getTableSlicerColumnNames = (table) => {
+    const count = table.range.endColumnIndex - table.range.startColumnIndex + 1;
+    return Array.from({ length: count }, (_, index) => table.columns?.[index]?.name || `Column${index + 1}`);
+};
+/**
+ * The slicers Excel's Insert Slicers dialog creates for the checked `columnIndexes` (table-relative,
+ * 0-based) of `table`: one table-bound slicer per column, titled after the column, placed as a
+ * floating object just right of the table and cascaded so they don't stack exactly.
+ */
+export const buildTableSlicers = (table, columnIndexes, createId = (columnIndex) => `slicer-${table.id}-${columnIndex}-${Date.now().toString(36)}`) => {
+    const names = getTableSlicerColumnNames(table);
+    return columnIndexes.map((columnIndex, order) => ({
+        slicerId: createId(columnIndex),
+        spec: {
+            type: "table",
+            tableIds: [table.id],
+            columnIndex,
+            title: names[columnIndex],
+        },
+        position: {
+            sheetId: table.sheetId,
+            overlayPosition: {
+                anchorCell: {
+                    rowIndex: table.range.startRowIndex,
+                    columnIndex: table.range.endColumnIndex + 1,
+                },
+                offsetXPixels: TABLE_SLICER_CASCADE_PIXELS * (order + 1),
+                offsetYPixels: TABLE_SLICER_CASCADE_PIXELS * order,
+                widthPixels: TABLE_SLICER_WIDTH_PIXELS,
+                heightPixels: TABLE_SLICER_HEIGHT_PIXELS,
+            },
+        },
+    }));
+};
 export const deleteSlicer = ({ onChangeSlicers, createHistory, }) => {
     return (slicerId) => {
         const saveHistory = createHistory();
@@ -40,7 +80,7 @@ export const updateSlicer = ({ onChangeSlicers, createHistory, }) => {
     };
 };
 export const moveSlicer = ({ onChangeSlicers, createHistory, }) => {
-    return (slicerId, sheetId, anchorCell, offsetXPixels, offsetYPixels) => {
+    return (slicerId, sheetId, anchorCell, offsetXPixels, offsetYPixels, toAnchor) => {
         const saveHistory = createHistory();
         onChangeSlicers?.((prevSlicers) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSlicers, (draft) => {
@@ -55,6 +95,7 @@ export const moveSlicer = ({ onChangeSlicers, createHistory, }) => {
                     slicer.position.overlayPosition.anchorCell = anchorCell;
                     slicer.position.overlayPosition.offsetXPixels = offsetXPixels;
                     slicer.position.overlayPosition.offsetYPixels = offsetYPixels;
+                    setOverlayToAnchor(slicer.position.overlayPosition, toAnchor);
                 }
             });
             saveHistory({
@@ -65,7 +106,7 @@ export const moveSlicer = ({ onChangeSlicers, createHistory, }) => {
     };
 };
 export const resizeSlicer = ({ onChangeSlicers, createHistory, }) => {
-    return (slicerId, sheetId, anchorCell, offsetXPixels, offsetYPixels, width, height) => {
+    return (slicerId, sheetId, anchorCell, offsetXPixels, offsetYPixels, width, height, toAnchor) => {
         const saveHistory = createHistory();
         onChangeSlicers?.((prevSlicers) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSlicers, (draft) => {
@@ -82,6 +123,7 @@ export const resizeSlicer = ({ onChangeSlicers, createHistory, }) => {
                     slicer.position.overlayPosition.offsetYPixels = offsetYPixels;
                     slicer.position.overlayPosition.widthPixels = width;
                     slicer.position.overlayPosition.heightPixels = height;
+                    setOverlayToAnchor(slicer.position.overlayPosition, toAnchor);
                 }
             });
             saveHistory({

package/dist/esm/interface/spreadsheet-interface.d.ts

@@ -8,7 +8,7 @@ import type { Patch } from "immer";
 import { type AutoFillType } from "../api/fill";
 import type { CalculationOperation, CalculationResult, StructureChange } from "../hooks/use-calculation";
 import type { OnChangeFormattingWithCellFormat, OnChangeFormattingWithTypeValue } from "../hooks/use-on-change-formatting";
-import type { SheetData } from "../hooks/use-spreadsheet-state";
+import { type SheetData } from "../hooks/use-spreadsheet-state";
 import type { HistoryType, SpreadsheetPatch } from "../hooks/use-undo-redo";
 import { CellXfsRegistry } from "../cellxfs-registry";
 import { SharedStringRegistry } from "../shared-string-registry";