@rowsncolumns/spreadsheet 10.2.74 → 10.2.76

package/dist/cjs/api/excel-validation-kinds.d.ts

@@ -0,0 +1,71 @@
+import type { DataValidationRule, SheetRange } from "../types";
+/**
+ * Excel's data-validation "Allow" kinds that have no `ConditionType` of
+ * their own. Each is authored as Excel's `type` + `operator` + up to two
+ * formulas and stored two ways at once:
+ *
+ * - `condition` — what both engines evaluate for the red Invalid marker:
+ *   `whole` and `textLength` compose a `CUSTOM_FORMULA` over the range
+ *   anchor (the same shape both importers synthesize), `time` is a plain
+ *   `NUMBER_*` comparison over day-fraction serials;
+ * - `xlsxSource` — the Excel-native description both xlsx exporters replay
+ *   verbatim (`type="whole"` …), so the rule round-trips as what the user
+ *   picked instead of a decimal / custom rule.
+ *
+ * Imported rules already carry `xlsxSource`, so the editor reads them back
+ * as "Whole number between 1 and 10" rather than a custom formula.
+ */
+export type ExcelValidationKind = "whole" | "time" | "textLength";
+export type ExcelValidationOperator = "between" | "notBetween" | "equal" | "notEqual" | "greaterThan" | "lessThan" | "greaterThanOrEqual" | "lessThanOrEqual";
+export type ExcelValidationSpec = {
+    kind: ExcelValidationKind;
+    operator: ExcelValidationOperator;
+    /** Bound(s) as the user typed them: a literal (`10`, `9:30 AM`) or `=ref`. */
+    formula1?: string;
+    formula2?: string;
+};
+export declare const EXCEL_VALIDATION_KIND_LABELS: ReadonlyArray<{
+    kind: ExcelValidationKind;
+    label: string;
+}>;
+export declare const EXCEL_VALIDATION_OPERATOR_LABELS: ReadonlyArray<{
+    operator: ExcelValidationOperator;
+    label: string;
+}>;
+/** Two-sided operators need both bounds. */
+export declare const isTwoSidedOperator: (operator: ExcelValidationOperator) => operator is "between" | "notBetween";
+/**
+ * Parse a typed time (`9:30`, `9:30 AM`, `21:05:10`, `24:00`, `0.5`) to
+ * Excel's serial. A bare non-negative number is taken as a serial already and
+ * kept whole (Excel's Time validation compares the full serial, so a
+ * date-time is out of a same-day range). `undefined` when unparsable.
+ */
+export declare const parseTimeToSerial: (text: string | undefined) => number | undefined;
+/** Render a day-fraction serial as `h:mm AM/PM` (seconds when non-zero). */
+export declare const formatTimeSerial: (serial: number) => string;
+/** The A1 anchor (range top-left) a relative custom formula is written against. */
+export declare const getValidationAnchor: (range: SheetRange | undefined) => string;
+/**
+ * Build the `condition` + `xlsxSource` pair for an Excel kind. Returns
+ * `undefined` when a required bound is missing (the editor keeps the form
+ * open in that case).
+ */
+export declare const buildExcelValidationRule: (spec: ExcelValidationSpec, anchor: string) => Pick<DataValidationRule, "condition" | "xlsxSource"> | undefined;
+/**
+ * Read an Excel kind back from a rule's `xlsxSource` (imported or authored
+ * here); `undefined` for every other rule. Time bounds come back as
+ * `h:mm AM/PM` text so the editor shows what the user would type.
+ */
+export declare const readExcelValidationSpec: (rule: Pick<DataValidationRule, "xlsxSource"> | undefined | null) => ExcelValidationSpec | undefined;
+/** A typed value that is a formula (`=…`) — validated on its result, not its text. */
+export declare const isFormulaEntry: (value: unknown) => value is string;
+/**
+ * Decide an Excel-kind rule for a freshly typed value without the
+ * calculator — the commit-time enforcement Excel applies (`stop` blocks a
+ * decimal in a whole-number cell). `undefined` when the bounds are
+ * formulas / references, or when the typed value is itself a formula
+ * (Excel validates the formula's RESULT after the recalc, so `=5` is a
+ * valid whole number), so the caller falls back to the flag-only marker.
+ */
+export declare const checkExcelValidationValue: (rule: Pick<DataValidationRule, "xlsxSource"> | undefined | null, value: string | boolean) => boolean | undefined;
+//# sourceMappingURL=excel-validation-kinds.d.ts.map

