@rowsncolumns/spreadsheet 10.2.76 → 10.3.0

package/dist/cjs/api/insert-options.d.ts

@@ -0,0 +1,67 @@
+import type { CellInterface, GridRange, SelectionArea } from "@rowsncolumns/grid";
+import type { CellFormat } from "../types";
+/**
+ * The paint-format call shape both engines accept from `onChangeFormatting`
+ * (`use-paint-format.ts` / rnc `change-formatting` with a `CellFormatOrGrid`):
+ * a row-major format grid tiled over the selections, `replace` clearing each
+ * target cell first.
+ */
+export type ChangeFormattingWithGrid = (sheetId: number, activeCell: CellInterface, selections: SelectionArea[], formats: (CellFormat | null)[][], options: {
+    replace: boolean;
+}) => void;
+export type InsertOptionsAxis = "row" | "column";
+/**
+ * Excel's Insert Options smart tag choices after a row insert ("Format Same
+ * As Above" / "Format Same As Below" / "Clear Formatting") — for a column
+ * insert the first two read "Left" / "Right". `before` is the neighbour the
+ * insert already copied (above / left), `after` the neighbour on the other
+ * side (below / right).
+ */
+export type InsertFormatOption = "before" | "after" | "clear";
+/** An inserted band: `count` rows (or columns) starting at `start`. */
+export type InsertedBand = {
+    axis: InsertOptionsAxis;
+    start: number;
+    count: number;
+};
+/** Reads a cell's user-entered format; `null`/`undefined` for an unformatted cell. */
+export type FormatReader = (rowIndex: number, columnIndex: number) => CellFormat | null | undefined;
+export type InsertFormatPlan = {
+    /** The band cells the formats are written over (one area). */
+    selections: SelectionArea[];
+    /**
+     * Row-major format grid tiled over `selections` by `onChangeFormatting`'s
+     * paint-format path (`{ replace: true }`): one source row for a row band
+     * (tiles down), one source column for a column band (tiles right). `null`
+     * entries clear the target cell's format.
+     */
+    formats: (CellFormat | null)[][];
+};
+/** The neighbour line an option copies from: `before` = above/left, `after` = below/right. */
+export declare const neighbourIndexForOption: (band: InsertedBand, option: Exclude<InsertFormatOption, "clear">) => number;
+/**
+ * The band as one grid area spanning the first `extent` cells across the
+ * other axis — `extent` bounds the write to the formatted part of the sheet
+ * instead of all 16,384 columns / 1,048,576 rows.
+ */
+export declare const insertedBandRange: (band: InsertedBand, extent: number) => GridRange;
+/**
+ * What re-choosing an Insert Options entry writes: the neighbour line's
+ * per-cell formats tiled over the inserted band (`{ replace: true }` so the
+ * previous choice's formats do not linger), or `null` when the neighbour has
+ * no formats at all — the caller then clears the band instead. `limit` caps
+ * the scan across the other axis (the sheet's column / row count).
+ */
+export declare const formatsForInsertOption: (band: InsertedBand, option: Exclude<InsertFormatOption, "clear">, read: FormatReader, limit: number) => InsertFormatPlan | null;
+/**
+ * The area "Clear Formatting" wipes: the formatted extent of the band itself
+ * (nothing to clear → `null`).
+ */
+export declare const clearRangeForInsertedBand: (band: InsertedBand, read: FormatReader, limit: number) => GridRange | null;
+/**
+ * True when any cell of the band (within the first `limit` cells across the
+ * other axis) holds a user-entered value. A fresh insert is blank, so a value
+ * means the insert was refused or the user has since typed into it.
+ */
+export declare const insertedBandHasValues: (band: InsertedBand, hasValue: (rowIndex: number, columnIndex: number) => boolean, limit: number) => boolean;
+//# sourceMappingURL=insert-options.d.ts.map

package/dist/cjs/api/insert-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-options.d.ts","sourceRoot":"","sources":["../../../api/insert-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,aAAa,EACd,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C;;;;;GAKG;AACH,MAAM,MAAM,wBAAwB,GAAG,CACrC,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,aAAa,EACzB,UAAU,EAAE,aAAa,EAAE,EAC3B,OAAO,EAAE,CAAC,UAAU,GAAG,IAAI,CAAC,EAAE,EAAE,EAChC,OAAO,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,KAC1B,IAAI,CAAC;AAEV,MAAM,MAAM,iBAAiB,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,CAAC;AAE9D,uEAAuE;AACvE,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,iBAAiB,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,sFAAsF;AACtF,MAAM,MAAM,YAAY,GAAG,CACzB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,UAAU,GAAG,IAAI,GAAG,SAAS,CAAC;AAEnC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,8DAA8D;IAC9D,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B;;;;;OAKG;IACH,OAAO,EAAE,CAAC,UAAU,GAAG,IAAI,CAAC,EAAE,EAAE,CAAC;CAClC,CAAC;AAwBF,8FAA8F;AAC9F,eAAO,MAAM,uBAAuB,GAClC,MAAM,YAAY,EAClB,QAAQ,OAAO,CAAC,kBAAkB,EAAE,OAAO,CAAC,WACuB,CAAC;AAEtE;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAC5B,MAAM,YAAY,EAClB,QAAQ,MAAM,KACb,SAaI,CAAC;AAER;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,GACjC,MAAM,YAAY,EAClB,QAAQ,OAAO,CAAC,kBAAkB,EAAE,OAAO,CAAC,EAC5C,MAAM,YAAY,EAClB,OAAO,MAAM,KACZ,gBAAgB,GAAG,IAqBrB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,yBAAyB,GACpC,MAAM,YAAY,EAClB,MAAM,YAAY,EAClB,OAAO,MAAM,KACZ,SAAS,GAAG,IASd,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAChC,MAAM,YAAY,EAClB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,EAC5D,OAAO,MAAM,YAWd,CAAC"}

