@rowsncolumns/spreadsheet 10.6.5 → 10.7.0

package/dist/cjs/api/autocomplete.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Excel's AutoComplete for cell values (support.microsoft.com "Turn automatic
+ * completion of cell entries on or off"): while you type text in a cell,
+ * Excel completes it from the entries already in the same column, once the
+ * typed characters match exactly one of them. Only entries that contain text
+ * are offered; entries that are only numbers, dates or times are not.
+ */
+/** What a column cell holds, for AutoComplete: a text entry, another value, or nothing. */
+export type AutoCompleteCell = {
+    text: string;
+} | "value" | null;
+/** How far up and down the contiguous block is scanned (a bound on a huge column). */
+export declare const AUTOCOMPLETE_SCAN_LIMIT = 5000;
+/**
+ * The distinct text entries of the column's contiguous block around `rowIndex`:
+ * the cells directly above and below the edited cell up to the first blank
+ * cell on each side (the edited cell itself is skipped). Numbers, dates and
+ * other non-text values keep the block going but are not entries. Duplicates
+ * differing only in case are listed once, with the first spelling found.
+ */
+export declare const getColumnAutoCompleteEntries: ({ rowIndex, getCell, minRowIndex, maxRowIndex, limit, }: {
+    rowIndex: number;
+    getCell(rowIndex: number): AutoCompleteCell;
+    minRowIndex?: number;
+    maxRowIndex: number;
+    limit?: number;
+}) => string[];
+/**
+ * The entry `typed` completes to, or `undefined`. Case-insensitive prefix
+ * match; Excel waits until the typed characters identify ONE entry, so a
+ * prefix shared by two distinct entries (or one that already equals an entry
+ * another entry extends) completes nothing.
+ */
+export declare const findAutoCompleteMatch: (typed: string, entries: string[]) => string | undefined;
+/**
+ * A text cell value for AutoComplete: a text constant that is not only a
+ * number, a date or a time. `null` = blank.
+ */
+export declare const toAutoCompleteCell: (userEnteredValue: Partial<Record<"sv" | "stringValue" | "fv" | "formulaValue" | "nv" | "numberValue" | "bv" | "boolValue", unknown>> | null | undefined) => AutoCompleteCell;
+/** Excel's Pick From Drop-down List: the block's entries, sorted A to Z. */
+export declare const getPickListEntries: (entries: string[]) => string[];
+//# sourceMappingURL=autocomplete.d.ts.map

package/dist/cjs/api/autocomplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocomplete.d.ts","sourceRoot":"","sources":["../../../api/autocomplete.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,2FAA2F;AAC3F,MAAM,MAAM,gBAAgB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,GAAG,IAAI,CAAC;AAEjE,sFAAsF;AACtF,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAE5C;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,GAAI,yDAM1C;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAAC;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,KAAG,MAAM,EAuBT,CAAC;AASF;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAChC,OAAO,MAAM,EACb,SAAS,MAAM,EAAE,KAChB,MAAM,GAAG,SAUX,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAC7B,kBAAkB,OAAO,CACvB,MAAM,CACF,IAAI,GACJ,aAAa,GACb,IAAI,GACJ,cAAc,GACd,IAAI,GACJ,aAAa,GACb,IAAI,GACJ,WAAW,EACb,OAAO,CACR,CACF,GAAG,IAAI,GAAG,SAAS,KACnB,gBAaF,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,kBAAkB,GAAI,SAAS,MAAM,EAAE,KAAG,MAAM,EACwB,CAAC"}