package/dist/cjs/api/excel-validation-kinds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"excel-validation-kinds.d.ts","sourceRoot":"","sources":["../../../api/excel-validation-kinds.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,kBAAkB,EAClB,UAAU,EACX,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,GAAG,MAAM,GAAG,YAAY,CAAC;AAElE,MAAM,MAAM,uBAAuB,GAC/B,SAAS,GACT,YAAY,GACZ,OAAO,GACP,UAAU,GACV,aAAa,GACb,UAAU,GACV,oBAAoB,GACpB,iBAAiB,CAAC;AAEtB,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,mBAAmB,CAAC;IAC1B,QAAQ,EAAE,uBAAuB,CAAC;IAClC,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,aAAa,CAAC;IACvD,IAAI,EAAE,mBAAmB,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf,CAIA,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,aAAa,CAAC;IAC3D,QAAQ,EAAE,uBAAuB,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;CACf,CASA,CAAC;AAOF,4CAA4C;AAC5C,eAAO,MAAM,kBAAkB,GAAI,UAAU,uBAAuB,yCACf,CAAC;AAwBtD;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC5B,MAAM,MAAM,GAAG,SAAS,KACvB,MAAM,GAAG,SAuBX,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,GAAI,QAAQ,MAAM,KAAG,MAUjD,CAAC;AAoBF,mFAAmF;AACnF,eAAO,MAAM,mBAAmB,GAAI,OAAO,UAAU,GAAG,SAAS,KAAG,MAKzD,CAAC;AAgCZ;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GACnC,MAAM,mBAAmB,EACzB,QAAQ,MAAM,KACb,IAAI,CAAC,kBAAkB,EAAE,WAAW,GAAG,YAAY,CAAC,GAAG,SAiDzD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,GAClC,MAAM,IAAI,CAAC,kBAAkB,EAAE,YAAY,CAAC,GAAG,SAAS,GAAG,IAAI,KAC9D,mBAAmB,GAAG,SAuBxB,CAAC;AAmCF,sFAAsF;AACtF,eAAO,MAAM,cAAc,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MACE,CAAC;AAE5D;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,GACpC,MAAM,IAAI,CAAC,kBAAkB,EAAE,YAAY,CAAC,GAAG,SAAS,GAAG,IAAI,EAC/D,OAAO,MAAM,GAAG,OAAO,KACtB,OAAO,GAAG,SAmCZ,CAAC"}