package/dist/cjs/api/insert-options.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertedBandHasValues = exports.clearRangeForInsertedBand = exports.formatsForInsertOption = exports.insertedBandRange = exports.neighbourIndexForOption = void 0;
+var tslib_1 = require("tslib");
+var hasFormat = function (format) {
+    return !!format && Object.keys(format).length > 0;
+};
+/**
+ * Last formatted index along `axis` of the neighbour line `index` (a row when
+ * `axis` is `"row"`), scanning at most `limit` cells. `0` when the line holds
+ * no formats.
+ */
+var formattedExtent = function (read, axis, index, limit) {
+    var extent = 0;
+    for (var i = 1; i <= limit; i++) {
+        var format = axis === "row" ? read(index, i) : read(i, index);
+        if (hasFormat(format))
+            extent = i;
+    }
+    return extent;
+};
+/** The neighbour line an option copies from: `before` = above/left, `after` = below/right. */
+var neighbourIndexForOption = function (band, option) { return (option === "before" ? band.start - 1 : band.start + band.count); };
+exports.neighbourIndexForOption = neighbourIndexForOption;
+/**
+ * The band as one grid area spanning the first `extent` cells across the
+ * other axis — `extent` bounds the write to the formatted part of the sheet
+ * instead of all 16,384 columns / 1,048,576 rows.
+ */
+var insertedBandRange = function (band, extent) {
+    return band.axis === "row"
+        ? {
+            startRowIndex: band.start,
+            endRowIndex: band.start + band.count - 1,
+            startColumnIndex: 1,
+            endColumnIndex: Math.max(1, extent),
+        }
+        : {
+            startRowIndex: 1,
+            endRowIndex: Math.max(1, extent),
+            startColumnIndex: band.start,
+            endColumnIndex: band.start + band.count - 1,
+        };
+};
+exports.insertedBandRange = insertedBandRange;
+/**
+ * What re-choosing an Insert Options entry writes: the neighbour line's
+ * per-cell formats tiled over the inserted band (`{ replace: true }` so the
+ * previous choice's formats do not linger), or `null` when the neighbour has
+ * no formats at all — the caller then clears the band instead. `limit` caps
+ * the scan across the other axis (the sheet's column / row count).
+ */
+var formatsForInsertOption = function (band, option, read, limit) {
+    var neighbour = (0, exports.neighbourIndexForOption)(band, option);
+    if (neighbour < 1)
+        return null;
+    var sourceExtent = formattedExtent(read, band.axis, neighbour, limit);
+    // The band currently carries the formats of the earlier choice; the write
+    // must span those too so `replace` clears them.
+    var bandExtent = formattedExtent(read, band.axis, band.start, limit);
+    var extent = Math.max(sourceExtent, bandExtent);
+    if (extent === 0)
+        return null;
+    var line = [];
+    for (var i = 1; i <= extent; i++) {
+        var format = band.axis === "row" ? read(neighbour, i) : read(i, neighbour);
+        line.push(hasFormat(format) ? tslib_1.__assign({}, format) : null);
+    }
+    var formats = band.axis === "row" ? [line] : line.map(function (format) { return [format]; });
+    return {
+        selections: [{ range: (0, exports.insertedBandRange)(band, extent) }],
+        formats: formats,
+    };
+};
+exports.formatsForInsertOption = formatsForInsertOption;
+/**
+ * The area "Clear Formatting" wipes: the formatted extent of the band itself
+ * (nothing to clear → `null`).
+ */
+var clearRangeForInsertedBand = function (band, read, limit) {
+    var extent = 0;
+    for (var k = 0; k < band.count; k++) {
+        extent = Math.max(extent, formattedExtent(read, band.axis, band.start + k, limit));
+    }
+    return extent === 0 ? null : (0, exports.insertedBandRange)(band, extent);
+};
+exports.clearRangeForInsertedBand = clearRangeForInsertedBand;
+/**
+ * True when any cell of the band (within the first `limit` cells across the
+ * other axis) holds a user-entered value. A fresh insert is blank, so a value
+ * means the insert was refused or the user has since typed into it.
+ */
+var insertedBandHasValues = function (band, hasValue, limit) {
+    for (var k = 0; k < band.count; k++) {
+        var line = band.start + k;
+        for (var i = 1; i <= limit; i++) {
+            if (band.axis === "row" ? hasValue(line, i) : hasValue(i, line)) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+exports.insertedBandHasValues = insertedBandHasValues;

package/dist/cjs/api/move-overwrite.d.ts

@@ -0,0 +1,14 @@
+import type { GridRange } from "@rowsncolumns/grid";
+/** Excel's prompt before a plain drag-move overwrites non-empty destination cells. */
+export declare const MOVE_OVERWRITE_PROMPT = "There's already data here. Do you want to replace it?";
+/**
+ * Whether a plain (overwrite) drag-move from `from` to `to` needs Excel's
+ * "There's already data here. Do you want to replace it?" prompt: true when any
+ * destination cell OUTSIDE the source block holds a value. Cells the block itself
+ * currently occupies are never "data here" — they leave with the move — so an
+ * overlapping drag one cell over prompts only for the newly covered strip. An
+ * empty destination never prompts; Shift+drag (insert) and Ctrl+drag (copy) never
+ * reach this check.
+ */
+export declare const needsOverwritePrompt: (from: GridRange, to: GridRange, hasValue: (rowIndex: number, columnIndex: number) => boolean) => boolean;
+//# sourceMappingURL=move-overwrite.d.ts.map

package/dist/cjs/api/move-overwrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-overwrite.d.ts","sourceRoot":"","sources":["../../../api/move-overwrite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,sFAAsF;AACtF,eAAO,MAAM,qBAAqB,0DACuB,CAAC;AAE1D;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,GAC/B,MAAM,SAAS,EACf,IAAI,SAAS,EACb,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,KAC3D,OAkBF,CAAC"}

package/dist/cjs/api/move-overwrite.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.needsOverwritePrompt = exports.MOVE_OVERWRITE_PROMPT = void 0;
+/** Excel's prompt before a plain drag-move overwrites non-empty destination cells. */
+exports.MOVE_OVERWRITE_PROMPT = "There's already data here. Do you want to replace it?";
+/**
+ * Whether a plain (overwrite) drag-move from `from` to `to` needs Excel's
+ * "There's already data here. Do you want to replace it?" prompt: true when any
+ * destination cell OUTSIDE the source block holds a value. Cells the block itself
+ * currently occupies are never "data here" — they leave with the move — so an
+ * overlapping drag one cell over prompts only for the newly covered strip. An
+ * empty destination never prompts; Shift+drag (insert) and Ctrl+drag (copy) never
+ * reach this check.
+ */
+var needsOverwritePrompt = function (from, to, hasValue) {
+    for (var rowIndex = to.startRowIndex; rowIndex <= to.endRowIndex; rowIndex++) {
+        for (var columnIndex = to.startColumnIndex; columnIndex <= to.endColumnIndex; columnIndex++) {
+            var insideSource = rowIndex >= from.startRowIndex &&
+                rowIndex <= from.endRowIndex &&
+                columnIndex >= from.startColumnIndex &&
+                columnIndex <= from.endColumnIndex;
+            if (!insideSource && hasValue(rowIndex, columnIndex)) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+exports.needsOverwritePrompt = needsOverwritePrompt;

package/dist/cjs/api/multi-selection.d.ts

@@ -0,0 +1,59 @@
+import type { GridRange, SelectionArea } from "@rowsncolumns/grid";
+/**
+ * How Excel treats the areas of a multi-area (Ctrl-click) selection for the
+ * structural commands (rowsncolumns/spreadsheet#647 INS-08 / UI-07):
+ *
+ * - `single` — one area (or none): the normal Insert / Delete dialog path.
+ * - `all-rows` — every area is an entire-row band: insert / delete one block
+ *   per area, sized to that area, applied bottom-up.
+ * - `all-columns` — every area is an entire-column band: same, per column band.
+ * - `mixed` — any partial area, or rows mixed with columns: Excel refuses
+ *   with "That command cannot be used on multiple selections."
+ */
+export type MultiSelectionKind = "single" | "all-rows" | "all-columns" | "mixed";
+export type WholeBandPredicates = {
+    isWholeRow(range: GridRange): boolean;
+    isWholeColumn(range: GridRange): boolean;
+};
+/** Entire-row test for a sheet `columnCount` wide (the grid's left bound is column 1). */
+export declare const wholeRowPredicate: (columnCount: number, selectionLeftBound?: number) => (range: GridRange) => boolean;
+/** Entire-column test for a sheet `rowCount` tall (the grid's top bound is row 1). */
+export declare const wholeColumnPredicate: (rowCount: number, selectionTopBound?: number) => (range: GridRange) => boolean;
+/**
+ * Entire-row test when the sheet extent is unknown: the grid's row-header
+ * bookkeeping (`selectedRowHeadersIds`) already lists every row that belongs
+ * to a whole-row area, so an area is whole-row when its first and last rows
+ * are both listed.
+ */
+export declare const wholeRowPredicateFromHeaderIds: (rowHeaderIds: readonly number[]) => (range: GridRange) => boolean;
+export declare const wholeColumnPredicateFromHeaderIds: (columnHeaderIds: readonly number[]) => (range: GridRange) => boolean;
+export declare const classifyMultiSelection: (selections: readonly SelectionArea[], { isWholeRow, isWholeColumn }: WholeBandPredicates) => MultiSelectionKind;
+export type IndexBand = {
+    start: number;
+    end: number;
+};
+/**
+ * The bands (start..end, inclusive) a per-area structural command acts on,
+ * deduplicated and ordered bottom-up / right-to-left so inserting one block
+ * per band never shifts a band that is still to be processed (INS-08).
+ */
+export declare const bandsForAreas: (selections: readonly SelectionArea[], axis: "row" | "column") => IndexBand[];
+/**
+ * Groups header ids (e.g. `selectedRowHeadersIds`) into contiguous bands,
+ * bottom-up. Fallback for callers that only know which rows/columns are
+ * selected, not the areas they came from.
+ */
+export declare const bandsFromIndexes: (indexes: readonly number[]) => IndexBand[];
+/** Sorted, de-duplicated row (or column) indexes covered by ALL areas. */
+export declare const indexesForAreas: (selections: readonly SelectionArea[], axis: "row" | "column") => number[];
+export type InsertCellsChoice = "shift-right" | "shift-down" | "entire-row" | "entire-column";
+export type DeleteCellsChoice = "shift-left" | "shift-up" | "entire-row" | "entire-column";
+/**
+ * Excel pre-selects the shift that moves the fewest neighbours: a selection
+ * taller than it is wide shifts cells right; a wider-than-tall or square one
+ * shifts cells down (UI-06).
+ */
+export declare const defaultInsertCellsChoice: (range: GridRange) => InsertCellsChoice;
+/** Delete mirrors Insert: taller-than-wide → shift left, otherwise shift up. */
+export declare const defaultDeleteCellsChoice: (range: GridRange) => DeleteCellsChoice;
+//# sourceMappingURL=multi-selection.d.ts.map

package/dist/cjs/api/multi-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi-selection.d.ts","sourceRoot":"","sources":["../../../api/multi-selection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnE;;;;;;;;;;GAUG;AACH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,UAAU,GAAG,aAAa,GAAG,OAAO,CAAC;AAEjF,MAAM,MAAM,mBAAmB,GAAG;IAChC,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC;IACtC,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC;CAC1C,CAAC;AAEF,0FAA0F;AAC1F,eAAO,MAAM,iBAAiB,GAC3B,aAAa,MAAM,EAAE,2BAAsB,MAC3C,OAAO,SAAS,YAEoB,CAAC;AAExC,sFAAsF;AACtF,eAAO,MAAM,oBAAoB,GAC9B,UAAU,MAAM,EAAE,0BAAqB,MACvC,OAAO,SAAS,YAC0D,CAAC;AAE9E;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,GACxC,cAAc,SAAS,MAAM,EAAE,MAEtB,OAAO,SAAS,YAEzB,CAAC;AAEJ,eAAO,MAAM,iCAAiC,GAC3C,iBAAiB,SAAS,MAAM,EAAE,MAEzB,OAAO,SAAS,YAIzB,CAAC;AAEJ,eAAO,MAAM,sBAAsB,GACjC,YAAY,SAAS,aAAa,EAAE,EACpC,+BAA+B,mBAAmB,KACjD,kBAOF,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvD;;;;GAIG;AACH,eAAO,MAAM,aAAa,GACxB,YAAY,SAAS,aAAa,EAAE,EACpC,MAAM,KAAK,GAAG,QAAQ,KACrB,SAAS,EAcX,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,SAAS,MAAM,EAAE,KAAG,SAAS,EAYtE,CAAC;AAEF,0EAA0E;AAC1E,eAAO,MAAM,eAAe,GAC1B,YAAY,SAAS,aAAa,EAAE,EACpC,MAAM,KAAK,GAAG,QAAQ,KACrB,MAAM,EAUR,CAAC;AAEF,MAAM,MAAM,iBAAiB,GACzB,aAAa,GACb,YAAY,GACZ,YAAY,GACZ,eAAe,CAAC;AAEpB,MAAM,MAAM,iBAAiB,GACzB,YAAY,GACZ,UAAU,GACV,YAAY,GACZ,eAAe,CAAC;AAMpB;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GAAI,OAAO,SAAS,KAAG,iBACJ,CAAC;AAEzD,gFAAgF;AAChF,eAAO,MAAM,wBAAwB,GAAI,OAAO,SAAS,KAAG,iBACP,CAAC"}

package/dist/cjs/api/multi-selection.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultDeleteCellsChoice = exports.defaultInsertCellsChoice = exports.indexesForAreas = exports.bandsFromIndexes = exports.bandsForAreas = exports.classifyMultiSelection = exports.wholeColumnPredicateFromHeaderIds = exports.wholeRowPredicateFromHeaderIds = exports.wholeColumnPredicate = exports.wholeRowPredicate = void 0;
+var tslib_1 = require("tslib");
+/** Entire-row test for a sheet `columnCount` wide (the grid's left bound is column 1). */
+var wholeRowPredicate = function (columnCount, selectionLeftBound) {
+    if (selectionLeftBound === void 0) { selectionLeftBound = 1; }
+    return function (range) {
+        return range.startColumnIndex <= selectionLeftBound &&
+            range.endColumnIndex >= columnCount;
+    };
+};
+exports.wholeRowPredicate = wholeRowPredicate;
+/** Entire-column test for a sheet `rowCount` tall (the grid's top bound is row 1). */
+var wholeColumnPredicate = function (rowCount, selectionTopBound) {
+    if (selectionTopBound === void 0) { selectionTopBound = 1; }
+    return function (range) {
+        return range.startRowIndex <= selectionTopBound && range.endRowIndex >= rowCount;
+    };
+};
+exports.wholeColumnPredicate = wholeColumnPredicate;
+/**
+ * Entire-row test when the sheet extent is unknown: the grid's row-header
+ * bookkeeping (`selectedRowHeadersIds`) already lists every row that belongs
+ * to a whole-row area, so an area is whole-row when its first and last rows
+ * are both listed.
+ */
+var wholeRowPredicateFromHeaderIds = function (rowHeaderIds) {
+    var ids = new Set(rowHeaderIds);
+    return function (range) {
+        return ids.size > 0 && ids.has(range.startRowIndex) && ids.has(range.endRowIndex);
+    };
+};
+exports.wholeRowPredicateFromHeaderIds = wholeRowPredicateFromHeaderIds;
+var wholeColumnPredicateFromHeaderIds = function (columnHeaderIds) {
+    var ids = new Set(columnHeaderIds);
+    return function (range) {
+        return ids.size > 0 &&
+            ids.has(range.startColumnIndex) &&
+            ids.has(range.endColumnIndex);
+    };
+};
+exports.wholeColumnPredicateFromHeaderIds = wholeColumnPredicateFromHeaderIds;
+var classifyMultiSelection = function (selections, _a) {
+    var isWholeRow = _a.isWholeRow, isWholeColumn = _a.isWholeColumn;
+    if (selections.length <= 1)
+        return "single";
+    if (selections.every(function (_a) {
+        var range = _a.range;
+        return isWholeRow(range);
+    }))
+        return "all-rows";
+    if (selections.every(function (_a) {
+        var range = _a.range;
+        return isWholeColumn(range);
+    })) {
+        return "all-columns";
+    }
+    return "mixed";
+};
+exports.classifyMultiSelection = classifyMultiSelection;
+/**
+ * The bands (start..end, inclusive) a per-area structural command acts on,
+ * deduplicated and ordered bottom-up / right-to-left so inserting one block
+ * per band never shifts a band that is still to be processed (INS-08).
+ */
+var bandsForAreas = function (selections, axis) {
+    var e_1, _a;
+    var seen = new Set();
+    var bands = [];
+    try {
+        for (var selections_1 = tslib_1.__values(selections), selections_1_1 = selections_1.next(); !selections_1_1.done; selections_1_1 = selections_1.next()) {
+            var range = selections_1_1.value.range;
+            var band = axis === "row"
+                ? { start: range.startRowIndex, end: range.endRowIndex }
+                : { start: range.startColumnIndex, end: range.endColumnIndex };
+            var key = "".concat(band.start, ":").concat(band.end);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            bands.push(band);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (selections_1_1 && !selections_1_1.done && (_a = selections_1.return)) _a.call(selections_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return bands.sort(function (a, b) { return b.start - a.start; });
+};
+exports.bandsForAreas = bandsForAreas;
+/**
+ * Groups header ids (e.g. `selectedRowHeadersIds`) into contiguous bands,
+ * bottom-up. Fallback for callers that only know which rows/columns are
+ * selected, not the areas they came from.
+ */
+var bandsFromIndexes = function (indexes) {
+    var e_2, _a;
+    var sorted = Array.from(new Set(indexes)).sort(function (a, b) { return a - b; });
+    var bands = [];
+    try {
+        for (var sorted_1 = tslib_1.__values(sorted), sorted_1_1 = sorted_1.next(); !sorted_1_1.done; sorted_1_1 = sorted_1.next()) {
+            var index = sorted_1_1.value;
+            var last = bands[bands.length - 1];
+            if (last && index === last.end + 1) {
+                last.end = index;
+            }
+            else {
+                bands.push({ start: index, end: index });
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (sorted_1_1 && !sorted_1_1.done && (_a = sorted_1.return)) _a.call(sorted_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return bands.sort(function (a, b) { return b.start - a.start; });
+};
+exports.bandsFromIndexes = bandsFromIndexes;
+/** Sorted, de-duplicated row (or column) indexes covered by ALL areas. */
+var indexesForAreas = function (selections, axis) {
+    var e_3, _a;
+    var indexes = new Set();
+    try {
+        for (var selections_2 = tslib_1.__values(selections), selections_2_1 = selections_2.next(); !selections_2_1.done; selections_2_1 = selections_2.next()) {
+            var range = selections_2_1.value.range;
+            var _b = tslib_1.__read(axis === "row"
+                ? [range.startRowIndex, range.endRowIndex]
+                : [range.startColumnIndex, range.endColumnIndex], 2), start = _b[0], end = _b[1];
+            for (var index = start; index <= end; index++)
+                indexes.add(index);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (selections_2_1 && !selections_2_1.done && (_a = selections_2.return)) _a.call(selections_2);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return Array.from(indexes).sort(function (a, b) { return a - b; });
+};
+exports.indexesForAreas = indexesForAreas;
+var isTallerThanWide = function (range) {
+    return range.endRowIndex - range.startRowIndex >
+        range.endColumnIndex - range.startColumnIndex;
+};
+/**
+ * Excel pre-selects the shift that moves the fewest neighbours: a selection
+ * taller than it is wide shifts cells right; a wider-than-tall or square one
+ * shifts cells down (UI-06).
+ */
+var defaultInsertCellsChoice = function (range) {
+    return isTallerThanWide(range) ? "shift-right" : "shift-down";
+};
+exports.defaultInsertCellsChoice = defaultInsertCellsChoice;
+/** Delete mirrors Insert: taller-than-wide → shift left, otherwise shift up. */
+var defaultDeleteCellsChoice = function (range) {
+    return isTallerThanWide(range) ? "shift-left" : "shift-up";
+};
+exports.defaultDeleteCellsChoice = defaultDeleteCellsChoice;

package/dist/cjs/atoms/index.d.ts

@@ -19,7 +19,10 @@ export * from "./validation-alert.atom";
 export * from "./sort-dialog.atom";
 export * from "./paste-special-dialog.atom";
 export * from "./go-to-dialog.atom";
+export * from "./move-overwrite-confirm.atom";
 export * from "./evaluate-formula-dialog.atom";
 export * from "./remove-duplicates-dialog.atom";
 export * from "./watch-window.atom";
+export * from "./insert-cells-dialog.atom";
+export * from "./insert-options.atom";
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/atoms/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../atoms/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iCAAiC,CAAC;AAChD,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,iCAAiC,CAAC;AAChD,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../atoms/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iCAAiC,CAAC;AAChD,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,iCAAiC,CAAC;AAChD,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC"}

package/dist/cjs/atoms/index.js

@@ -24,6 +24,9 @@ tslib_1.__exportStar(require("./validation-alert.atom"), exports);
 tslib_1.__exportStar(require("./sort-dialog.atom"), exports);
 tslib_1.__exportStar(require("./paste-special-dialog.atom"), exports);
 tslib_1.__exportStar(require("./go-to-dialog.atom"), exports);
+tslib_1.__exportStar(require("./move-overwrite-confirm.atom"), exports);
 tslib_1.__exportStar(require("./evaluate-formula-dialog.atom"), exports);
 tslib_1.__exportStar(require("./remove-duplicates-dialog.atom"), exports);
 tslib_1.__exportStar(require("./watch-window.atom"), exports);
+tslib_1.__exportStar(require("./insert-cells-dialog.atom"), exports);
+tslib_1.__exportStar(require("./insert-options.atom"), exports);

package/dist/cjs/atoms/insert-cells-dialog.atom.d.ts

@@ -0,0 +1,36 @@
+import type { DeleteCellsChoice, InsertCellsChoice } from "../api/multi-selection";
+/**
+ * Open-state + payload for Excel's Insert / Delete cells dialog (right-click a
+ * cell → "Insert…" / "Delete…", `Ctrl` + `+` / `-` on a cell selection). The
+ * grid opens it with the shape-derived default; the host-mounted dialog routes
+ * the chosen entry back through `onApply`, and the opener dispatches the
+ * matching structural command (shift cells / entire row / entire column).
+ */
+export type InsertCellsDialogRequest = {
+    mode: "insert";
+    defaultChoice: InsertCellsChoice;
+    onApply: (choice: InsertCellsChoice) => void;
+} | {
+    mode: "delete";
+    defaultChoice: DeleteCellsChoice;
+    onApply: (choice: DeleteCellsChoice) => void;
+};
+export declare const insertCellsDialogAtom: import("jotai").PrimitiveAtom<InsertCellsDialogRequest | null> & {
+    init: InsertCellsDialogRequest | null;
+};
+export declare const useInsertCellsDialogState: () => [InsertCellsDialogRequest | null, (args_0: InsertCellsDialogRequest | ((prev: InsertCellsDialogRequest | null) => InsertCellsDialogRequest | null) | null) => void];
+/**
+ * Number of mounted `InsertCellsDialogHost`s. The context menu only offers the
+ * dialog entry while a host is mounted; without one it keeps the direct
+ * submenu so a host that has not adopted the dialog never gets a dead item.
+ */
+export declare const insertCellsDialogHostCountAtom: import("jotai").PrimitiveAtom<number> & {
+    init: number;
+};
+/** True when at least one `InsertCellsDialogHost` is mounted. */
+export declare const useIsInsertCellsDialogMounted: () => boolean;
+/** Registers the calling component as a dialog host for its lifetime. */
+export declare const useRegisterInsertCellsDialogHost: () => void;
+/** Returns a function that opens the host-mounted Insert / Delete cells dialog. */
+export declare const useOpenInsertCellsDialog: () => (request: InsertCellsDialogRequest) => void;
+//# sourceMappingURL=insert-cells-dialog.atom.d.ts.map

package/dist/cjs/atoms/insert-cells-dialog.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-cells-dialog.atom.d.ts","sourceRoot":"","sources":["../../../atoms/insert-cells-dialog.atom.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAEhC;;;;;;GAMG;AACH,MAAM,MAAM,wBAAwB,GAChC;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,aAAa,EAAE,iBAAiB,CAAC;IACjC,OAAO,EAAE,CAAC,MAAM,EAAE,iBAAiB,KAAK,IAAI,CAAC;CAC9C,GACD;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,aAAa,EAAE,iBAAiB,CAAC;IACjC,OAAO,EAAE,CAAC,MAAM,EAAE,iBAAiB,KAAK,IAAI,CAAC;CAC9C,CAAC;AAEN,eAAO,MAAM,qBAAqB;;CAEjC,CAAC;AAEF,eAAO,MAAM,yBAAyB,2KAAuC,CAAC;AAE9E;;;;GAIG;AACH,eAAO,MAAM,8BAA8B;;CAAU,CAAC;AAEtD,iEAAiE;AACjE,eAAO,MAAM,6BAA6B,eACQ,CAAC;AAEnD,yEAAyE;AACzE,eAAO,MAAM,gCAAgC,YAM5C,CAAC;AAEF,mFAAmF;AACnF,eAAO,MAAM,wBAAwB,kBAGvB,wBAAwB,SAGrC,CAAC"}

package/dist/cjs/atoms/insert-cells-dialog.atom.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOpenInsertCellsDialog = exports.useRegisterInsertCellsDialogHost = exports.useIsInsertCellsDialogMounted = exports.insertCellsDialogHostCountAtom = exports.useInsertCellsDialogState = exports.insertCellsDialogAtom = void 0;
+var jotai_1 = require("jotai");
+var react_1 = require("react");
+exports.insertCellsDialogAtom = (0, jotai_1.atom)(null);
+var useInsertCellsDialogState = function () { return (0, jotai_1.useAtom)(exports.insertCellsDialogAtom); };
+exports.useInsertCellsDialogState = useInsertCellsDialogState;
+/**
+ * Number of mounted `InsertCellsDialogHost`s. The context menu only offers the
+ * dialog entry while a host is mounted; without one it keeps the direct
+ * submenu so a host that has not adopted the dialog never gets a dead item.
+ */
+exports.insertCellsDialogHostCountAtom = (0, jotai_1.atom)(0);
+/** True when at least one `InsertCellsDialogHost` is mounted. */
+var useIsInsertCellsDialogMounted = function () {
+    return (0, jotai_1.useAtomValue)(exports.insertCellsDialogHostCountAtom) > 0;
+};
+exports.useIsInsertCellsDialogMounted = useIsInsertCellsDialogMounted;
+/** Registers the calling component as a dialog host for its lifetime. */
+var useRegisterInsertCellsDialogHost = function () {
+    var setCount = (0, jotai_1.useSetAtom)(exports.insertCellsDialogHostCountAtom);
+    (0, react_1.useEffect)(function () {
+        setCount(function (count) { return count + 1; });
+        return function () { return setCount(function (count) { return count - 1; }); };
+    }, [setCount]);
+};
+exports.useRegisterInsertCellsDialogHost = useRegisterInsertCellsDialogHost;
+/** Returns a function that opens the host-mounted Insert / Delete cells dialog. */
+var useOpenInsertCellsDialog = function () {
+    var setRequest = (0, jotai_1.useSetAtom)(exports.insertCellsDialogAtom);
+    return (0, react_1.useCallback)(function (request) { return setRequest(request); }, [setRequest]);
+};
+exports.useOpenInsertCellsDialog = useOpenInsertCellsDialog;

package/dist/cjs/atoms/insert-options.atom.d.ts

@@ -0,0 +1,21 @@
+import type { InsertedBand, InsertFormatOption } from "../api/insert-options";
+/**
+ * A just-inserted row / column band waiting for the user to (re)choose how it
+ * is formatted — Excel's Insert Options smart tag ("Format Same As Above /
+ * Below / Clear Formatting"; "Left / Right" for columns). The insert already
+ * applied `before` (the row above / column to the left); choosing another
+ * entry re-formats the band from the other neighbour, or clears it. Dropped
+ * on the next click elsewhere (a new active cell) or sheet switch.
+ */
+export type InsertOptionsRequest = InsertedBand & {
+    sheetId: number;
+    /** The entry currently applied to the band. */
+    option: InsertFormatOption;
+};
+export declare const insertOptionsAtom: import("jotai").PrimitiveAtom<InsertOptionsRequest | null> & {
+    init: InsertOptionsRequest | null;
+};
+export declare const useInsertOptionsState: () => [InsertOptionsRequest | null, (args_0: InsertOptionsRequest | ((prev: InsertOptionsRequest | null) => InsertOptionsRequest | null) | null) => void];
+export declare const useInsertOptionsValue: () => InsertOptionsRequest | null;
+export declare const useSetInsertOptions: () => (args_0: InsertOptionsRequest | ((prev: InsertOptionsRequest | null) => InsertOptionsRequest | null) | null) => void;
+//# sourceMappingURL=insert-options.atom.d.ts.map

package/dist/cjs/atoms/insert-options.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-options.atom.d.ts","sourceRoot":"","sources":["../../../atoms/insert-options.atom.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE9E;;;;;;;GAOG;AACH,MAAM,MAAM,oBAAoB,GAAG,YAAY,GAAG;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,MAAM,EAAE,kBAAkB,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;CAA0C,CAAC;AAEzE,eAAO,MAAM,qBAAqB,2JAAmC,CAAC;AACtE,eAAO,MAAM,qBAAqB,mCAAwC,CAAC;AAC3E,eAAO,MAAM,mBAAmB,4HAAsC,CAAC"}

package/dist/cjs/atoms/insert-options.atom.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSetInsertOptions = exports.useInsertOptionsValue = exports.useInsertOptionsState = exports.insertOptionsAtom = void 0;
+var jotai_1 = require("jotai");
+exports.insertOptionsAtom = (0, jotai_1.atom)(null);
+var useInsertOptionsState = function () { return (0, jotai_1.useAtom)(exports.insertOptionsAtom); };
+exports.useInsertOptionsState = useInsertOptionsState;
+var useInsertOptionsValue = function () { return (0, jotai_1.useAtomValue)(exports.insertOptionsAtom); };
+exports.useInsertOptionsValue = useInsertOptionsValue;
+var useSetInsertOptions = function () { return (0, jotai_1.useSetAtom)(exports.insertOptionsAtom); };
+exports.useSetInsertOptions = useSetInsertOptions;

package/dist/cjs/atoms/move-overwrite-confirm.atom.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Open-state + payload for the drag-move overwrite prompt (Excel: "There's
+ * already data here. Do you want to replace it?"). The grid raises it from the
+ * selection-border drop; the host-mounted dialog answers through `resolve`.
+ */
+export type MoveOverwriteConfirmRequest = {
+    message: string;
+    resolve: (replace: boolean) => void;
+};
+export declare const moveOverwriteConfirmAtom: import("jotai").PrimitiveAtom<MoveOverwriteConfirmRequest | null> & {
+    init: MoveOverwriteConfirmRequest | null;
+};
+export declare const useMoveOverwriteConfirmState: () => [MoveOverwriteConfirmRequest | null, (args_0: MoveOverwriteConfirmRequest | ((prev: MoveOverwriteConfirmRequest | null) => MoveOverwriteConfirmRequest | null) | null) => void];
+/** Number of mounted `MoveOverwriteConfirmDialogHost`s. */
+export declare const moveOverwriteConfirmHostCountAtom: import("jotai").PrimitiveAtom<number> & {
+    init: number;
+};
+/** True when a host has mounted the dialog; otherwise the grid falls back to `window.confirm`. */
+export declare const useIsMoveOverwriteConfirmMounted: () => boolean;
+/** Registers the calling component as a dialog host for its lifetime. */
+export declare const useRegisterMoveOverwriteConfirmHost: () => void;
+/** Returns a function that opens the host-mounted prompt and resolves with the user's answer. */
+export declare const useOpenMoveOverwriteConfirm: () => (message: string) => Promise<boolean>;
+//# sourceMappingURL=move-overwrite-confirm.atom.d.ts.map

package/dist/cjs/atoms/move-overwrite-confirm.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-overwrite-confirm.atom.d.ts","sourceRoot":"","sources":["../../../atoms/move-overwrite-confirm.atom.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,MAAM,MAAM,2BAA2B,GAAG;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;CACrC,CAAC;AAEF,eAAO,MAAM,wBAAwB;;CAEpC,CAAC;AAEF,eAAO,MAAM,4BAA4B,uLACN,CAAC;AAEpC,2DAA2D;AAC3D,eAAO,MAAM,iCAAiC;;CAAU,CAAC;AAEzD,kGAAkG;AAClG,eAAO,MAAM,gCAAgC,eACQ,CAAC;AAEtD,yEAAyE;AACzE,eAAO,MAAM,mCAAmC,YAM/C,CAAC;AAEF,iGAAiG;AACjG,eAAO,MAAM,2BAA2B,kBAG1B,MAAM,qBAYnB,CAAC"}