@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/api/table.js

@@ -0,0 +1,337 @@
+var _a, _b, _c;
+import { __assign, __read, __spreadArray, __values } from "tslib";
+import { lexify, tokenVocabulary, } from "@rowsncolumns/calculator";
+import { Direction } from "@rowsncolumns/common-types";
+import { isAFormula, isCellWithinBounds, isNil, iterateCellsInRange, } from "@rowsncolumns/utils";
+import { SheetCell } from "../sheet-cell";
+import { detokenize } from "./formula";
+import { moveFilterView, moveRange } from "./selection";
+var isTableColumnToken = function (token) {
+    return token.tokenType.name === tokenVocabulary.TableColumnName.name;
+};
+var isTableNameToken = function (token) {
+    return token.tokenType.name === tokenVocabulary.TableName.name;
+};
+/**
+ * Get table column index
+ * @param sheetId
+ * @param cell
+ * @param tables
+ */
+export var findTableColumnIndex = function (sheetId, cell, tables) {
+    var e_1, _a;
+    var rowIndex = cell.rowIndex, columnIndex = cell.columnIndex;
+    if (tables) {
+        try {
+            for (var tables_1 = __values(tables), tables_1_1 = tables_1.next(); !tables_1_1.done; tables_1_1 = tables_1.next()) {
+                var table = tables_1_1.value;
+                // Header row
+                if (table.sheetId === sheetId &&
+                    table.range.startRowIndex === rowIndex &&
+                    columnIndex >= table.range.startColumnIndex &&
+                    columnIndex <= table.range.endColumnIndex) {
+                    return columnIndex - table.range.startColumnIndex;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (tables_1_1 && !tables_1_1.done && (_a = tables_1.return)) _a.call(tables_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    return undefined;
+};
+export var findActiveTableWithinCell = function (sheetId, cell, tables) {
+    return tables === null || tables === void 0 ? void 0 : tables.find(function (table) {
+        return table.sheetId === sheetId && isCellWithinBounds(cell, table.range);
+    });
+};
+/**
+ * Find table adjacent to a cell
+ * @param sheetId
+ * @param cell
+ * @param tables
+ * @returns
+ */
+export var findAdjacentTable = function (sheetId, cell, tables, getUserEnteredValue) {
+    var adjacentTable = tables === null || tables === void 0 ? void 0 : tables.find(function (table) {
+        var rowExpansion = table.range.endRowIndex + 1 === cell.rowIndex && !table.totalRow;
+        var columnExpansion = table.range.endColumnIndex + 1 === cell.columnIndex;
+        var isAdjacent = table.sheetId === sheetId &&
+            (rowExpansion || columnExpansion) &&
+            isCellWithinBounds(cell, __assign(__assign({}, table.range), { endRowIndex: table.range.endRowIndex + 1, endColumnIndex: table.range.endColumnIndex + 1 }));
+        if (!isAdjacent) {
+            return false;
+        }
+        var lookupRange = __assign(__assign({}, table.range), (rowExpansion
+            ? {
+                startRowIndex: cell.rowIndex,
+                endRowIndex: cell.rowIndex,
+            }
+            : {
+                startColumnIndex: cell.columnIndex,
+                endColumnIndex: cell.columnIndex,
+            }));
+        return (isAdjacent &&
+            __spreadArray([], __read(iterateCellsInRange(lookupRange)), false).every(function (_a) {
+                var _b = __read(_a, 2), rowIndex = _b[0], columnIndex = _b[1];
+                return isNil(getUserEnteredValue(sheetId, rowIndex, columnIndex));
+            }));
+    });
+    var totalRowOffset = (adjacentTable === null || adjacentTable === void 0 ? void 0 : adjacentTable.totalRow) ? 1 : 0;
+    var isRowExpansion = adjacentTable
+        ? adjacentTable.range.endRowIndex + 1 - totalRowOffset === cell.rowIndex
+        : false;
+    var isColumnExpansion = adjacentTable
+        ? adjacentTable.range.endColumnIndex + 1 === cell.columnIndex
+        : false;
+    return [adjacentTable, isRowExpansion, isColumnExpansion];
+};
+/**
+ * Find table adjacent to a cell
+ * @param sheetId
+ * @param cell
+ * @param tables
+ * @returns
+ */
+export var findAdjacentBandedRange = function (sheetId, cell, bandedRanges, getUserEnteredValue) {
+    var adjacentTable = bandedRanges === null || bandedRanges === void 0 ? void 0 : bandedRanges.find(function (bandedRange) {
+        var rowExpansion = bandedRange.range.endRowIndex + 1 === cell.rowIndex;
+        var columnExpansion = bandedRange.range.endColumnIndex + 1 === cell.columnIndex;
+        var isAdjacent = (rowExpansion || columnExpansion) &&
+            isCellWithinBounds(cell, __assign(__assign({}, bandedRange.range), { endRowIndex: bandedRange.range.endRowIndex + 1, endColumnIndex: bandedRange.range.endColumnIndex + 1 }));
+        if (!isAdjacent) {
+            return false;
+        }
+        var lookupRange = __assign(__assign({}, bandedRange.range), (rowExpansion
+            ? {
+                startRowIndex: cell.rowIndex,
+                endRowIndex: cell.rowIndex,
+            }
+            : {
+                startColumnIndex: cell.columnIndex,
+                endColumnIndex: cell.columnIndex,
+            }));
+        return (isAdjacent &&
+            __spreadArray([], __read(iterateCellsInRange(lookupRange)), false).every(function (_a) {
+                var _b = __read(_a, 2), rowIndex = _b[0], columnIndex = _b[1];
+                return isNil(getUserEnteredValue(sheetId, rowIndex, columnIndex));
+            }));
+    });
+    var isRowExpansion = adjacentTable
+        ? adjacentTable.range.endRowIndex + 1 === cell.rowIndex
+        : false;
+    var isColumnExpansion = adjacentTable
+        ? adjacentTable.range.endColumnIndex + 1 === cell.columnIndex
+        : false;
+    return [adjacentTable, isRowExpansion, isColumnExpansion];
+};
+// Check if table cells are fillable
+export var isTableColumnCellsFillable = function (sheetId, range, excludeCell, existingColumnFormula, currentValue, activeSheetName, getUserEnteredValue) {
+    var _a;
+    var normalizedExistingFormula = normalizeFormulaString(existingColumnFormula);
+    var normalizedCurrentFormula = isAFormula(currentValue)
+        ? normalizeFormulaString(currentValue)
+        : undefined;
+    var templateFormula = normalizedExistingFormula !== null && normalizedExistingFormula !== void 0 ? normalizedExistingFormula : normalizedCurrentFormula;
+    if (!templateFormula) {
+        return false;
+    }
+    var normalizedTemplate = (_a = SheetCell.getRelativeFormula(templateFormula, excludeCell, excludeCell, activeSheetName)) !== null && _a !== void 0 ? _a : templateFormula;
+    var templateHasReferences = formulaHasCellReferences(templateFormula);
+    var isAnchorCell = excludeCell.rowIndex === range.startRowIndex &&
+        excludeCell.columnIndex === range.startColumnIndex;
+    var normalizedCurrentLiteral = normalizeFormulaString(typeof currentValue === "string" ? currentValue : undefined);
+    if (normalizedExistingFormula && !templateHasReferences) {
+        return false;
+    }
+    return __spreadArray([], __read(iterateCellsInRange(range)), false).every(function (_a) {
+        var _b = __read(_a, 2), rowIndex = _b[0], columnIndex = _b[1];
+        if (rowIndex === excludeCell.rowIndex &&
+            columnIndex === excludeCell.columnIndex) {
+            return true;
+        }
+        var userEnteredValue = getUserEnteredValue(sheetId, rowIndex, columnIndex);
+        if (isNil(userEnteredValue) || userEnteredValue === "") {
+            return true;
+        }
+        if (!isAFormula(userEnteredValue)) {
+            return false;
+        }
+        var relativeFormula = SheetCell.getRelativeFormula(userEnteredValue, { rowIndex: rowIndex, columnIndex: columnIndex }, excludeCell, activeSheetName);
+        var comparable = relativeFormula !== null && relativeFormula !== void 0 ? relativeFormula : userEnteredValue;
+        return normalizedTemplate === comparable;
+    });
+};
+var formulaHasCellReferences = function (formula) {
+    if (!formula || typeof formula !== "string" || !formula.startsWith("=")) {
+        return false;
+    }
+    var tokens = lexify(formula).tokens;
+    return tokens.some(function (token) {
+        return CELL_REFERENCE_TOKEN_NAMES.has(token.tokenType.name);
+    });
+};
+var CELL_REFERENCE_TOKEN_NAMES = new Set([
+    (_a = tokenVocabulary.Cell) === null || _a === void 0 ? void 0 : _a.name,
+    (_b = tokenVocabulary.Column) === null || _b === void 0 ? void 0 : _b.name,
+    (_c = tokenVocabulary.TableColumnName) === null || _c === void 0 ? void 0 : _c.name,
+].filter(function (tokenName) { return Boolean(tokenName); }));
+var normalizeFormulaString = function (value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    var trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return trimmed.startsWith("=") ? trimmed : "=".concat(trimmed);
+};
+// Add table name to formula
+export var addTableNameToTokens = function (tokens, title) {
+    var newTokens = [];
+    var offset = 0;
+    var len = title.length;
+    for (var i = 0; i < tokens.length; i++) {
+        var token = tokens[i];
+        if (token.structured &&
+            isTableColumnToken(token) &&
+            isNil(token.tableName)) {
+            token.tableName = title;
+            token.image = title + token.image;
+            token.endColumn += len;
+            token.endOffset += len;
+            offset += len;
+        }
+        else {
+            token.endColumn += offset;
+            token.endOffset += offset;
+        }
+        newTokens.push(token);
+    }
+    return detokenize(newTokens);
+};
+/**
+ * Remove table name from formula
+ * @param formula
+ * @returns
+ */
+var replaceTable = function (formula) {
+    var bracketIndex = formula.indexOf("[");
+    if (bracketIndex === -1) {
+        return formula;
+    }
+    return formula.slice(bracketIndex);
+};
+export var removeTableName = function (tokens, title) {
+    var _a, _b;
+    // // Use regular expression to match the pattern and extract the column name
+    var newTokens = [];
+    var offset = 0;
+    for (var i = 0; i < tokens.length; i++) {
+        var token = tokens[i];
+        if (token.structured &&
+            isTableNameToken(token) &&
+            token.tableName === title) {
+            var len = (_b = (_a = token === null || token === void 0 ? void 0 : token.tableName) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+            token.tableName = undefined;
+            token.image = replaceTable(token.image);
+            token.endColumn -= len;
+            token.endOffset -= len;
+            offset -= len;
+        }
+        else {
+            token.endColumn -= offset;
+            token.endOffset -= offset;
+        }
+        newTokens.push(token);
+    }
+    return detokenize(newTokens);
+};
+/**
+ * Shift tables
+ */
+export var shiftTableMovingRows = function (table, dims, referenceIndex) {
+    var _a = dims, firstDim = _a[0], _b = dims.length - 1, lastDim = _a[_b];
+    /**
+     * Scenarios
+     * 1. User is moving the entire table
+     * 2. User is moving a row out of table => Not allowed
+     * 3. User is moving a row inside a table
+     * 4. User is moving a row from the bottom to top of the table => No changes to table required
+     */
+    var count = dims.length;
+    // Scenario 1
+    if (firstDim <= table.range.startRowIndex &&
+        lastDim >= table.range.endRowIndex) {
+        // User is moving the entire table
+        var delta = referenceIndex - firstDim;
+        table.range = moveRange(table.range, table.range, __assign(__assign({}, table.range), { startRowIndex: table.range.startRowIndex + delta, endRowIndex: table.range.endRowIndex + delta }));
+    }
+    else if (firstDim < table.range.startRowIndex ||
+        lastDim > table.range.endRowIndex) {
+        // Check if user is inserting ?
+        if (referenceIndex > table.range.startRowIndex &&
+            referenceIndex < table.range.endRowIndex) {
+            // Moving from top
+            if (firstDim < table.range.startRowIndex) {
+                moveFilterView(table, count, Direction.Up);
+            }
+            // Insert
+            table.range.endRowIndex += count;
+        }
+        else if (firstDim <= table.range.startRowIndex &&
+            referenceIndex >= table.range.endRowIndex) {
+            moveFilterView(table, count, Direction.Up);
+        }
+        else if (firstDim >= table.range.endRowIndex &&
+            referenceIndex <= table.range.startRowIndex) {
+            moveFilterView(table, count, Direction.Down);
+        }
+    }
+};
+/**
+ * Shift tables
+ */
+export var shiftTableMovingColumns = function (table, dims, referenceIndex) {
+    var _a = dims, firstDim = _a[0], _b = dims.length - 1, lastDim = _a[_b];
+    /**
+     * Scenarios
+     * 1. User is moving the entire table
+     * 2. User is moving a row out of table => Not allowed
+     * 3. User is moving a row inside a table
+     * 4. User is moving a row from the bottom to top of the table => No changes to table required
+     */
+    var count = dims.length;
+    // Scenario 1
+    if (firstDim <= table.range.startColumnIndex &&
+        lastDim >= table.range.endColumnIndex) {
+        // User is moving the entire table
+        var delta = referenceIndex - firstDim;
+        table.range = moveRange(table.range, table.range, __assign(__assign({}, table.range), { startColumnIndex: table.range.startColumnIndex + delta, endColumnIndex: table.range.endColumnIndex + delta }));
+    }
+    else if (firstDim < table.range.startColumnIndex ||
+        lastDim > table.range.endColumnIndex) {
+        // Check if user is inserting ?
+        if (referenceIndex > table.range.startColumnIndex &&
+            referenceIndex < table.range.endColumnIndex) {
+            // Moving from top
+            if (firstDim < table.range.startColumnIndex) {
+                moveFilterView(table, count, Direction.Left);
+            }
+            // Insert
+            table.range.endColumnIndex += count;
+        }
+        else if (firstDim <= table.range.startColumnIndex &&
+            referenceIndex >= table.range.endColumnIndex) {
+            moveFilterView(table, count, Direction.Left);
+        }
+        else if (firstDim >= table.range.endColumnIndex &&
+            referenceIndex <= table.range.startColumnIndex) {
+            moveFilterView(table, count, Direction.Right);
+        }
+    }
+};

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

@@ -0,0 +1,12 @@
+import type { ConditionValue, DataValidationRule } from "@rowsncolumns/spreadsheet";
+type CustomFormulaResult = string | number | boolean | Date | null | undefined | {
+    type?: string;
+    message?: string;
+};
+export declare const validationValueToDate: (value: string) => Date;
+export type CheckBooleanRuleOptions = {
+    locale?: string;
+};
+export declare const checkBooleanRule: (rule?: DataValidationRule | undefined, value?: CustomFormulaResult, previousValue?: CustomFormulaResult, getRangeValues?: (address: string) => ConditionValue[], options?: CheckBooleanRuleOptions) => boolean | undefined;
+export {};
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../api/validation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAiBpF,KAAK,mBAAmB,GACpB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,IAAI,GACJ,SAAS,GACT;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAoBxC,eAAO,MAAM,qBAAqB,GAAI,OAAO,MAAM,SA6BlD,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,OAAO,kBAAkB,GAAG,SAAS,EACrC,QAAQ,mBAAmB,EAC3B,gBAAgB,mBAAmB,EACnC,iBAAiB,CAAC,OAAO,EAAE,MAAM,KAAK,cAAc,EAAE,EACtD,UAAU,uBAAuB,wBAsTlC,CAAC"}

package/dist/cjs/api/validation.js

@@ -0,0 +1,306 @@
+import { checkIfStringIsReference, escapeCharacters, isNil, stripDataValidationTextPrefix, toDate, toSerial, } from "@rowsncolumns/utils";
+import { convertToNumber } from "./datatype";
+var EMAIL_REGEX = /(?:[a-z0-9!#$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+\/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])/;
+var URL_REGEX = /^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$/;
+var splitDataValidationListValues = function (listString) {
+    if (isNil(listString)) {
+        return [];
+    }
+    var trimmedString = listString.replace(/^"(.*)"$/, "$1");
+    return trimmedString
+        .split(",")
+        .map(function (value) { return value.trim(); })
+        // A leading apostrophe is Excel's text prefix (`'000s` is the text
+        // "000s"), never part of the value.
+        .map(stripDataValidationTextPrefix)
+        .map(function (userEnteredValue) { return ({
+        userEnteredValue: userEnteredValue,
+    }); });
+};
+export var validationValueToDate = function (value) {
+    switch (value) {
+        case "today":
+            return new Date();
+        case "yesterday":
+            return new Date(new Date().getTime() - 24 * 60 * 60 * 1000);
+        case "last7Days":
+            return new Date(new Date().getTime() - 7 * 24 * 60 * 60 * 1000);
+        case "lastMonth":
+            return new Date(new Date().getFullYear(), new Date().getMonth() - 1, 1);
+        case "lastWeek":
+            return new Date(new Date().getTime() - 7 * 24 * 60 * 60 * 1000);
+        case "nextMonth":
+            return new Date(new Date().getFullYear(), new Date().getMonth() + 1, 1);
+        case "nextWeek":
+            return new Date(new Date().setDate(new Date().getDate() + 7 - new Date().getDay() + 1));
+        case "thisMonth":
+            return new Date(new Date().getFullYear(), new Date().getMonth(), 1);
+        case "thisWeek":
+            return new Date(new Date().setDate(new Date().getDate() - new Date().getDay() + 1));
+        case "tomorrow":
+            return new Date(new Date().getTime() + 24 * 60 * 60 * 1000);
+        default:
+            return new Date(value);
+    }
+};
+export var checkBooleanRule = function (rule, value, previousValue, getRangeValues, options) {
+    var _a, _b, _c, _d, _e, _f;
+    void previousValue;
+    var locale = (options !== null && options !== void 0 ? options : {}).locale;
+    var parseNumber = function (val) {
+        if (val === null || (typeof val === "object" && !(val instanceof Date))) {
+            return NaN;
+        }
+        return convertToNumber(val, locale);
+    };
+    var isErrorValue = function (entry) {
+        return Boolean(entry &&
+            typeof entry === "object" &&
+            "type" in entry &&
+            "message" in entry);
+    };
+    var normalizeDate = function (date) {
+        return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+    };
+    var toComparableDate = function (entry) {
+        if (entry instanceof Date) {
+            return entry;
+        }
+        if (typeof entry === "number" && Number.isFinite(entry)) {
+            return toDate(entry);
+        }
+        if (typeof entry === "string") {
+            var trimmed = entry.trim();
+            if (!trimmed)
+                return undefined;
+            var asNumber = Number(trimmed);
+            if (Number.isFinite(asNumber)) {
+                return toDate(asNumber);
+            }
+            var parsed = new Date(trimmed);
+            if (!isNaN(parsed.getTime())) {
+                return parsed;
+            }
+        }
+        return undefined;
+    };
+    var getWeekStart = function (date) {
+        var day = date.getDay();
+        var diff = day === 0 ? -6 : 1 - day;
+        return new Date(date.getFullYear(), date.getMonth(), date.getDate() + diff);
+    };
+    var getTimePeriodRange = function (type) {
+        var today = normalizeDate(new Date());
+        var startOfDay = function (date) { return normalizeDate(date); };
+        var endOfDay = function (date) {
+            return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59, 999);
+        };
+        switch (type) {
+            case "DATE_TODAY": {
+                return { start: startOfDay(today), end: endOfDay(today) };
+            }
+            case "DATE_YESTERDAY": {
+                var target = new Date(today);
+                target.setDate(target.getDate() - 1);
+                return { start: startOfDay(target), end: endOfDay(target) };
+            }
+            case "DATE_TOMORROW": {
+                var target = new Date(today);
+                target.setDate(target.getDate() + 1);
+                return { start: startOfDay(target), end: endOfDay(target) };
+            }
+            case "DATE_LAST_7_DAYS": {
+                var start = new Date(today);
+                start.setDate(start.getDate() - 6);
+                return { start: startOfDay(start), end: endOfDay(today) };
+            }
+            case "DATE_THIS_WEEK": {
+                var start = getWeekStart(today);
+                var end = new Date(start);
+                end.setDate(end.getDate() + 6);
+                return { start: startOfDay(start), end: endOfDay(end) };
+            }
+            case "DATE_LAST_WEEK": {
+                var thisWeekStart = getWeekStart(today);
+                var start = new Date(thisWeekStart);
+                start.setDate(start.getDate() - 7);
+                var end = new Date(thisWeekStart);
+                end.setDate(end.getDate() - 1);
+                return { start: startOfDay(start), end: endOfDay(end) };
+            }
+            case "DATE_NEXT_WEEK": {
+                var thisWeekStart = getWeekStart(today);
+                var start = new Date(thisWeekStart);
+                start.setDate(start.getDate() + 7);
+                var end = new Date(thisWeekStart);
+                end.setDate(end.getDate() + 13);
+                return { start: startOfDay(start), end: endOfDay(end) };
+            }
+            case "DATE_THIS_MONTH": {
+                var start = new Date(today.getFullYear(), today.getMonth(), 1);
+                var end = new Date(today.getFullYear(), today.getMonth() + 1, 0);
+                return { start: startOfDay(start), end: endOfDay(end) };
+            }
+            case "DATE_LAST_MONTH": {
+                var start = new Date(today.getFullYear(), today.getMonth() - 1, 1);
+                var end = new Date(today.getFullYear(), today.getMonth(), 0);
+                return { start: startOfDay(start), end: endOfDay(end) };
+            }
+            case "DATE_NEXT_MONTH": {
+                var start = new Date(today.getFullYear(), today.getMonth() + 1, 1);
+                var end = new Date(today.getFullYear(), today.getMonth() + 2, 0);
+                return { start: startOfDay(start), end: endOfDay(end) };
+            }
+            default:
+                return undefined;
+        }
+    };
+    var condition = rule === null || rule === void 0 ? void 0 : rule.condition;
+    if (!condition || !condition.type) {
+        return true;
+    }
+    var allowBlank = rule === null || rule === void 0 ? void 0 : rule.allowBlank;
+    if (allowBlank && (value === "" || isNil(value))) {
+        return true;
+    }
+    var type = condition.type, values = condition.values;
+    var valuesArray = values !== null && values !== void 0 ? values : [];
+    var firstValue = (_a = valuesArray[0]) !== null && _a !== void 0 ? _a : { userEnteredValue: "" };
+    switch (type) {
+        case "TEXT_EQ":
+            return new RegExp("^" + escapeCharacters(firstValue.userEnteredValue) + "$", "gi").test(String(value));
+        case "BLANK":
+            return value === "" || isNil(value);
+        case "BOOLEAN":
+            // A blank cell under a checkbox rule is an unchecked checkbox, not a
+            // violation (Google Sheets semantics) — flagging it Invalid would also
+            // suppress the checkbox render for freshly inserted checkboxes.
+            return typeof value === "boolean" || value === "" || isNil(value);
+        case "CUSTOM_FORMULA":
+            return value === true;
+        case "NUMBER_BETWEEN": {
+            var num = parseNumber(value);
+            var bound1 = parseNumber(firstValue.userEnteredValue);
+            var bound2 = parseNumber((_b = valuesArray[1]) === null || _b === void 0 ? void 0 : _b.userEnteredValue);
+            var min = Math.min(bound1, bound2);
+            var max = Math.max(bound1, bound2);
+            return num >= min && num <= max;
+        }
+        case "NUMBER_NOT_BETWEEN": {
+            var num = parseNumber(value);
+            var bound1 = parseNumber(firstValue.userEnteredValue);
+            var bound2 = parseNumber((_c = valuesArray[1]) === null || _c === void 0 ? void 0 : _c.userEnteredValue);
+            var min = Math.min(bound1, bound2);
+            var max = Math.max(bound1, bound2);
+            return !(num >= min && num <= max);
+        }
+        case "NUMBER_EQ":
+            return parseNumber(value) === parseNumber(firstValue.userEnteredValue);
+        case "NUMBER_GREATER":
+            return parseNumber(value) > parseNumber(firstValue.userEnteredValue);
+        case "NUMBER_GREATER_THAN_EQ":
+            return parseNumber(value) >= parseNumber(firstValue.userEnteredValue);
+        case "NUMBER_LESS":
+            return parseNumber(value) < parseNumber(firstValue.userEnteredValue);
+        case "NUMBER_LESS_THAN_EQ":
+            return parseNumber(value) <= parseNumber(firstValue.userEnteredValue);
+        case "NUMBER_GREATER_THAN_PREVIOUS":
+        case "NUMBER_GREATER_THAN_EQ_PREVIOUS":
+        case "NUMBER_LESS_THAN_PREVIOUS":
+        case "NUMBER_LESS_THAN_EQ_PREVIOUS":
+            return false;
+        case "NUMBER_NOT_EQ":
+            return parseNumber(value) !== parseNumber(firstValue.userEnteredValue);
+        case "TEXT_CONTAINS":
+            return new RegExp(escapeCharacters(firstValue.userEnteredValue), "gi").test(String(value));
+        case "TEXT_ENDS_WITH":
+            return new RegExp(escapeCharacters(firstValue.userEnteredValue) + "$", "gi").test(String(value));
+        case "TEXT_NOT_CONTAINS":
+            return !new RegExp(escapeCharacters(firstValue.userEnteredValue), "gi").test(String(value));
+        case "NOT_BLANK":
+            return !(isNil(value) || value === "");
+        case "TEXT_NOT_EQ":
+            return !new RegExp(escapeCharacters(firstValue.userEnteredValue), "gi").test(String(value));
+        case "TEXT_STARTS_WITH":
+            return new RegExp("^" + escapeCharacters(firstValue.userEnteredValue), "gi").test(String(value));
+        case "ONE_OF_RANGE":
+        case "ONE_OF_LIST": {
+            if (allowBlank && !value) {
+                return true;
+            }
+            var userEnteredValue = (_d = valuesArray[0]) === null || _d === void 0 ? void 0 : _d.userEnteredValue;
+            var isAddress = type === "ONE_OF_RANGE"
+                ? true
+                : checkIfStringIsReference(userEnteredValue);
+            var finalValues = isAddress
+                ? getRangeValues === null || getRangeValues === void 0 ? void 0 : getRangeValues(userEnteredValue)
+                : splitDataValidationListValues(userEnteredValue);
+            // A cell storing the lone text-prefix apostrophe (`'`) is Excel's
+            // "empty text" — it satisfies the list exactly like a blank cell does,
+            // and both match the list's empty entry (a stripped bare `'`).
+            var candidate_1 = value === "'" || isNil(value) ? "" : String(value);
+            return finalValues === null || finalValues === void 0 ? void 0 : finalValues.some(function (entry) {
+                return new RegExp("^" + escapeCharacters(entry.userEnteredValue) + "$", "gi").test(candidate_1);
+            });
+        }
+        case "TEXT_IS_EMAIL":
+            return new RegExp(EMAIL_REGEX, "gi").test(String(value));
+        case "TEXT_IS_URL":
+            return new RegExp(URL_REGEX, "gi").test(String(value));
+        case "DATE_EQ":
+            return (value ===
+                toSerial(validationValueToDate(firstValue.userEnteredValue)));
+        case "DATE_AFTER":
+            return (Number(value) > toSerial(validationValueToDate(firstValue.userEnteredValue)));
+        case "DATE_BEFORE":
+            return (Number(value) < toSerial(validationValueToDate(firstValue.userEnteredValue)));
+        case "DATE_IS_VALID": {
+            var dateValue = toDate(Number(value));
+            return dateValue instanceof Date && !isNaN(dateValue.getTime());
+        }
+        case "DATE_TODAY":
+        case "DATE_YESTERDAY":
+        case "DATE_TOMORROW":
+        case "DATE_LAST_7_DAYS":
+        case "DATE_LAST_WEEK":
+        case "DATE_THIS_WEEK":
+        case "DATE_NEXT_WEEK":
+        case "DATE_LAST_MONTH":
+        case "DATE_THIS_MONTH":
+        case "DATE_NEXT_MONTH": {
+            var dateValue = toComparableDate(value);
+            if (!dateValue)
+                return false;
+            var range = getTimePeriodRange(type);
+            if (!range)
+                return false;
+            var normalized = normalizeDate(dateValue);
+            return normalized >= range.start && normalized <= range.end;
+        }
+        case "ERROR":
+            return isErrorValue(value);
+        case "NOT_ERROR":
+            return !isErrorValue(value);
+        case "DATE_NOT_EQ":
+            return (value !==
+                toSerial(validationValueToDate(firstValue.userEnteredValue)));
+        case "DATE_ON_OR_AFTER":
+            return (Number(value) >=
+                toSerial(validationValueToDate(firstValue.userEnteredValue)));
+        case "DATE_ON_OR_BEFORE":
+            return (Number(value) <=
+                toSerial(validationValueToDate(firstValue.userEnteredValue)));
+        case "DATE_BETWEEN":
+            return (Number(value) >=
+                toSerial(validationValueToDate(firstValue.userEnteredValue)) &&
+                Number(value) <=
+                    toSerial(validationValueToDate((_e = valuesArray[1]) === null || _e === void 0 ? void 0 : _e.userEnteredValue)));
+        case "DATE_NOT_BETWEEN":
+            return !(Number(value) >=
+                toSerial(validationValueToDate(firstValue.userEnteredValue)) &&
+                Number(value) <=
+                    toSerial(validationValueToDate((_f = valuesArray[1]) === null || _f === void 0 ? void 0 : _f.userEnteredValue)));
+        default:
+            return true;
+    }
+};

package/dist/cjs/api/xlsx-source.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Helpers for managing the `xlsxSource` field on round-trippable rules
+ * (ConditionalFormatRule, DataValidationRule, DataValidationRuleRecord).
+ *
+ * The xlsx exporter prefers `xlsxSource` over the high-level `condition` /
+ * `booleanRule` representation when emitting a rule, which preserves the
+ * verbatim source-xlsx attributes (cfRule type, operator, formula text,
+ * `text`/`timePeriod`/`rank`/etc.). That fidelity is correct for rules that
+ * round-trip untouched, but stale once the user edits the rule — the exporter
+ * would otherwise emit the pre-edit attributes and the user's change would
+ * disappear from the saved file.
+ *
+ * Every mutation path that updates a rule's condition, formula, format, or
+ * range must call `dropXlsxSource` on the rule before storing it. The export
+ * then falls through to the synthesizer for that rule, which reads the
+ * current `condition`/`booleanRule`/etc. and emits a faithful (if more
+ * canonicalized) representation of the user's intent.
+ *
+ * Untouched rules keep their `xlsxSource` and round-trip with full fidelity.
+ */
+export declare const dropXlsxSource: <T>(rule: T) => T;
+//# sourceMappingURL=xlsx-source.d.ts.map