@rowsncolumns/utils 9.2.35

package/dist/cjs/conditional-format.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildConditionalFormatExpression = exports.isConditionalFormatFormulaRule = void 0;
+var data_validation_1 = require("./data-validation");
+var selection_1 = require("./selection");
+var FORMULA_PREDICATE_BASE_CELL_REF = "A1";
+var NUMBER_LITERAL_PATTERN = /^-?\d+(?:\.\d+)?$/;
+var BOOLEAN_LITERAL_PATTERN = /^(TRUE|FALSE)$/i;
+var escapeFormulaText = function (value) { return value.replace(/"/g, '""'); };
+/**
+ * Parse a locale-formatted numeric string (e.g., "6,5" in fr-FR) into a JS
+ * number. Uses `Intl.NumberFormat` to detect decimal/group separators.
+ * Returns NaN on failure.
+ */
+var parseLocaleNumberLoose = function (value, locale) {
+    var _a, _b, _c, _d;
+    try {
+        var parts = new Intl.NumberFormat(locale).formatToParts(1234.5);
+        var decimal = (_b = (_a = parts.find(function (part) { return part.type === "decimal"; })) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : ".";
+        var group = (_d = (_c = parts.find(function (part) { return part.type === "group"; })) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : ",";
+        var cleaned = value.split(group).join("").replace(decimal, ".");
+        return Number(cleaned);
+    }
+    catch (_e) {
+        return NaN;
+    }
+};
+/**
+ * Normalize a condition value for use in a formula expression.
+ * Handles locale-specific number formats (e.g., "6,5" -> "6.5").
+ */
+var normalizeConditionValue = function (raw, allowStringLiteral, locale) {
+    if (allowStringLiteral === void 0) { allowStringLiteral = false; }
+    if (!raw)
+        return "";
+    var trimmed = raw.trim();
+    if (!trimmed)
+        return "";
+    if (trimmed.startsWith("=")) {
+        return trimmed.slice(1);
+    }
+    if ((0, selection_1.checkIfStringIsReference)(trimmed)) {
+        return trimmed;
+    }
+    if (NUMBER_LITERAL_PATTERN.test(trimmed) ||
+        BOOLEAN_LITERAL_PATTERN.test(trimmed)) {
+        return trimmed;
+    }
+    // Try parsing as locale-aware number
+    if (locale) {
+        var parsed = parseLocaleNumberLoose(trimmed, locale);
+        if (!isNaN(parsed)) {
+            return String(parsed);
+        }
+    }
+    if (allowStringLiteral) {
+        return "\"".concat(escapeFormulaText(trimmed), "\"");
+    }
+    return trimmed;
+};
+/**
+ * Whether a CF rule is evaluated via the calculator (formula path) instead of
+ * the synchronous `checkBooleanRule` path used in
+ * `apps/spreadsheet/hooks/use-conditional-formatting.ts`.
+ *
+ * Returns `true` for every condition type that `buildConditionalFormatExpression`
+ * can express as a single-cell formula: CUSTOM_FORMULA, all NUMBER_/DATE_/TEXT_
+ * comparisons, BETWEEN/NOT_BETWEEN, CONTAINS/NOT_CONTAINS, STARTS_WITH/ENDS_WITH,
+ * ONE_OF_LIST/ONE_OF_RANGE, BLANK/NOT_BLANK, BOOLEAN, TEXT_IS_EMAIL/TEXT_IS_URL.
+ * The calculator stores the per-cell boolean on
+ * `cellData.conditionalFormattingResultById[ruleId]`.
+ *
+ * Returns `false` — leaving the rule on the sync path — for rules that aren't
+ * expressible as a single-cell formula:
+ *   - Aggregate-over-range: gradient/heatmap, TOP/BOTTOM N, DUPLICATE/UNIQUE,
+ *     NUMBER_ABOVE_AVERAGE / NUMBER_BELOW_AVERAGE — the result depends on
+ *     other cells in the range, not just the current cell.
+ *   - Loop-state: NUMBER_GREATER_THAN_PREVIOUS and the other `*_PREVIOUS`
+ *     variants — compare against the prior row's value held in iteration state.
+ *   - Calendar-relative dates: DATE_TODAY / DATE_THIS_WEEK / DATE_THIS_MONTH
+ *     and the surrounding family, plus DATE_IS_VALID. Could be expressed via
+ *     TODAY()-based formulas if we ever want to migrate them.
+ *   - Cell error state: ERROR / NOT_ERROR — read directly from the extended
+ *     value in `getValidationValue`.
+ *
+ * The consumers (rule create/update/delete enqueueing in spreadsheet-state,
+ * `getConditionalFormatFormula` building the expression, `getValidationValue`
+ * choosing where to read the per-cell value, and the `isFormulaRule` branch
+ * in `use-conditional-formatting.ts`) MUST stay in lockstep with this
+ * predicate — if it returns `true`, the calculator owns the result and the
+ * sync `checkBooleanRule` path must not run for that rule. Delegating to
+ * `buildConditionalFormatExpression` keeps the predicate and the builder from
+ * drifting.
+ */
+var isConditionalFormatFormulaRule = function (rule) {
+    return Boolean((0, exports.buildConditionalFormatExpression)(rule, FORMULA_PREDICATE_BASE_CELL_REF));
+};
+exports.isConditionalFormatFormulaRule = isConditionalFormatFormulaRule;
+var buildConditionalFormatExpression = function (rule, baseCellRef, locale) {
+    var _a, _b, _c, _d;
+    var condition = (_a = rule === null || rule === void 0 ? void 0 : rule.booleanRule) === null || _a === void 0 ? void 0 : _a.condition;
+    if (!(condition === null || condition === void 0 ? void 0 : condition.type))
+        return undefined;
+    var values = (_b = condition.values) !== null && _b !== void 0 ? _b : [];
+    var fromRaw = (_c = values[0]) === null || _c === void 0 ? void 0 : _c.userEnteredValue;
+    var toRaw = (_d = values[1]) === null || _d === void 0 ? void 0 : _d.userEnteredValue;
+    if (condition.type === "CUSTOM_FORMULA") {
+        var raw = fromRaw !== null && fromRaw !== void 0 ? fromRaw : "";
+        var trimmed = raw.trim();
+        if (!trimmed)
+            return undefined;
+        return trimmed.startsWith("=") ? trimmed : "=".concat(trimmed);
+    }
+    var fromExpr = normalizeConditionValue(fromRaw, true, locale);
+    var toExpr = normalizeConditionValue(toRaw, true, locale);
+    if (!fromExpr && !toExpr)
+        return undefined;
+    var comparisonOperatorMap = {
+        NUMBER_EQ: "=",
+        NUMBER_NOT_EQ: "<>",
+        NUMBER_GREATER: ">",
+        NUMBER_GREATER_THAN_EQ: ">=",
+        NUMBER_LESS: "<",
+        NUMBER_LESS_THAN_EQ: "<=",
+        DATE_EQ: "=",
+        DATE_NOT_EQ: "<>",
+        DATE_BEFORE: "<",
+        DATE_AFTER: ">",
+        DATE_ON_OR_BEFORE: "<=",
+        DATE_ON_OR_AFTER: ">=",
+        TEXT_EQ: "=",
+        TEXT_NOT_EQ: "<>",
+    };
+    if (condition.type === "NUMBER_BETWEEN" ||
+        condition.type === "DATE_BETWEEN") {
+        if (!fromExpr || !toExpr)
+            return undefined;
+        return "=AND(".concat(baseCellRef, ">=").concat(fromExpr, ",").concat(baseCellRef, "<=").concat(toExpr, ")");
+    }
+    if (condition.type === "NUMBER_NOT_BETWEEN" ||
+        condition.type === "DATE_NOT_BETWEEN") {
+        if (!fromExpr || !toExpr)
+            return undefined;
+        return "=OR(".concat(baseCellRef, "<").concat(fromExpr, ",").concat(baseCellRef, ">").concat(toExpr, ")");
+    }
+    var comparisonOperator = comparisonOperatorMap[condition.type];
+    if (comparisonOperator) {
+        if (!fromExpr)
+            return undefined;
+        return "=".concat(baseCellRef).concat(comparisonOperator).concat(fromExpr);
+    }
+    if (condition.type === "TEXT_CONTAINS") {
+        if (!fromExpr)
+            return undefined;
+        return "=ISNUMBER(SEARCH(".concat(fromExpr, ",").concat(baseCellRef, "))");
+    }
+    if (condition.type === "TEXT_NOT_CONTAINS") {
+        if (!fromExpr)
+            return undefined;
+        return "=NOT(ISNUMBER(SEARCH(".concat(fromExpr, ",").concat(baseCellRef, ")))");
+    }
+    if (condition.type === "TEXT_STARTS_WITH") {
+        if (!fromExpr)
+            return undefined;
+        return "=LEFT(".concat(baseCellRef, ",LEN(").concat(fromExpr, "))=").concat(fromExpr);
+    }
+    if (condition.type === "TEXT_ENDS_WITH") {
+        if (!fromExpr)
+            return undefined;
+        return "=RIGHT(".concat(baseCellRef, ",LEN(").concat(fromExpr, "))=").concat(fromExpr);
+    }
+    if (condition.type === "TEXT_IS_EMAIL") {
+        return "=ISNUMBER(SEARCH(\"@\",".concat(baseCellRef, "))");
+    }
+    if (condition.type === "TEXT_IS_URL") {
+        return "=OR(LEFT(".concat(baseCellRef, ",7)=\"http://\",LEFT(").concat(baseCellRef, ",8)=\"https://\")");
+    }
+    if (condition.type === "ONE_OF_RANGE") {
+        if (!fromExpr)
+            return undefined;
+        return "=COUNTIF(".concat(fromExpr, ",").concat(baseCellRef, ")>0");
+    }
+    if (condition.type === "ONE_OF_LIST") {
+        var entries = fromRaw
+            ? fromRaw.split(",").map(function (entry) { return entry.trim(); })
+            : [];
+        // A leading apostrophe is Excel's text prefix — `'000s` is the text
+        // "000s" and a bare `'` is empty text — never part of the value. A cell
+        // storing the lone text-prefix apostrophe is equivalent to a blank cell,
+        // so the bare `'` entry accepts it too.
+        var conditions = entries
+            .flatMap(function (entry) {
+            if (entry.startsWith("'")) {
+                var stripped = (0, data_validation_1.stripDataValidationTextPrefix)(entry);
+                var textCondition = "".concat(baseCellRef, "=\"").concat(escapeFormulaText(stripped), "\"");
+                return stripped === ""
+                    ? [textCondition, "".concat(baseCellRef, "=\"'\"")]
+                    : [textCondition];
+            }
+            return entry
+                ? ["".concat(baseCellRef, "=").concat(normalizeConditionValue(entry, true, locale))]
+                : [];
+        })
+            .filter(function (entry) { return Boolean(entry); });
+        if (!conditions.length)
+            return undefined;
+        return conditions.length === 1
+            ? "=".concat(conditions[0])
+            : "=OR(".concat(conditions.join(","), ")");
+    }
+    if (condition.type === "BLANK") {
+        return "=".concat(baseCellRef, "=\"\"");
+    }
+    if (condition.type === "NOT_BLANK") {
+        return "=".concat(baseCellRef, "<>\"\"");
+    }
+    if (condition.type === "BOOLEAN") {
+        return "=OR(".concat(baseCellRef, "=TRUE,").concat(baseCellRef, "=FALSE)");
+    }
+    if (condition.type === "TEXT_EQ" || condition.type === "TEXT_NOT_EQ") {
+        if (!fromExpr)
+            return undefined;
+        return "=".concat(baseCellRef).concat(comparisonOperatorMap[condition.type]).concat(fromExpr);
+    }
+    return undefined;
+};
+exports.buildConditionalFormatExpression = buildConditionalFormatExpression;

package/dist/cjs/content-hash.d.ts

@@ -0,0 +1,16 @@
+export declare const CONTENT_HASH_LENGTH = 8;
+/**
+ * Stable, deterministic 8-character base62 ID derived from the input string.
+ * The same value always produces the same id across sessions, clients, and
+ * languages (FNV-1a 64-bit over UTF-8 bytes → low-48 → base62).
+ *
+ * 62^8 ≈ 2.18e14 ids; birthday-collision risk is negligible for spreadsheet
+ * shared-string tables. Callers that need defense against the astronomically
+ * rare same-id-different-value case should keep a random-id fallback.
+ *
+ * IMPORTANT: This algorithm is mirrored in
+ * `python/rowsncolumns_spreadsheet/utils.py::content_hash`. Any change to the
+ * constants, byte encoding, or base62 alphabet must be applied to both ports.
+ */
+export declare const contentHash: (value: string) => string;
+//# sourceMappingURL=content-hash.d.ts.map

package/dist/cjs/content-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-hash.d.ts","sourceRoot":"","sources":["../../content-hash.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAsCrC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,KAAG,MAa3C,CAAC"}

package/dist/cjs/content-hash.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contentHash = exports.CONTENT_HASH_LENGTH = void 0;
+// BigInt literals (e.g. `0x…n`) need ES2020+; the utils package targets older
+// runtimes, so build them via the BigInt() constructor instead.
+var FNV_OFFSET_BASIS_64 = BigInt("0xcbf29ce484222325");
+var FNV_PRIME_64 = BigInt("0x100000001b3");
+var ONE = BigInt(1);
+var SIXTY_FOUR = BigInt(64);
+var MASK_64 = (ONE << SIXTY_FOUR) - ONE;
+var BASE62_ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+var BASE62 = BigInt(BASE62_ALPHABET.length);
+var TEXT_ENCODER = typeof TextEncoder !== "undefined" ? new TextEncoder() : null;
+exports.CONTENT_HASH_LENGTH = 8;
+var toUtf8Bytes = function (value) {
+    if (TEXT_ENCODER)
+        return TEXT_ENCODER.encode(value);
+    // Minimal UTF-8 fallback for environments without TextEncoder. Mirrors the
+    // standard encoding so the hash stays identical across runtimes.
+    var bytes = [];
+    for (var i = 0; i < value.length; i += 1) {
+        var codePoint = value.charCodeAt(i);
+        if (codePoint >= 0xd800 && codePoint <= 0xdbff && i + 1 < value.length) {
+            var next = value.charCodeAt(i + 1);
+            if (next >= 0xdc00 && next <= 0xdfff) {
+                codePoint = 0x10000 + ((codePoint - 0xd800) << 10) + (next - 0xdc00);
+                i += 1;
+            }
+        }
+        if (codePoint < 0x80) {
+            bytes.push(codePoint);
+        }
+        else if (codePoint < 0x800) {
+            bytes.push(0xc0 | (codePoint >> 6), 0x80 | (codePoint & 0x3f));
+        }
+        else if (codePoint < 0x10000) {
+            bytes.push(0xe0 | (codePoint >> 12), 0x80 | ((codePoint >> 6) & 0x3f), 0x80 | (codePoint & 0x3f));
+        }
+        else {
+            bytes.push(0xf0 | (codePoint >> 18), 0x80 | ((codePoint >> 12) & 0x3f), 0x80 | ((codePoint >> 6) & 0x3f), 0x80 | (codePoint & 0x3f));
+        }
+    }
+    return bytes;
+};
+/**
+ * Stable, deterministic 8-character base62 ID derived from the input string.
+ * The same value always produces the same id across sessions, clients, and
+ * languages (FNV-1a 64-bit over UTF-8 bytes → low-48 → base62).
+ *
+ * 62^8 ≈ 2.18e14 ids; birthday-collision risk is negligible for spreadsheet
+ * shared-string tables. Callers that need defense against the astronomically
+ * rare same-id-different-value case should keep a random-id fallback.
+ *
+ * IMPORTANT: This algorithm is mirrored in
+ * `python/rowsncolumns_spreadsheet/utils.py::content_hash`. Any change to the
+ * constants, byte encoding, or base62 alphabet must be applied to both ports.
+ */
+var contentHash = function (value) {
+    var hash = FNV_OFFSET_BASIS_64;
+    var bytes = toUtf8Bytes(value);
+    for (var i = 0; i < bytes.length; i += 1) {
+        hash ^= BigInt(bytes[i]);
+        hash = (hash * FNV_PRIME_64) & MASK_64;
+    }
+    var result = "";
+    for (var i = 0; i < exports.CONTENT_HASH_LENGTH; i += 1) {
+        result = BASE62_ALPHABET[Number(hash % BASE62)] + result;
+        hash = hash / BASE62;
+    }
+    return result;
+};
+exports.contentHash = contentHash;

package/dist/cjs/data-validation.d.ts

@@ -0,0 +1,54 @@
+import type { DataValidationRule } from "@rowsncolumns/common-types";
+/**
+ * A leading apostrophe in a data-validation / conditional-format list entry is
+ * Excel's text prefix — `'000s` is the text "000s" and a bare `'` is empty
+ * text — never part of the value itself.
+ */
+export declare const stripDataValidationTextPrefix: (entry: string) => string;
+/**
+ * Whether a cell's current text matches a ONE_OF_LIST option, with Excel's
+ * text-prefix semantics on BOTH sides: the option strips its leading `'`
+ * (`'000s` ≡ "000s", a bare `'` ≡ empty text) and a cell storing the lone
+ * text-prefix apostrophe is equivalent to a blank cell. Case-insensitive,
+ * mirroring `checkBooleanRule`'s ONE_OF_LIST matching.
+ */
+export declare const dataValidationOptionMatchesCellValue: (option: string | undefined | null, cellValue: string | undefined | null) => boolean;
+/**
+ * Whether a data validation rule is evaluated via the calculator (formula path)
+ * instead of the synchronous `checkBooleanRule` path used in
+ * `SheetCell.validate()` (`libs/spreadsheet-state/sheet-cell.ts`).
+ *
+ * Returns `true` for every condition type that `buildDataValidationExpression`
+ * can express as a single-cell formula: CUSTOM_FORMULA, all NUMBER_/DATE_/TEXT_
+ * comparisons, BETWEEN/NOT_BETWEEN, CONTAINS/NOT_CONTAINS, STARTS_WITH/ENDS_WITH,
+ * ONE_OF_LIST/ONE_OF_RANGE, BLANK/NOT_BLANK, BOOLEAN, TEXT_IS_EMAIL/TEXT_IS_URL.
+ * The calculator stores the per-cell boolean on
+ * `cellData.dataValidationResultById` and `SheetCell.validate()` reads
+ * `this.dataValidationResult` to decide validity.
+ *
+ * Returns `false` — leaving the rule on the sync path — for rules that aren't
+ * expressible as a single-cell formula:
+ *   - Loop-state: NUMBER_*_PREVIOUS comparisons (compare to prior row).
+ *   - Calendar-relative dates: DATE_TODAY / DATE_THIS_WEEK / DATE_THIS_MONTH
+ *     and the surrounding family, plus DATE_IS_VALID.
+ *   - Cell error state: ERROR / NOT_ERROR.
+ *
+ * Note (input-gating tradeoff): unlike conditional formatting, data validation
+ * decides whether a cell is flagged invalid. The formula path runs through the
+ * calculator, so a freshly-typed value spends one calc tick at
+ * `dataValidationResult === undefined`, during which `SheetCell.validate()`
+ * treats the cell as valid. Anything reading validity synchronously right
+ * after a write may see stale-valid for one tick.
+ *
+ * Consumers that must stay in lockstep with this predicate:
+ *   - `createDataValidationRule` / update / delete (enqueueing into the calc).
+ *   - `getDataValidationFormula` (builds the expression for the calculator).
+ *   - `SheetCell.validate()` (chooses formula-result vs sync `checkBooleanRule`).
+ *   - `use-on-filter-table` (uses the same predicate to decide its formula path).
+ *
+ * Delegating to `buildDataValidationExpression` keeps the predicate and the
+ * builder from drifting.
+ */
+export declare const isDataValidationFormulaRule: (rule: DataValidationRule | undefined) => boolean;
+export declare const buildDataValidationExpression: (rule: DataValidationRule | undefined, baseCellRef: string, locale?: string) => string | undefined;
+//# sourceMappingURL=data-validation.d.ts.map

package/dist/cjs/data-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-validation.d.ts","sourceRoot":"","sources":["../../data-validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,kBAAkB,EACnB,MAAM,4BAA4B,CAAC;AAWpC;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,GAAI,OAAO,MAAM,KAAG,MACd,CAAC;AAEjD;;;;;;GAMG;AACH,eAAO,MAAM,oCAAoC,GAC/C,QAAQ,MAAM,GAAG,SAAS,GAAG,IAAI,EACjC,WAAW,MAAM,GAAG,SAAS,GAAG,IAAI,KACnC,OAKF,CAAC;AAwDF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,2BAA2B,GACtC,MAAM,kBAAkB,GAAG,SAAS,YAKrC,CAAC;AAEF,eAAO,MAAM,6BAA6B,GACxC,MAAM,kBAAkB,GAAG,SAAS,EACpC,aAAa,MAAM,EACnB,SAAS,MAAM,uBA4HhB,CAAC"}

package/dist/cjs/data-validation.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDataValidationExpression = exports.isDataValidationFormulaRule = exports.dataValidationOptionMatchesCellValue = exports.stripDataValidationTextPrefix = void 0;
+var selection_1 = require("./selection");
+var FORMULA_PREDICATE_BASE_CELL_REF = "A1";
+var NUMBER_LITERAL_PATTERN = /^-?\d+(?:\.\d+)?$/;
+var BOOLEAN_LITERAL_PATTERN = /^(TRUE|FALSE)$/i;
+var escapeFormulaText = function (value) { return value.replace(/"/g, '""'); };
+/**
+ * A leading apostrophe in a data-validation / conditional-format list entry is
+ * Excel's text prefix — `'000s` is the text "000s" and a bare `'` is empty
+ * text — never part of the value itself.
+ */
+var stripDataValidationTextPrefix = function (entry) {
+    return entry.startsWith("'") ? entry.slice(1) : entry;
+};
+exports.stripDataValidationTextPrefix = stripDataValidationTextPrefix;
+/**
+ * Whether a cell's current text matches a ONE_OF_LIST option, with Excel's
+ * text-prefix semantics on BOTH sides: the option strips its leading `'`
+ * (`'000s` ≡ "000s", a bare `'` ≡ empty text) and a cell storing the lone
+ * text-prefix apostrophe is equivalent to a blank cell. Case-insensitive,
+ * mirroring `checkBooleanRule`'s ONE_OF_LIST matching.
+ */
+var dataValidationOptionMatchesCellValue = function (option, cellValue) {
+    var normalizedOption = (0, exports.stripDataValidationTextPrefix)(option !== null && option !== void 0 ? option : "");
+    var rawValue = cellValue !== null && cellValue !== void 0 ? cellValue : "";
+    var normalizedValue = rawValue === "'" ? "" : rawValue;
+    return normalizedOption.toLowerCase() === normalizedValue.toLowerCase();
+};
+exports.dataValidationOptionMatchesCellValue = dataValidationOptionMatchesCellValue;
+/**
+ * Parse a locale-formatted numeric string (e.g., "6,5" in fr-FR) into a JS
+ * number. Uses `Intl.NumberFormat` to detect decimal/group separators.
+ * Returns NaN on failure.
+ */
+var parseLocaleNumberLoose = function (value, locale) {
+    var _a, _b, _c, _d;
+    try {
+        var parts = new Intl.NumberFormat(locale).formatToParts(1234.5);
+        var decimal = (_b = (_a = parts.find(function (part) { return part.type === "decimal"; })) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : ".";
+        var group = (_d = (_c = parts.find(function (part) { return part.type === "group"; })) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : ",";
+        var cleaned = value.split(group).join("").replace(decimal, ".");
+        return Number(cleaned);
+    }
+    catch (_e) {
+        return NaN;
+    }
+};
+/**
+ * Normalize a condition value for use in a formula expression.
+ * Handles locale-specific number formats (e.g., "6,5" -> "6.5").
+ */
+var normalizeConditionValue = function (raw, allowStringLiteral, locale) {
+    if (allowStringLiteral === void 0) { allowStringLiteral = false; }
+    if (!raw)
+        return "";
+    var trimmed = raw.trim();
+    if (!trimmed)
+        return "";
+    if (trimmed.startsWith("=")) {
+        return trimmed.slice(1);
+    }
+    if ((0, selection_1.checkIfStringIsReference)(trimmed)) {
+        return trimmed;
+    }
+    if (NUMBER_LITERAL_PATTERN.test(trimmed) ||
+        BOOLEAN_LITERAL_PATTERN.test(trimmed)) {
+        return trimmed;
+    }
+    // Try parsing as locale-aware number
+    if (locale) {
+        var parsed = parseLocaleNumberLoose(trimmed, locale);
+        if (!isNaN(parsed)) {
+            return String(parsed);
+        }
+    }
+    if (allowStringLiteral) {
+        return "\"".concat(escapeFormulaText(trimmed), "\"");
+    }
+    return trimmed;
+};
+/**
+ * Whether a data validation rule is evaluated via the calculator (formula path)
+ * instead of the synchronous `checkBooleanRule` path used in
+ * `SheetCell.validate()` (`libs/spreadsheet-state/sheet-cell.ts`).
+ *
+ * Returns `true` for every condition type that `buildDataValidationExpression`
+ * can express as a single-cell formula: CUSTOM_FORMULA, all NUMBER_/DATE_/TEXT_
+ * comparisons, BETWEEN/NOT_BETWEEN, CONTAINS/NOT_CONTAINS, STARTS_WITH/ENDS_WITH,
+ * ONE_OF_LIST/ONE_OF_RANGE, BLANK/NOT_BLANK, BOOLEAN, TEXT_IS_EMAIL/TEXT_IS_URL.
+ * The calculator stores the per-cell boolean on
+ * `cellData.dataValidationResultById` and `SheetCell.validate()` reads
+ * `this.dataValidationResult` to decide validity.
+ *
+ * Returns `false` — leaving the rule on the sync path — for rules that aren't
+ * expressible as a single-cell formula:
+ *   - Loop-state: NUMBER_*_PREVIOUS comparisons (compare to prior row).
+ *   - Calendar-relative dates: DATE_TODAY / DATE_THIS_WEEK / DATE_THIS_MONTH
+ *     and the surrounding family, plus DATE_IS_VALID.
+ *   - Cell error state: ERROR / NOT_ERROR.
+ *
+ * Note (input-gating tradeoff): unlike conditional formatting, data validation
+ * decides whether a cell is flagged invalid. The formula path runs through the
+ * calculator, so a freshly-typed value spends one calc tick at
+ * `dataValidationResult === undefined`, during which `SheetCell.validate()`
+ * treats the cell as valid. Anything reading validity synchronously right
+ * after a write may see stale-valid for one tick.
+ *
+ * Consumers that must stay in lockstep with this predicate:
+ *   - `createDataValidationRule` / update / delete (enqueueing into the calc).
+ *   - `getDataValidationFormula` (builds the expression for the calculator).
+ *   - `SheetCell.validate()` (chooses formula-result vs sync `checkBooleanRule`).
+ *   - `use-on-filter-table` (uses the same predicate to decide its formula path).
+ *
+ * Delegating to `buildDataValidationExpression` keeps the predicate and the
+ * builder from drifting.
+ */
+var isDataValidationFormulaRule = function (rule) {
+    return Boolean((0, exports.buildDataValidationExpression)(rule, FORMULA_PREDICATE_BASE_CELL_REF));
+};
+exports.isDataValidationFormulaRule = isDataValidationFormulaRule;
+var buildDataValidationExpression = function (rule, baseCellRef, locale) {
+    var _a, _b, _c;
+    var condition = rule === null || rule === void 0 ? void 0 : rule.condition;
+    if (!(condition === null || condition === void 0 ? void 0 : condition.type))
+        return undefined;
+    var values = (_a = condition.values) !== null && _a !== void 0 ? _a : [];
+    var fromRaw = (_b = values[0]) === null || _b === void 0 ? void 0 : _b.userEnteredValue;
+    var toRaw = (_c = values[1]) === null || _c === void 0 ? void 0 : _c.userEnteredValue;
+    if (condition.type === "CUSTOM_FORMULA") {
+        var raw = fromRaw !== null && fromRaw !== void 0 ? fromRaw : "";
+        var trimmed = raw.trim();
+        if (!trimmed)
+            return undefined;
+        return trimmed.startsWith("=") ? trimmed : "=".concat(trimmed);
+    }
+    var fromExpr = normalizeConditionValue(fromRaw, true, locale);
+    var toExpr = normalizeConditionValue(toRaw, true, locale);
+    if (!fromExpr && !toExpr)
+        return undefined;
+    var comparisonOperatorMap = {
+        NUMBER_EQ: "=",
+        NUMBER_NOT_EQ: "<>",
+        NUMBER_GREATER: ">",
+        NUMBER_GREATER_THAN_EQ: ">=",
+        NUMBER_LESS: "<",
+        NUMBER_LESS_THAN_EQ: "<=",
+        DATE_EQ: "=",
+        DATE_NOT_EQ: "<>",
+        DATE_BEFORE: "<",
+        DATE_AFTER: ">",
+        DATE_ON_OR_BEFORE: "<=",
+        DATE_ON_OR_AFTER: ">=",
+        TEXT_EQ: "=",
+        TEXT_NOT_EQ: "<>",
+    };
+    if (condition.type === "NUMBER_BETWEEN" ||
+        condition.type === "DATE_BETWEEN") {
+        if (!fromExpr || !toExpr)
+            return undefined;
+        return "=AND(".concat(baseCellRef, ">=").concat(fromExpr, ",").concat(baseCellRef, "<=").concat(toExpr, ")");
+    }
+    if (condition.type === "NUMBER_NOT_BETWEEN" ||
+        condition.type === "DATE_NOT_BETWEEN") {
+        if (!fromExpr || !toExpr)
+            return undefined;
+        return "=OR(".concat(baseCellRef, "<").concat(fromExpr, ",").concat(baseCellRef, ">").concat(toExpr, ")");
+    }
+    var comparisonOperator = comparisonOperatorMap[condition.type];
+    if (comparisonOperator) {
+        if (!fromExpr)
+            return undefined;
+        return "=".concat(baseCellRef).concat(comparisonOperator).concat(fromExpr);
+    }
+    if (condition.type === "TEXT_CONTAINS") {
+        if (!fromExpr)
+            return undefined;
+        return "=ISNUMBER(SEARCH(".concat(fromExpr, ",").concat(baseCellRef, "))");
+    }
+    if (condition.type === "TEXT_NOT_CONTAINS") {
+        if (!fromExpr)
+            return undefined;
+        return "=NOT(ISNUMBER(SEARCH(".concat(fromExpr, ",").concat(baseCellRef, ")))");
+    }
+    if (condition.type === "TEXT_STARTS_WITH") {
+        if (!fromExpr)
+            return undefined;
+        return "=LEFT(".concat(baseCellRef, ",LEN(").concat(fromExpr, "))=").concat(fromExpr);
+    }
+    if (condition.type === "TEXT_ENDS_WITH") {
+        if (!fromExpr)
+            return undefined;
+        return "=RIGHT(".concat(baseCellRef, ",LEN(").concat(fromExpr, "))=").concat(fromExpr);
+    }
+    if (condition.type === "TEXT_IS_EMAIL") {
+        return "=ISNUMBER(SEARCH(\"@\",".concat(baseCellRef, "))");
+    }
+    if (condition.type === "TEXT_IS_URL") {
+        return "=OR(LEFT(".concat(baseCellRef, ",7)=\"http://\",LEFT(").concat(baseCellRef, ",8)=\"https://\")");
+    }
+    if (condition.type === "ONE_OF_RANGE") {
+        if (!fromExpr)
+            return undefined;
+        if (rule === null || rule === void 0 ? void 0 : rule.allowBlank) {
+            return "=IF(".concat(baseCellRef, "=\"\",TRUE,COUNTIF(").concat(fromExpr, ",").concat(baseCellRef, ")>0)");
+        }
+        return "=COUNTIF(".concat(fromExpr, ",").concat(baseCellRef, ")>0");
+    }
+    if (condition.type === "ONE_OF_LIST") {
+        var entries = fromRaw
+            ? fromRaw.split(",").map(function (entry) { return entry.trim(); })
+            : [];
+        // A leading apostrophe is Excel's text prefix — `'000s` is the text
+        // "000s" and a bare `'` is empty text — never part of the value.
+        var conditions = entries
+            .flatMap(function (entry) {
+            if (entry.startsWith("'")) {
+                var stripped = (0, exports.stripDataValidationTextPrefix)(entry);
+                var textCondition = "".concat(baseCellRef, "=\"").concat(escapeFormulaText(stripped), "\"");
+                // The bare `'` entry means empty text, and a cell storing the lone
+                // text-prefix apostrophe is equivalent to a blank cell — accept it too.
+                return stripped === ""
+                    ? [textCondition, "".concat(baseCellRef, "=\"'\"")]
+                    : [textCondition];
+            }
+            return entry
+                ? ["".concat(baseCellRef, "=").concat(normalizeConditionValue(entry, true, locale))]
+                : [];
+        })
+            .filter(function (entry) { return Boolean(entry); });
+        if (!conditions.length)
+            return undefined;
+        return conditions.length === 1
+            ? "=".concat(conditions[0])
+            : "=OR(".concat(conditions.join(","), ")");
+    }
+    if (condition.type === "BLANK") {
+        return "=".concat(baseCellRef, "=\"\"");
+    }
+    if (condition.type === "NOT_BLANK") {
+        return "=".concat(baseCellRef, "<>\"\"");
+    }
+    if (condition.type === "BOOLEAN") {
+        return "=OR(".concat(baseCellRef, "=TRUE,").concat(baseCellRef, "=FALSE)");
+    }
+    return undefined;
+};
+exports.buildDataValidationExpression = buildDataValidationExpression;

package/dist/cjs/date.d.ts

@@ -0,0 +1,15 @@
+export type DateSerialMode = "local" | "excel-utc";
+/**
+ * Convert date to serial with explicit time zone behavior.
+ * - local: interpret date components in local time (UI entry behavior).
+ * - excel-utc: treat Date as UTC (formula engine behavior).
+ */
+export declare const toSerialWithMode: (date: Date, use1904?: boolean, mode?: DateSerialMode) => number;
+export declare const toSerial: (date: Date, use1904?: boolean) => number;
+/**
+ * Convert serial to date
+ * @param serial
+ * @returns
+ */
+export declare const toDate: (serial: number, use1904?: boolean) => Date;
+//# sourceMappingURL=date.d.ts.map

package/dist/cjs/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../date.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,WAAW,CAAC;AAEnD;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAC3B,MAAM,IAAI,EACV,iBAAe,EACf,OAAM,cAAwB,WAwB/B,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,MAAM,IAAI,EAAE,iBAAe,WAEnD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,MAAM,GAAI,QAAQ,MAAM,EAAE,iBAAe,SA+BrD,CAAC"}