package/dist/cjs/api/autocomplete.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * Excel's AutoComplete for cell values (support.microsoft.com "Turn automatic
+ * completion of cell entries on or off"): while you type text in a cell,
+ * Excel completes it from the entries already in the same column, once the
+ * typed characters match exactly one of them. Only entries that contain text
+ * are offered; entries that are only numbers, dates or times are not.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPickListEntries = exports.toAutoCompleteCell = exports.findAutoCompleteMatch = exports.getColumnAutoCompleteEntries = exports.AUTOCOMPLETE_SCAN_LIMIT = void 0;
+var tslib_1 = require("tslib");
+/** How far up and down the contiguous block is scanned (a bound on a huge column). */
+exports.AUTOCOMPLETE_SCAN_LIMIT = 5000;
+/**
+ * The distinct text entries of the column's contiguous block around `rowIndex`:
+ * the cells directly above and below the edited cell up to the first blank
+ * cell on each side (the edited cell itself is skipped). Numbers, dates and
+ * other non-text values keep the block going but are not entries. Duplicates
+ * differing only in case are listed once, with the first spelling found.
+ */
+var getColumnAutoCompleteEntries = function (_a) {
+    var rowIndex = _a.rowIndex, getCell = _a.getCell, _b = _a.minRowIndex, minRowIndex = _b === void 0 ? 1 : _b, maxRowIndex = _a.maxRowIndex, _c = _a.limit, limit = _c === void 0 ? exports.AUTOCOMPLETE_SCAN_LIMIT : _c;
+    var entries = [];
+    var seen = new Set();
+    var visit = function (r) {
+        var cell = getCell(r);
+        if (cell === null)
+            return false;
+        if (cell !== "value") {
+            var text = cell.text;
+            var key = text.toLowerCase();
+            if (text.trim() && !seen.has(key)) {
+                seen.add(key);
+                entries.push(text);
+            }
+        }
+        return true;
+    };
+    for (var r = rowIndex - 1, n = 0; r >= minRowIndex && n < limit; r--, n++) {
+        if (!visit(r))
+            break;
+    }
+    for (var r = rowIndex + 1, n = 0; r <= maxRowIndex && n < limit; r++, n++) {
+        if (!visit(r))
+            break;
+    }
+    return entries;
+};
+exports.getColumnAutoCompleteEntries = getColumnAutoCompleteEntries;
+/** A typed entry Excel would never complete: empty, a formula, or a number / date / time. */
+var isCompletable = function (typed) {
+    if (!typed || typed.includes("\n"))
+        return false;
+    if (typed.startsWith("=") || typed.startsWith("+") || typed.startsWith("-"))
+        return false;
+    return true;
+};
+/**
+ * The entry `typed` completes to, or `undefined`. Case-insensitive prefix
+ * match; Excel waits until the typed characters identify ONE entry, so a
+ * prefix shared by two distinct entries (or one that already equals an entry
+ * another entry extends) completes nothing.
+ */
+var findAutoCompleteMatch = function (typed, entries) {
+    var e_1, _a;
+    if (!isCompletable(typed))
+        return undefined;
+    var lower = typed.toLowerCase();
+    var match;
+    try {
+        for (var entries_1 = tslib_1.__values(entries), entries_1_1 = entries_1.next(); !entries_1_1.done; entries_1_1 = entries_1.next()) {
+            var entry = entries_1_1.value;
+            if (!entry.toLowerCase().startsWith(lower))
+                continue;
+            if (match !== undefined)
+                return undefined;
+            match = entry;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) _a.call(entries_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return match && match.length > typed.length ? match : undefined;
+};
+exports.findAutoCompleteMatch = findAutoCompleteMatch;
+/**
+ * A text cell value for AutoComplete: a text constant that is not only a
+ * number, a date or a time. `null` = blank.
+ */
+var toAutoCompleteCell = function (userEnteredValue) {
+    var _a, _b, _c, _d;
+    if (!userEnteredValue)
+        return null;
+    var present = function (value) { return value !== undefined && value !== null; };
+    var formula = (_a = userEnteredValue.fv) !== null && _a !== void 0 ? _a : userEnteredValue.formulaValue;
+    var text = (_b = userEnteredValue.sv) !== null && _b !== void 0 ? _b : userEnteredValue.stringValue;
+    if (!present(formula) && typeof text === "string") {
+        return text === "" ? null : { text: text };
+    }
+    var hasValue = present(formula) ||
+        present((_c = userEnteredValue.nv) !== null && _c !== void 0 ? _c : userEnteredValue.numberValue) ||
+        present((_d = userEnteredValue.bv) !== null && _d !== void 0 ? _d : userEnteredValue.boolValue);
+    return hasValue ? "value" : null;
+};
+exports.toAutoCompleteCell = toAutoCompleteCell;
+/** Excel's Pick From Drop-down List: the block's entries, sorted A to Z. */
+var getPickListEntries = function (entries) {
+    return tslib_1.__spreadArray([], tslib_1.__read(entries), false).sort(function (a, b) { return a.localeCompare(b, undefined, { sensitivity: "base" }); });
+};
+exports.getPickListEntries = getPickListEntries;

package/dist/cjs/api/banded-ranges.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"banded-ranges.d.ts","sourceRoot":"","sources":["../../../api/banded-ranges.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAE1E,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEtE;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GACzB,cAAc,WAAW,EAAE,EAC3B,OAAO,gBAAgB,EACvB,SAAS,MAAM,EACf,aAAa,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,EAC1C,gBAAgB,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,4BAuKjD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC,iBAE5D,CAAC"}
+{"version":3,"file":"banded-ranges.d.ts","sourceRoot":"","sources":["../../../api/banded-ranges.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAE1E,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEtE;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GACzB,cAAc,WAAW,EAAE,EAC3B,OAAO,gBAAgB,EACvB,SAAS,MAAM,EACf,aAAa,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,EAC1C,gBAAgB,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,4BAoLjD,CAAC;AAuDF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC,iBAE5D,CAAC"}

package/dist/cjs/api/banded-ranges.js

@@ -17,11 +17,22 @@ var getBandedCells = function (bandedRanges, theme, sheetId, isHiddenRow, isHidd
     var bandedCells = new Map();
     try {
         for (var bandedRanges_1 = tslib_1.__values(bandedRanges), bandedRanges_1_1 = bandedRanges_1.next(); !bandedRanges_1_1.done; bandedRanges_1_1 = bandedRanges_1.next()) {
-            var _e = bandedRanges_1_1.value, range = _e.range, rowProperties = _e.rowProperties, columnProperties = _e.columnProperties, showFirstColumn = _e.showFirstColumn, showLastColumn = _e.showLastColumn, totalRow = _e.totalRow;
+            var _e = bandedRanges_1_1.value, range = _e.range, rowProperties = _e.rowProperties, columnProperties = _e.columnProperties, showFirstColumn = _e.showFirstColumn, showLastColumn = _e.showLastColumn, totalRow = _e.totalRow, headerRow = _e.headerRow, tableStyleElements = _e.tableStyleElements;
             // Only pick current sheet
             if (range.sheetId !== sheetId) {
                 continue;
             }
+            if (tableStyleElements) {
+                setTableStyleCells(bandedCells, tableStyleElements, range, {
+                    headerRow: headerRow !== false,
+                    totalRow: !!totalRow,
+                    showFirstColumn: !!showFirstColumn,
+                    showLastColumn: !!showLastColumn,
+                    isHiddenRow: isHiddenRow,
+                    isHiddenColumn: isHiddenColumn,
+                });
+                continue;
+            }
             if (rowProperties || columnProperties) {
                 var _f = rowProperties !== null && rowProperties !== void 0 ? rowProperties : {}, headerColor = _f.headerColor, firstBandColor = _f.firstBandColor, secondBandColor = _f.secondBandColor, footerColor = _f.footerColor, headerBorder = _f.headerBorder, firstBandBorder = _f.firstBandBorder, footerBorder = _f.footerBorder, firstColumnColor = _f.firstColumnColor, lastColumnColor = _f.lastColumnColor, totalRowColor = _f.totalRowColor, totalRowBorder = _f.totalRowBorder, totalRowBold = _f.totalRowBold;
                 var _g = columnProperties !== null && columnProperties !== void 0 ? columnProperties : {}, firstBandColorColumn = _g.firstBandColor, secondBandColorColumn = _g.secondBandColor;
@@ -133,6 +144,45 @@ var getBandedCells = function (bandedRanges, theme, sheetId, isHiddenRow, isHidd
     return bandedCells;
 };
 exports.getBandedCells = getBandedCells;
+/**
+ * Paint a table from its style elements (Excel's built-in styles): every visible cell takes the
+ * format `resolveTableStyleCell` layers for its position. Stripes count visible rows / columns,
+ * like Excel's banding over a filtered table.
+ */
+var setTableStyleCells = function (bandedCells, elements, range, options) {
+    var rows = [];
+    for (var r = range.startRowIndex; r <= range.endRowIndex; r++) {
+        if (!options.isHiddenRow(r))
+            rows.push(r);
+    }
+    var columns = [];
+    for (var c = range.startColumnIndex; c <= range.endColumnIndex; c++) {
+        if (!options.isHiddenColumn(c))
+            columns.push(c);
+    }
+    for (var i = 0; i < rows.length; i++) {
+        for (var j = 0; j < columns.length; j++) {
+            var _a = (0, utils_1.resolveTableStyleCell)(elements, {
+                rowIndex: i,
+                columnIndex: j,
+                rowCount: rows.length,
+                columnCount: columns.length,
+                // The header / totals rows and first / last columns are the range's own edges: hidden,
+                // their element has nothing to paint.
+                headerRow: options.headerRow && rows[0] === range.startRowIndex,
+                totalRow: options.totalRow && rows[rows.length - 1] === range.endRowIndex,
+                showFirstColumn: options.showFirstColumn && columns[0] === range.startColumnIndex,
+                showLastColumn: options.showLastColumn &&
+                    columns[columns.length - 1] === range.endColumnIndex,
+            }), fill = _a.fill, color = _a.color, bold = _a.bold, borders = _a.borders;
+            bandedCells.set((0, grid_1.cellIdentifier)(rows[i], columns[j]), {
+                backgroundColor: fill,
+                borders: borders,
+                textFormat: { color: color, bold: bold },
+            });
+        }
+    }
+};
 /**
  * Parse tinted color. returns undefined if tint >= 1
  * @param color

package/dist/cjs/api/error-checking.d.ts

@@ -0,0 +1,82 @@
+import type { GridRange } from "@rowsncolumns/common-types";
+import type { ErrorValue, ExtendedValue, IgnoredError } from "../types";
+/**
+ * The Excel background error-checking rules the grid flags with the green ◤ indicator. The names
+ * are the OOXML `<ignoredError>` attribute names, so an ignored error round-trips through xlsx.
+ *
+ * - `evalError` — "Cells containing formulas that result in an error".
+ * - `numberStoredAsText` — "Numbers formatted as text or preceded by an apostrophe".
+ */
+export type ErrorCheckKind = "evalError" | "numberStoredAsText";
+/**
+ * The number a "number stored as text" holds, or `undefined` when the text is not one. This is
+ * the value Excel's Convert to Number writes back.
+ */
+export declare const parseNumberStoredAsText: (text: string | null | undefined) => number | undefined;
+export type ErrorCheckInput = {
+    /** What the user typed (`uev`): a formula, a number, a string, … */
+    userEnteredValue: ExtendedValue | null | undefined;
+    /** The cell's error, if its effective value is one. */
+    errorValue: ErrorValue | null | undefined;
+};
+/**
+ * Which error-checking rule (if any) flags this cell, before ignored errors are applied.
+ * A typed error constant (`#N/A` entered as a value) is not flagged — only a formula's result.
+ * A data-validation failure is not an error-checking rule (Excel only circles it on request).
+ */
+export declare const getErrorCheckKind: ({ userEnteredValue, errorValue, }: ErrorCheckInput) => ErrorCheckKind | undefined;
+/** What the error-checking smart tag's menu can do. */
+export type ErrorCheckOption = "convertToNumber" | "help" | "ignore" | "editInFormulaBar" | "options";
+/** The menu's heading, as Excel words it. */
+export declare const getErrorCheckTitle: (kind: ErrorCheckKind, errorName?: string) => string;
+/** Excel's own help pages: hiding error values and error indicators, and the rule options. */
+export declare const ERROR_CHECKING_HELP_URL = "https://support.microsoft.com/en-us/office/hide-error-values-and-error-indicators-in-cells-d171b96e-8fb4-4863-a1ba-b64557474439";
+/** "Help on this Error": Excel's article for the error, else the error-indicators article. */
+export declare const getErrorHelpUrl: (kind: ErrorCheckKind, errorName?: string) => string;
+/** Has the user ignored this rule for this cell ("Ignore Error", or the file's `<ignoredErrors>`)? */
+export declare const isErrorIgnored: (ignoredErrors: ReadonlyArray<IgnoredError> | null | undefined, rowIndex: number, columnIndex: number, kind: ErrorCheckKind) => boolean;
+/** The sheet's ignored-errors list after "Ignore Error" on `ranges` (one new entry, as Excel writes). */
+export declare const appendIgnoredError: (ignoredErrors: ReadonlyArray<IgnoredError> | null | undefined, ranges: GridRange[], kind: ErrorCheckKind) => IgnoredError[];
+/** One row's run of adjacent cells Convert to Number rewrites, with their numbers. */
+export type NumberRun = {
+    rowIndex: number;
+    startColumnIndex: number;
+    values: number[];
+};
+/**
+ * The numbers stored as text inside `ranges`, as runs of adjacent cells per row — so Convert to
+ * Number writes each run in one call and never touches the cells between them. Rows / columns are
+ * clipped to `maxRow` / `maxColumn` (the sheet's data extent) so a whole-column selection scans
+ * only the used rows.
+ */
+export declare const collectNumberStoredAsTextRuns: (ranges: GridRange[], getUserEnteredValue: (rowIndex: number, columnIndex: number) => ExtendedValue | null | undefined, maxRow: number, maxColumn: number) => NumberRun[];
+export type ErrorCheckActionContext = {
+    sheetId: number;
+    kind: ErrorCheckKind;
+    errorName?: string;
+    /** The selection's ranges (the active cell's when nothing else is selected). */
+    ranges: GridRange[];
+    getUserEnteredValue(rowIndex: number, columnIndex: number): ExtendedValue | null | undefined;
+    /** The sheet's data extent: Convert to Number scans no further. */
+    maxRow: number;
+    maxColumn: number;
+    getIgnoredErrors?(sheetId: number): IgnoredError[] | null | undefined;
+    onChangeBatch?(sheetId: number, range: GridRange, values: number[][]): void;
+    /** Records every write `action` makes as one undo step. */
+    batchHistory?<R>(action: () => R): R;
+    onUpdateSheet?(sheetId: number, sheet: {
+        ignoredErrors: IgnoredError[];
+    }): void;
+    /** Start editing the active cell in the formula bar (or in the cell when there is no bar). */
+    editInFormulaBar(): void;
+    openUrl(url: string): void;
+};
+/**
+ * Run one of the error-checking smart tag's menu items. Convert to Number and Ignore Error act on
+ * every selected cell, as Excel does: Convert to Number rewrites each number stored as text as its
+ * number — one `onChangeBatch` per run of adjacent cells, all inside one `batchHistory`, so it is a
+ * single undo step and syncs as ordinary value writes; Ignore Error appends the selection to the
+ * sheet's `ignoredErrors` (persisted, xlsx `<ignoredErrors>`).
+ */
+export declare const runErrorCheckOption: (option: ErrorCheckOption, context: ErrorCheckActionContext) => void;
+//# sourceMappingURL=error-checking.d.ts.map

package/dist/cjs/api/error-checking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-checking.d.ts","sourceRoot":"","sources":["../../../api/error-checking.ts"],"names":[],"mappings":"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"}

package/dist/cjs/api/error-checking.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runErrorCheckOption = exports.collectNumberStoredAsTextRuns = exports.appendIgnoredError = exports.isErrorIgnored = exports.getErrorHelpUrl = exports.ERROR_CHECKING_HELP_URL = exports.getErrorCheckTitle = exports.getErrorCheckKind = exports.parseNumberStoredAsText = void 0;
+var tslib_1 = require("tslib");
+/**
+ * Text that Excel's "Number Stored as Text" rule flags: an optionally signed number, with optional
+ * thousands separators, decimals, exponent or a trailing percent sign — and nothing else.
+ */
+var NUMBER_STORED_AS_TEXT = /^[+-]?(?:\d{1,3}(?:,\d{3})+|\d+)?(?:\.\d+)?(?:[eE][+-]?\d+)?%?$/;
+/**
+ * The number a "number stored as text" holds, or `undefined` when the text is not one. This is
+ * the value Excel's Convert to Number writes back.
+ */
+var parseNumberStoredAsText = function (text) {
+    if (typeof text !== "string" || !/\d/.test(text))
+        return undefined;
+    if (!NUMBER_STORED_AS_TEXT.test(text))
+        return undefined;
+    var isPercent = text.endsWith("%");
+    var body = (isPercent ? text.slice(0, -1) : text).replace(/,/g, "");
+    var value = Number(body);
+    if (!Number.isFinite(value))
+        return undefined;
+    return isPercent ? value / 100 : value;
+};
+exports.parseNumberStoredAsText = parseNumberStoredAsText;
+/**
+ * Which error-checking rule (if any) flags this cell, before ignored errors are applied.
+ * A typed error constant (`#N/A` entered as a value) is not flagged — only a formula's result.
+ * A data-validation failure is not an error-checking rule (Excel only circles it on request).
+ */
+var getErrorCheckKind = function (_a) {
+    var _b, _c;
+    var userEnteredValue = _a.userEnteredValue, errorValue = _a.errorValue;
+    var formula = (_b = userEnteredValue === null || userEnteredValue === void 0 ? void 0 : userEnteredValue.fv) !== null && _b !== void 0 ? _b : userEnteredValue === null || userEnteredValue === void 0 ? void 0 : userEnteredValue.formulaValue;
+    if (formula) {
+        return (errorValue === null || errorValue === void 0 ? void 0 : errorValue.type) === "Error" ? "evalError" : undefined;
+    }
+    var text = (_c = userEnteredValue === null || userEnteredValue === void 0 ? void 0 : userEnteredValue.sv) !== null && _c !== void 0 ? _c : userEnteredValue === null || userEnteredValue === void 0 ? void 0 : userEnteredValue.stringValue;
+    if ((0, exports.parseNumberStoredAsText)(text) !== undefined)
+        return "numberStoredAsText";
+    return undefined;
+};
+exports.getErrorCheckKind = getErrorCheckKind;
+var ERROR_TITLES = {
+    "#VALUE!": "Error in Value",
+    "#DIV/0!": "Divide by Zero Error",
+    "#N/A": "Value Not Available Error",
+    "#NAME?": "Invalid Name Error",
+    "#NULL!": "Null Error",
+    "#NUM!": "Invalid Number Error",
+    "#REF!": "Invalid Cell Reference Error",
+    "#SPILL!": "Spill Range Isn't Blank",
+    "#CALC!": "Calculation Error",
+};
+/** The menu's heading, as Excel words it. */
+var getErrorCheckTitle = function (kind, errorName) {
+    return kind === "numberStoredAsText"
+        ? "Number Stored as Text"
+        : (errorName && ERROR_TITLES[errorName]) || "Error in Formula";
+};
+exports.getErrorCheckTitle = getErrorCheckTitle;
+/** Excel's own help pages: hiding error values and error indicators, and the rule options. */
+exports.ERROR_CHECKING_HELP_URL = "https://support.microsoft.com/en-us/office/hide-error-values-and-error-indicators-in-cells-d171b96e-8fb4-4863-a1ba-b64557474439";
+var ERROR_HELP_URLS = {
+    "#VALUE!": "https://support.microsoft.com/en-us/office/how-to-correct-a-value-error-15e1b616-fbf2-4147-9c0b-0a11a20e409e",
+    "#NAME?": "https://support.microsoft.com/en-us/office/how-to-correct-a-name-error-b6d54e31-a743-4d7d-9b61-40002a7b4286",
+    "#NUM!": "https://support.microsoft.com/en-us/office/how-to-correct-a-num-error-f5193bfc-4400-43f4-88c4-8e1dcca0428b",
+    "#SPILL!": "https://support.microsoft.com/en-us/office/how-to-correct-a-spill-error-ffe0f555-b479-4a17-a6e2-ef9cc9ad4023",
+};
+/** "Help on this Error": Excel's article for the error, else the error-indicators article. */
+var getErrorHelpUrl = function (kind, errorName) {
+    return (kind === "evalError" && errorName && ERROR_HELP_URLS[errorName]) ||
+        exports.ERROR_CHECKING_HELP_URL;
+};
+exports.getErrorHelpUrl = getErrorHelpUrl;
+var inRange = function (range, rowIndex, columnIndex) {
+    return rowIndex >= range.startRowIndex &&
+        rowIndex <= range.endRowIndex &&
+        columnIndex >= range.startColumnIndex &&
+        columnIndex <= range.endColumnIndex;
+};
+/** Has the user ignored this rule for this cell ("Ignore Error", or the file's `<ignoredErrors>`)? */
+var isErrorIgnored = function (ignoredErrors, rowIndex, columnIndex, kind) {
+    return !!(ignoredErrors === null || ignoredErrors === void 0 ? void 0 : ignoredErrors.some(function (entry) {
+        return entry[kind] === true &&
+            entry.ranges.some(function (range) { return inRange(range, rowIndex, columnIndex); });
+    }));
+};
+exports.isErrorIgnored = isErrorIgnored;
+/** The sheet's ignored-errors list after "Ignore Error" on `ranges` (one new entry, as Excel writes). */
+var appendIgnoredError = function (ignoredErrors, ranges, kind) {
+    var _a;
+    return tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read((ignoredErrors !== null && ignoredErrors !== void 0 ? ignoredErrors : [])), false), [
+        (_a = { ranges: ranges.map(function (range) { return (tslib_1.__assign({}, range)); }) }, _a[kind] = true, _a),
+    ], false);
+};
+exports.appendIgnoredError = appendIgnoredError;
+/**
+ * The numbers stored as text inside `ranges`, as runs of adjacent cells per row — so Convert to
+ * Number writes each run in one call and never touches the cells between them. Rows / columns are
+ * clipped to `maxRow` / `maxColumn` (the sheet's data extent) so a whole-column selection scans
+ * only the used rows.
+ */
+var collectNumberStoredAsTextRuns = function (ranges, getUserEnteredValue, maxRow, maxColumn) {
+    var e_1, _a;
+    var _b;
+    var runs = [];
+    var seen = new Set();
+    try {
+        for (var ranges_1 = tslib_1.__values(ranges), ranges_1_1 = ranges_1.next(); !ranges_1_1.done; ranges_1_1 = ranges_1.next()) {
+            var range = ranges_1_1.value;
+            var endRow = Math.min(range.endRowIndex, maxRow);
+            var endColumn = Math.min(range.endColumnIndex, maxColumn);
+            for (var row = range.startRowIndex; row <= endRow; row++) {
+                var run = null;
+                for (var col = range.startColumnIndex; col <= endColumn; col++) {
+                    var key = "".concat(row, ":").concat(col);
+                    var uev = seen.has(key) ? null : getUserEnteredValue(row, col);
+                    seen.add(key);
+                    var kind = (0, exports.getErrorCheckKind)({ userEnteredValue: uev, errorValue: null });
+                    var value = kind === "numberStoredAsText"
+                        ? (0, exports.parseNumberStoredAsText)((_b = uev === null || uev === void 0 ? void 0 : uev.sv) !== null && _b !== void 0 ? _b : uev === null || uev === void 0 ? void 0 : uev.stringValue)
+                        : undefined;
+                    if (value === undefined) {
+                        run = null;
+                        continue;
+                    }
+                    if (!run) {
+                        run = { rowIndex: row, startColumnIndex: col, values: [] };
+                        runs.push(run);
+                    }
+                    run.values.push(value);
+                }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (ranges_1_1 && !ranges_1_1.done && (_a = ranges_1.return)) _a.call(ranges_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return runs;
+};
+exports.collectNumberStoredAsTextRuns = collectNumberStoredAsTextRuns;
+/**
+ * Run one of the error-checking smart tag's menu items. Convert to Number and Ignore Error act on
+ * every selected cell, as Excel does: Convert to Number rewrites each number stored as text as its
+ * number — one `onChangeBatch` per run of adjacent cells, all inside one `batchHistory`, so it is a
+ * single undo step and syncs as ordinary value writes; Ignore Error appends the selection to the
+ * sheet's `ignoredErrors` (persisted, xlsx `<ignoredErrors>`).
+ */
+var runErrorCheckOption = function (option, context) {
+    var _a, _b;
+    var sheetId = context.sheetId, kind = context.kind, ranges = context.ranges;
+    switch (option) {
+        case "convertToNumber": {
+            var runs_1 = (0, exports.collectNumberStoredAsTextRuns)(ranges, context.getUserEnteredValue, context.maxRow, context.maxColumn);
+            if (!runs_1.length)
+                return;
+            var write = function () {
+                var e_2, _a;
+                var _b;
+                try {
+                    for (var runs_2 = tslib_1.__values(runs_1), runs_2_1 = runs_2.next(); !runs_2_1.done; runs_2_1 = runs_2.next()) {
+                        var run = runs_2_1.value;
+                        (_b = context.onChangeBatch) === null || _b === void 0 ? void 0 : _b.call(context, sheetId, {
+                            startRowIndex: run.rowIndex,
+                            endRowIndex: run.rowIndex,
+                            startColumnIndex: run.startColumnIndex,
+                            endColumnIndex: run.startColumnIndex + run.values.length - 1,
+                        }, [run.values]);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (runs_2_1 && !runs_2_1.done && (_a = runs_2.return)) _a.call(runs_2);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            };
+            if (context.batchHistory)
+                context.batchHistory(write);
+            else
+                write();
+            return;
+        }
+        case "ignore":
+            (_a = context.onUpdateSheet) === null || _a === void 0 ? void 0 : _a.call(context, sheetId, {
+                ignoredErrors: (0, exports.appendIgnoredError)((_b = context.getIgnoredErrors) === null || _b === void 0 ? void 0 : _b.call(context, sheetId), ranges, kind),
+            });
+            return;
+        case "editInFormulaBar":
+            context.editInFormulaBar();
+            return;
+        case "help":
+            context.openUrl((0, exports.getErrorHelpUrl)(kind, context.errorName));
+            return;
+        case "options":
+            context.openUrl(exports.ERROR_CHECKING_HELP_URL);
+            return;
+    }
+};
+exports.runErrorCheckOption = runErrorCheckOption;

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

@@ -7,8 +7,14 @@ export declare const MOVE_OVERWRITE_PROMPT = "There's already data here. Do you
  * 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.
+ * empty destination never prompts; Shift+drag (insert) never reaches this check and
+ * Ctrl+drag (copy) uses {@link needsCopyOverwritePrompt}.
  */
 export declare const needsOverwritePrompt: (from: GridRange, to: GridRange, hasValue: (rowIndex: number, columnIndex: number) => boolean) => boolean;
+/**
+ * Whether a Ctrl+drag (⌥+drag on macOS) COPY onto `to` needs the same prompt: any
+ * destination cell holding a value counts — a copy leaves the source in place, so
+ * source cells the copy lands on are replaced too.
+ */
+export declare const needsCopyOverwritePrompt: (to: GridRange, hasValue: (rowIndex: number, columnIndex: number) => boolean) => boolean;
 //# sourceMappingURL=move-overwrite.d.ts.map

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

@@ -1 +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"}
+{"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;AAEF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GACnC,IAAI,SAAS,EACb,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,KAC3D,OAaF,CAAC"}

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.needsOverwritePrompt = exports.MOVE_OVERWRITE_PROMPT = void 0;
+exports.needsCopyOverwritePrompt = 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?";
 /**
@@ -9,8 +9,8 @@ exports.MOVE_OVERWRITE_PROMPT = "There's already data here. Do you want to repla
  * 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.
+ * empty destination never prompts; Shift+drag (insert) never reaches this check and
+ * Ctrl+drag (copy) uses {@link needsCopyOverwritePrompt}.
  */
 var needsOverwritePrompt = function (from, to, hasValue) {
     for (var rowIndex = to.startRowIndex; rowIndex <= to.endRowIndex; rowIndex++) {
@@ -27,3 +27,19 @@ var needsOverwritePrompt = function (from, to, hasValue) {
     return false;
 };
 exports.needsOverwritePrompt = needsOverwritePrompt;
+/**
+ * Whether a Ctrl+drag (⌥+drag on macOS) COPY onto `to` needs the same prompt: any
+ * destination cell holding a value counts — a copy leaves the source in place, so
+ * source cells the copy lands on are replaced too.
+ */
+var needsCopyOverwritePrompt = function (to, hasValue) {
+    for (var rowIndex = to.startRowIndex; rowIndex <= to.endRowIndex; rowIndex++) {
+        for (var columnIndex = to.startColumnIndex; columnIndex <= to.endColumnIndex; columnIndex++) {
+            if (hasValue(rowIndex, columnIndex)) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+exports.needsCopyOverwritePrompt = needsCopyOverwritePrompt;

package/dist/cjs/api/selections.d.ts

@@ -8,7 +8,7 @@ import type { SheetRange, TableView } from "../types";
  * @param isActiveCell
  * @param isSelection
  */
-export declare const getSelectionStrokeStyle: (formulaMode: boolean, isFill: boolean, isActiveCell: boolean, emptySelections: boolean) => "dashed" | "solid";
+export declare const getSelectionStrokeStyle: (formulaMode: boolean, isFill: boolean, isActiveCell: boolean, emptySelections: boolean) => "solid" | "dashed";
 export type SelectionStrokeOptions = {
     /** Border width of a range selection outside formula mode. Default `1`. */
     selectionStrokeWidth?: number;
@@ -37,7 +37,7 @@ export declare const getSelectionStrokeWidth: (formulaMode: boolean, isFill: boo
  * @param isFill
  * @returns
  */
-export declare const getSelectionFillOpacity: (formulaMode: boolean, isFill: boolean) => 1 | 0 | 0.2;
+export declare const getSelectionFillOpacity: (formulaMode: boolean, isFill: boolean) => 0 | 1 | 0.2;
 /**
  * Get background color of selection
  * @param formulaMode