package/dist/cjs/api/excel-validation-kinds.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkExcelValidationValue = exports.isFormulaEntry = exports.readExcelValidationSpec = exports.buildExcelValidationRule = exports.getValidationAnchor = exports.formatTimeSerial = exports.parseTimeToSerial = exports.isTwoSidedOperator = exports.EXCEL_VALIDATION_OPERATOR_LABELS = exports.EXCEL_VALIDATION_KIND_LABELS = void 0;
+var tslib_1 = require("tslib");
+var utils_1 = require("@rowsncolumns/utils");
+exports.EXCEL_VALIDATION_KIND_LABELS = [
+    { kind: "whole", label: "Whole number" },
+    { kind: "time", label: "Time" },
+    { kind: "textLength", label: "Text length" },
+];
+exports.EXCEL_VALIDATION_OPERATOR_LABELS = [
+    { operator: "between", label: "between" },
+    { operator: "notBetween", label: "not between" },
+    { operator: "equal", label: "equal to" },
+    { operator: "notEqual", label: "not equal to" },
+    { operator: "greaterThan", label: "greater than" },
+    { operator: "lessThan", label: "less than" },
+    { operator: "greaterThanOrEqual", label: "greater than or equal to" },
+    { operator: "lessThanOrEqual", label: "less than or equal to" },
+];
+var EXCEL_KINDS = new Set(["whole", "time", "textLength"]);
+var EXCEL_OPERATORS = new Set(exports.EXCEL_VALIDATION_OPERATOR_LABELS.map(function (entry) { return entry.operator; }));
+/** Two-sided operators need both bounds. */
+var isTwoSidedOperator = function (operator) {
+    return operator === "between" || operator === "notBetween";
+};
+exports.isTwoSidedOperator = isTwoSidedOperator;
+var NUMBER_CONDITION_BY_OPERATOR = {
+    between: "NUMBER_BETWEEN",
+    notBetween: "NUMBER_NOT_BETWEEN",
+    equal: "NUMBER_EQ",
+    notEqual: "NUMBER_NOT_EQ",
+    greaterThan: "NUMBER_GREATER",
+    lessThan: "NUMBER_LESS",
+    greaterThanOrEqual: "NUMBER_GREATER_THAN_EQ",
+    lessThanOrEqual: "NUMBER_LESS_THAN_EQ",
+};
+var stripEquals = function (text) {
+    var _a;
+    var trimmed = (_a = text === null || text === void 0 ? void 0 : text.trim()) !== null && _a !== void 0 ? _a : "";
+    return trimmed.startsWith("=") ? trimmed.slice(1).trim() : trimmed;
+};
+var TIME_PATTERN = /^(\d{1,2})(?::(\d{1,2}))?(?::(\d{1,2}))?\s*([AaPp][Mm]?)?$/;
+/**
+ * Parse a typed time (`9:30`, `9:30 AM`, `21:05:10`, `24:00`, `0.5`) to
+ * Excel's serial. A bare non-negative number is taken as a serial already and
+ * kept whole (Excel's Time validation compares the full serial, so a
+ * date-time is out of a same-day range). `undefined` when unparsable.
+ */
+var parseTimeToSerial = function (text) {
+    var _a, _b, _c, _d;
+    var trimmed = (_a = text === null || text === void 0 ? void 0 : text.trim()) !== null && _a !== void 0 ? _a : "";
+    if (!trimmed)
+        return undefined;
+    var asNumber = Number(trimmed);
+    if (Number.isFinite(asNumber)) {
+        return asNumber >= 0 ? asNumber : undefined;
+    }
+    var match = TIME_PATTERN.exec(trimmed);
+    if (!match)
+        return undefined;
+    var hours = Number(match[1]);
+    var minutes = Number((_b = match[2]) !== null && _b !== void 0 ? _b : 0);
+    var seconds = Number((_c = match[3]) !== null && _c !== void 0 ? _c : 0);
+    var meridiem = (_d = match[4]) === null || _d === void 0 ? void 0 : _d.toLowerCase();
+    if (minutes > 59 || seconds > 59)
+        return undefined;
+    if (meridiem) {
+        if (hours < 1 || hours > 12)
+            return undefined;
+        if (meridiem.startsWith("p") && hours !== 12)
+            hours += 12;
+        if (meridiem.startsWith("a") && hours === 12)
+            hours = 0;
+    }
+    else if (hours > 24 || (hours === 24 && (minutes > 0 || seconds > 0))) {
+        // Excel accepts `24:00` as exactly 1.0 (midnight at the end of the day).
+        return undefined;
+    }
+    return (hours * 3600 + minutes * 60 + seconds) / 86400;
+};
+exports.parseTimeToSerial = parseTimeToSerial;
+/** Render a day-fraction serial as `h:mm AM/PM` (seconds when non-zero). */
+var formatTimeSerial = function (serial) {
+    var total = Math.round((serial - Math.floor(serial)) * 86400) % 86400;
+    var hours24 = Math.floor(total / 3600);
+    var minutes = Math.floor((total % 3600) / 60);
+    var seconds = total % 60;
+    var meridiem = hours24 >= 12 ? "PM" : "AM";
+    var hours12 = hours24 % 12 === 0 ? 12 : hours24 % 12;
+    var mm = String(minutes).padStart(2, "0");
+    var ss = seconds ? ":".concat(String(seconds).padStart(2, "0")) : "";
+    return "".concat(hours12, ":").concat(mm).concat(ss, " ").concat(meridiem);
+};
+exports.formatTimeSerial = formatTimeSerial;
+/**
+ * A bound as it goes into a formula / `xlsxSource`: references and formulas
+ * verbatim (no `=`), times as serials, numbers as typed.
+ */
+var toBoundFormula = function (kind, text) {
+    var _a;
+    var raw = (_a = text === null || text === void 0 ? void 0 : text.trim()) !== null && _a !== void 0 ? _a : "";
+    if (!raw)
+        return undefined;
+    if (raw.startsWith("="))
+        return stripEquals(raw);
+    if (kind === "time") {
+        var serial = (0, exports.parseTimeToSerial)(raw);
+        return serial === undefined ? raw : String(serial);
+    }
+    return raw;
+};
+/** The A1 anchor (range top-left) a relative custom formula is written against. */
+var getValidationAnchor = function (range) {
+    var _a;
+    return (_a = (0, utils_1.cellToAddress)(range
+        ? { rowIndex: range.startRowIndex, columnIndex: range.startColumnIndex }
+        : { rowIndex: 1, columnIndex: 1 })) !== null && _a !== void 0 ? _a : "A1";
+};
+exports.getValidationAnchor = getValidationAnchor;
+var comparison = function (subject, operator, a, b) {
+    switch (operator) {
+        case "between":
+            return b === undefined
+                ? undefined
+                : "AND(".concat(subject, ">=").concat(a, ",").concat(subject, "<=").concat(b, ")");
+        case "notBetween":
+            return b === undefined
+                ? undefined
+                : "OR(".concat(subject, "<").concat(a, ",").concat(subject, ">").concat(b, ")");
+        case "equal":
+            return "".concat(subject, "=").concat(a);
+        case "notEqual":
+            return "".concat(subject, "<>").concat(a);
+        case "greaterThan":
+            return "".concat(subject, ">").concat(a);
+        case "lessThan":
+            return "".concat(subject, "<").concat(a);
+        case "greaterThanOrEqual":
+            return "".concat(subject, ">=").concat(a);
+        case "lessThanOrEqual":
+            return "".concat(subject, "<=").concat(a);
+    }
+};
+/**
+ * Build the `condition` + `xlsxSource` pair for an Excel kind. Returns
+ * `undefined` when a required bound is missing (the editor keeps the form
+ * open in that case).
+ */
+var buildExcelValidationRule = function (spec, anchor) {
+    var formula1 = toBoundFormula(spec.kind, spec.formula1);
+    var formula2 = toBoundFormula(spec.kind, spec.formula2);
+    if (!formula1)
+        return undefined;
+    if ((0, exports.isTwoSidedOperator)(spec.operator) && !formula2)
+        return undefined;
+    var xlsxSource = tslib_1.__assign({ type: spec.kind, operator: spec.operator, formula1: formula1 }, ((0, exports.isTwoSidedOperator)(spec.operator) ? { formula2: formula2 } : {}));
+    if (spec.kind === "time") {
+        var condition = {
+            type: NUMBER_CONDITION_BY_OPERATOR[spec.operator],
+            values: tslib_1.__spreadArray([
+                {
+                    userEnteredValue: /^[A-Za-z$'!]/.test(formula1)
+                        ? "=".concat(formula1)
+                        : formula1,
+                }
+            ], tslib_1.__read(((0, exports.isTwoSidedOperator)(spec.operator) && formula2
+                ? [
+                    {
+                        userEnteredValue: /^[A-Za-z$'!]/.test(formula2)
+                            ? "=".concat(formula2)
+                            : formula2,
+                    },
+                ]
+                : [])), false),
+        };
+        return { condition: condition, xlsxSource: xlsxSource };
+    }
+    var subject = spec.kind === "textLength" ? "LEN(".concat(anchor, ")") : anchor;
+    var body = comparison(subject, spec.operator, formula1, formula2);
+    if (!body)
+        return undefined;
+    var formula = spec.kind === "whole"
+        ? "=AND(ISNUMBER(".concat(anchor, "),").concat(anchor, "=INT(").concat(anchor, "),").concat(body, ")")
+        : "=".concat(body);
+    return {
+        condition: {
+            type: "CUSTOM_FORMULA",
+            values: [{ userEnteredValue: formula }],
+        },
+        xlsxSource: xlsxSource,
+    };
+};
+exports.buildExcelValidationRule = buildExcelValidationRule;
+/**
+ * Read an Excel kind back from a rule's `xlsxSource` (imported or authored
+ * here); `undefined` for every other rule. Time bounds come back as
+ * `h:mm AM/PM` text so the editor shows what the user would type.
+ */
+var readExcelValidationSpec = function (rule) {
+    var source = rule === null || rule === void 0 ? void 0 : rule.xlsxSource;
+    if (!source || !EXCEL_KINDS.has(source.type))
+        return undefined;
+    var operator = (source.operator && EXCEL_OPERATORS.has(source.operator)
+        ? source.operator
+        : "between");
+    var kind = source.type;
+    var display = function (formula) {
+        if (formula === undefined || formula === "")
+            return undefined;
+        var asNumber = Number(formula);
+        if (Number.isFinite(asNumber)) {
+            return kind === "time" ? (0, exports.formatTimeSerial)(asNumber) : formula;
+        }
+        return "=".concat(formula);
+    };
+    return {
+        kind: kind,
+        operator: operator,
+        formula1: display(source.formula1),
+        formula2: display(source.formula2),
+    };
+};
+exports.readExcelValidationSpec = readExcelValidationSpec;
+var compare = function (subject, operator, a, b) {
+    switch (operator) {
+        case "between":
+            return (b !== undefined &&
+                subject >= Math.min(a, b) &&
+                subject <= Math.max(a, b));
+        case "notBetween":
+            return (b !== undefined &&
+                (subject < Math.min(a, b) || subject > Math.max(a, b)));
+        case "equal":
+            return subject === a;
+        case "notEqual":
+            return subject !== a;
+        case "greaterThan":
+            return subject > a;
+        case "lessThan":
+            return subject < a;
+        case "greaterThanOrEqual":
+            return subject >= a;
+        case "lessThanOrEqual":
+            return subject <= a;
+    }
+};
+/** A typed value that is a formula (`=…`) — validated on its result, not its text. */
+var isFormulaEntry = function (value) {
+    return typeof value === "string" && value.trim().startsWith("=");
+};
+exports.isFormulaEntry = isFormulaEntry;
+/**
+ * Decide an Excel-kind rule for a freshly typed value without the
+ * calculator — the commit-time enforcement Excel applies (`stop` blocks a
+ * decimal in a whole-number cell). `undefined` when the bounds are
+ * formulas / references, or when the typed value is itself a formula
+ * (Excel validates the formula's RESULT after the recalc, so `=5` is a
+ * valid whole number), so the caller falls back to the flag-only marker.
+ */
+var checkExcelValidationValue = function (rule, value) {
+    var _a;
+    var source = rule === null || rule === void 0 ? void 0 : rule.xlsxSource;
+    if (!source || !EXCEL_KINDS.has(source.type))
+        return undefined;
+    if ((0, exports.isFormulaEntry)(value))
+        return undefined;
+    var operator = ((_a = source.operator) !== null && _a !== void 0 ? _a : "between");
+    if (!EXCEL_OPERATORS.has(operator))
+        return undefined;
+    var a = Number(source.formula1);
+    var b = source.formula2 === undefined ? undefined : Number(source.formula2);
+    if (!Number.isFinite(a))
+        return undefined;
+    if ((0, exports.isTwoSidedOperator)(operator) &&
+        !(b !== undefined && Number.isFinite(b))) {
+        return undefined;
+    }
+    var text = typeof value === "boolean" ? (value ? "TRUE" : "FALSE") : value;
+    switch (source.type) {
+        case "textLength":
+            return compare(Array.from(text).length, operator, a, b);
+        case "whole": {
+            if (typeof value === "boolean")
+                return false;
+            var num = Number(text.trim());
+            if (!Number.isFinite(num) || !Number.isInteger(num))
+                return false;
+            return compare(num, operator, a, b);
+        }
+        case "time": {
+            if (typeof value === "boolean")
+                return false;
+            // Excel compares the cell's full serial against the bounds (a
+            // date-time such as 45292.5 is NOT between 9:00 and 12:00) — the same
+            // comparison the composed `NUMBER_*` condition makes for the marker.
+            var serial = (0, exports.parseTimeToSerial)(text);
+            if (serial === undefined)
+                return false;
+            return compare(serial, operator, a, b);
+        }
+    }
+};
+exports.checkExcelValidationValue = checkExcelValidationValue;

package/dist/cjs/api/fill-series.d.ts

@@ -0,0 +1,38 @@
+import type { GridRange } from "@rowsncolumns/grid";
+import type { FillSeriesSpec } from "../types";
+/**
+ * The seed line of a Series-dialog fill: Excel treats the target range's first
+ * row (Series in Columns — filling down) or first column (Series in Rows —
+ * filling across) as the values the series starts from.
+ */
+export declare const seedRangeForSeriesSpec: (target: GridRange, spec: FillSeriesSpec) => GridRange;
+/**
+ * How many series values fit before `stop` is passed, starting from the seed's
+ * last value. `undefined` when the spec has no usable stop (no stop, zero step,
+ * a step that walks away from the stop, …) — the caller then fills the target
+ * as selected.
+ */
+export declare const seriesCountToStop: (last: number, spec: FillSeriesSpec) => number | undefined;
+export type FillRangeForSeriesSpecArgs = {
+    /** The range the user selected (seed + cells to fill). */
+    target: GridRange;
+    /** From {@link seedRangeForSeriesSpec}. */
+    seed: GridRange;
+    spec: FillSeriesSpec;
+    /** Numeric value of a seed cell (`undefined` when not a number). */
+    getSeedValue(rowIndex: number, columnIndex: number): number | undefined;
+    rowCount: number;
+    columnCount: number;
+};
+/**
+ * The range a Series-dialog fill covers (seed + cells to fill). A selection
+ * that reaches beyond the seed is filled as selected (`undefined` when there
+ * is nothing beyond the seed and no stop): the engines apply the `stop` value
+ * per fill line — every column (Series in Columns) / row (Rows) ends at the
+ * last value within its own stop and the remaining selected cells stay
+ * untouched, exactly as Excel leaves them. Only a seed-only selection is
+ * extended along the axis by the number of values that stay within the stop —
+ * Excel fills down/right from a single line until the value would pass it.
+ */
+export declare const fillRangeForSeriesSpec: ({ target, seed, spec, getSeedValue, rowCount, columnCount, }: FillRangeForSeriesSpecArgs) => GridRange | undefined;
+//# sourceMappingURL=fill-series.d.ts.map

package/dist/cjs/api/fill-series.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fill-series.d.ts","sourceRoot":"","sources":["../../../api/fill-series.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GACjC,QAAQ,SAAS,EACjB,MAAM,cAAc,KACnB,SAGyD,CAAC;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC5B,MAAM,MAAM,EACZ,MAAM,cAAc,KACnB,MAAM,GAAG,SAuBX,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,0DAA0D;IAC1D,MAAM,EAAE,SAAS,CAAC;IAClB,2CAA2C;IAC3C,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,cAAc,CAAC;IACrB,oEAAoE;IACpE,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IACxE,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,GAAI,8DAOpC,0BAA0B,KAAG,SAAS,GAAG,SAwB3C,CAAC"}

package/dist/cjs/api/fill-series.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fillRangeForSeriesSpec = exports.seriesCountToStop = exports.seedRangeForSeriesSpec = void 0;
+var tslib_1 = require("tslib");
+/**
+ * The seed line of a Series-dialog fill: Excel treats the target range's first
+ * row (Series in Columns — filling down) or first column (Series in Rows —
+ * filling across) as the values the series starts from.
+ */
+var seedRangeForSeriesSpec = function (target, spec) {
+    return spec.in === "columns"
+        ? tslib_1.__assign(tslib_1.__assign({}, target), { endRowIndex: target.startRowIndex }) : tslib_1.__assign(tslib_1.__assign({}, target), { endColumnIndex: target.startColumnIndex });
+};
+exports.seedRangeForSeriesSpec = seedRangeForSeriesSpec;
+/**
+ * How many series values fit before `stop` is passed, starting from the seed's
+ * last value. `undefined` when the spec has no usable stop (no stop, zero step,
+ * a step that walks away from the stop, …) — the caller then fills the target
+ * as selected.
+ */
+var seriesCountToStop = function (last, spec) {
+    var _a, _b;
+    var stop = spec.stop;
+    if (stop === undefined || !Number.isFinite(stop))
+        return undefined;
+    var step = (_a = spec.step) !== null && _a !== void 0 ? _a : 1;
+    if (spec.type === "linear") {
+        if (step === 0)
+            return undefined;
+        var n = Math.floor((stop - last) / step + 1e-9);
+        return n >= 0 ? n : 0;
+    }
+    if (spec.type === "growth") {
+        if (last === 0 || step <= 0 || step === 1)
+            return undefined;
+        if (Math.sign(last) !== Math.sign(stop))
+            return 0;
+        var n = Math.floor(Math.log(Math.abs(stop) / Math.abs(last)) / Math.log(step) + 1e-9);
+        return n >= 0 ? n : 0;
+    }
+    if (spec.type === "date" && ((_b = spec.dateUnit) !== null && _b !== void 0 ? _b : "day") === "day") {
+        if (step === 0)
+            return undefined;
+        var n = Math.floor((stop - last) / step + 1e-9);
+        return n >= 0 ? n : 0;
+    }
+    return undefined;
+};
+exports.seriesCountToStop = seriesCountToStop;
+/**
+ * The range a Series-dialog fill covers (seed + cells to fill). A selection
+ * that reaches beyond the seed is filled as selected (`undefined` when there
+ * is nothing beyond the seed and no stop): the engines apply the `stop` value
+ * per fill line — every column (Series in Columns) / row (Rows) ends at the
+ * last value within its own stop and the remaining selected cells stay
+ * untouched, exactly as Excel leaves them. Only a seed-only selection is
+ * extended along the axis by the number of values that stay within the stop —
+ * Excel fills down/right from a single line until the value would pass it.
+ */
+var fillRangeForSeriesSpec = function (_a) {
+    var _b;
+    var target = _a.target, seed = _a.seed, spec = _a.spec, getSeedValue = _a.getSeedValue, rowCount = _a.rowCount, columnCount = _a.columnCount;
+    var down = spec.in === "columns";
+    // Excel reads the stop against the first seed line's last value.
+    var last = down
+        ? getSeedValue(seed.endRowIndex, seed.startColumnIndex)
+        : getSeedValue(seed.startRowIndex, seed.endColumnIndex);
+    var selectedBeyondSeed = down
+        ? target.endRowIndex - seed.endRowIndex
+        : target.endColumnIndex - seed.endColumnIndex;
+    var extent = selectedBeyondSeed > 0
+        ? selectedBeyondSeed
+        : last === undefined
+            ? 0
+            : ((_b = (0, exports.seriesCountToStop)(last, spec)) !== null && _b !== void 0 ? _b : 0);
+    if (extent <= 0)
+        return undefined;
+    if (down) {
+        var endRowIndex = Math.min(seed.endRowIndex + extent, rowCount - 1);
+        if (endRowIndex <= seed.endRowIndex)
+            return undefined;
+        return tslib_1.__assign(tslib_1.__assign({}, target), { endRowIndex: endRowIndex });
+    }
+    var endColumnIndex = Math.min(seed.endColumnIndex + extent, columnCount - 1);
+    if (endColumnIndex <= seed.endColumnIndex)
+        return undefined;
+    return tslib_1.__assign(tslib_1.__assign({}, target), { endColumnIndex: endColumnIndex });
+};
+exports.fillRangeForSeriesSpec = fillRangeForSeriesSpec;

package/dist/cjs/api/go-to-special.d.ts

@@ -0,0 +1,32 @@
+import type { GridRange } from "@rowsncolumns/grid";
+import type { CellData } from "../types";
+/**
+ * Excel's Go To Special categories that can be decided from cell data alone.
+ * (Row / column differences, precedents / dependents and objects are served
+ * by the trace arrows and the drawing layer, not by this dialog.)
+ */
+export type GoToSpecialKind = "blanks" | "constants" | "formulas" | "errors" | "notes" | "visible";
+export declare const GO_TO_SPECIAL_OPTIONS: ReadonlyArray<{
+    kind: GoToSpecialKind;
+    label: string;
+}>;
+export type GoToSpecialContext<T extends CellData = CellData> = {
+    sheetId: number;
+    /** The area to scan — the current selection, or the used range for a single cell. */
+    range: GridRange;
+    getCellData(sheetId: number, rowIndex: number, columnIndex: number): T | null | undefined;
+    isRowHidden?(rowIndex: number): boolean;
+    isColumnHidden?(columnIndex: number): boolean;
+    /** Scan guard — Excel refuses huge Go To Special selections as well. */
+    maxCells?: number;
+};
+/** Cells scanned before the search gives up (returns what it found so far). */
+export declare const GO_TO_SPECIAL_MAX_CELLS = 250000;
+/**
+ * Resolve a Go To Special category to the matching cells of `range`, packed
+ * into per-row runs of adjacent columns (what the selection layer paints).
+ * Hidden rows / columns are skipped for every kind — Excel never selects
+ * into a hidden cell from Go To Special. Returns `[]` when nothing matches.
+ */
+export declare const resolveGoToSpecial: <T extends CellData>(kind: GoToSpecialKind, context: GoToSpecialContext<T>) => GridRange[];
+//# sourceMappingURL=go-to-special.d.ts.map

package/dist/cjs/api/go-to-special.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"go-to-special.d.ts","sourceRoot":"","sources":["../../../api/go-to-special.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC;;;;GAIG;AACH,MAAM,MAAM,eAAe,GACvB,QAAQ,GACR,WAAW,GACX,UAAU,GACV,QAAQ,GACR,OAAO,GACP,SAAS,CAAC;AAEd,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAAC;IAChD,IAAI,EAAE,eAAe,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACf,CAOA,CAAC;AAEF,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,IAAI;IAC9D,OAAO,EAAE,MAAM,CAAC;IAChB,qFAAqF;IACrF,KAAK,EAAE,SAAS,CAAC;IACjB,WAAW,CACT,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;IACxB,WAAW,CAAC,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IACxC,cAAc,CAAC,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;IAC9C,wEAAwE;IACxE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,uBAAuB,SAAU,CAAC;AAmD/C;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,QAAQ,EACnD,MAAM,eAAe,EACrB,SAAS,kBAAkB,CAAC,CAAC,CAAC,KAC7B,SAAS,EAoCX,CAAC"}

package/dist/cjs/api/go-to-special.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGoToSpecial = exports.GO_TO_SPECIAL_MAX_CELLS = exports.GO_TO_SPECIAL_OPTIONS = void 0;
+exports.GO_TO_SPECIAL_OPTIONS = [
+    { kind: "notes", label: "Notes" },
+    { kind: "constants", label: "Constants" },
+    { kind: "formulas", label: "Formulas" },
+    { kind: "errors", label: "Errors" },
+    { kind: "blanks", label: "Blanks" },
+    { kind: "visible", label: "Visible cells only" },
+];
+/** Cells scanned before the search gives up (returns what it found so far). */
+exports.GO_TO_SPECIAL_MAX_CELLS = 250000;
+var hasContent = function (cell) {
+    var _a;
+    var ue = (_a = cell === null || cell === void 0 ? void 0 : cell.ue) !== null && _a !== void 0 ? _a : cell === null || cell === void 0 ? void 0 : cell.userEnteredValue;
+    if (!ue)
+        return false;
+    return (ue.fv != null ||
+        ue.formulaValue != null ||
+        ue.sv != null ||
+        ue.stringValue != null ||
+        ue.nv != null ||
+        ue.numberValue != null ||
+        ue.bv != null ||
+        ue.boolValue != null);
+};
+var isFormula = function (cell) {
+    var _a, _b;
+    var ue = (_a = cell === null || cell === void 0 ? void 0 : cell.ue) !== null && _a !== void 0 ? _a : cell === null || cell === void 0 ? void 0 : cell.userEnteredValue;
+    return typeof ((_b = ue === null || ue === void 0 ? void 0 : ue.fv) !== null && _b !== void 0 ? _b : ue === null || ue === void 0 ? void 0 : ue.formulaValue) === "string";
+};
+var isError = function (cell) {
+    var _a, _b;
+    var ev = (_a = cell === null || cell === void 0 ? void 0 : cell.ev) !== null && _a !== void 0 ? _a : cell === null || cell === void 0 ? void 0 : cell.effectiveValue;
+    var error = (_b = ev === null || ev === void 0 ? void 0 : ev.ev) !== null && _b !== void 0 ? _b : ev === null || ev === void 0 ? void 0 : ev.errorValue;
+    return !!error && error.type === "Error";
+};
+var hasNote = function (cell) {
+    return typeof (cell === null || cell === void 0 ? void 0 : cell.note) === "string" && cell.note.trim().length > 0;
+};
+var matches = function (kind, cell) {
+    switch (kind) {
+        case "blanks":
+            return !hasContent(cell);
+        case "constants":
+            return hasContent(cell) && !isFormula(cell);
+        case "formulas":
+            return isFormula(cell);
+        case "errors":
+            return isError(cell);
+        case "notes":
+            return hasNote(cell);
+        case "visible":
+            return true;
+    }
+};
+/**
+ * Resolve a Go To Special category to the matching cells of `range`, packed
+ * into per-row runs of adjacent columns (what the selection layer paints).
+ * Hidden rows / columns are skipped for every kind — Excel never selects
+ * into a hidden cell from Go To Special. Returns `[]` when nothing matches.
+ */
+var resolveGoToSpecial = function (kind, context) {
+    var _a;
+    var sheetId = context.sheetId, range = context.range, getCellData = context.getCellData, isRowHidden = context.isRowHidden, isColumnHidden = context.isColumnHidden;
+    var maxCells = (_a = context.maxCells) !== null && _a !== void 0 ? _a : exports.GO_TO_SPECIAL_MAX_CELLS;
+    var runs = [];
+    var scanned = 0;
+    var _loop_1 = function (row) {
+        if (isRowHidden === null || isRowHidden === void 0 ? void 0 : isRowHidden(row))
+            return "continue";
+        var runStart;
+        var flush = function (endColumn) {
+            if (runStart === undefined)
+                return;
+            runs.push({
+                startRowIndex: row,
+                endRowIndex: row,
+                startColumnIndex: runStart,
+                endColumnIndex: endColumn,
+            });
+            runStart = undefined;
+        };
+        for (var col = range.startColumnIndex; col <= range.endColumnIndex; col++) {
+            if (++scanned > maxCells) {
+                flush(col - 1);
+                return { value: runs };
+            }
+            if (isColumnHidden === null || isColumnHidden === void 0 ? void 0 : isColumnHidden(col)) {
+                flush(col - 1);
+                continue;
+            }
+            if (matches(kind, getCellData(sheetId, row, col))) {
+                if (runStart === undefined)
+                    runStart = col;
+            }
+            else {
+                flush(col - 1);
+            }
+        }
+        flush(range.endColumnIndex);
+    };
+    for (var row = range.startRowIndex; row <= range.endRowIndex; row++) {
+        var state_1 = _loop_1(row);
+        if (typeof state_1 === "object")
+            return state_1.value;
+    }
+    return runs;
+};
+exports.resolveGoToSpecial = resolveGoToSpecial;