@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/api/table.js

@@ -0,0 +1,333 @@
+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";
+const isTableColumnToken = (token) => token.tokenType.name === tokenVocabulary.TableColumnName.name;
+const isTableNameToken = (token) => token.tokenType.name === tokenVocabulary.TableName.name;
+/**
+ * Get table column index
+ * @param sheetId
+ * @param cell
+ * @param tables
+ */
+export const findTableColumnIndex = (sheetId, cell, tables) => {
+    const { rowIndex, columnIndex } = cell;
+    if (tables) {
+        for (const table of tables) {
+            // Header row
+            if (table.sheetId === sheetId &&
+                table.range.startRowIndex === rowIndex &&
+                columnIndex >= table.range.startColumnIndex &&
+                columnIndex <= table.range.endColumnIndex) {
+                return columnIndex - table.range.startColumnIndex;
+            }
+        }
+    }
+    return undefined;
+};
+export const findActiveTableWithinCell = (sheetId, cell, tables) => {
+    return tables?.find((table) => table.sheetId === sheetId && isCellWithinBounds(cell, table.range));
+};
+/**
+ * Find table adjacent to a cell
+ * @param sheetId
+ * @param cell
+ * @param tables
+ * @returns
+ */
+export const findAdjacentTable = (sheetId, cell, tables, getUserEnteredValue) => {
+    const adjacentTable = tables?.find((table) => {
+        const rowExpansion = table.range.endRowIndex + 1 === cell.rowIndex && !table.totalRow;
+        const columnExpansion = table.range.endColumnIndex + 1 === cell.columnIndex;
+        const isAdjacent = table.sheetId === sheetId &&
+            (rowExpansion || columnExpansion) &&
+            isCellWithinBounds(cell, {
+                ...table.range,
+                endRowIndex: table.range.endRowIndex + 1,
+                endColumnIndex: table.range.endColumnIndex + 1,
+            });
+        if (!isAdjacent) {
+            return false;
+        }
+        const lookupRange = {
+            ...table.range,
+            ...(rowExpansion
+                ? {
+                    startRowIndex: cell.rowIndex,
+                    endRowIndex: cell.rowIndex,
+                }
+                : {
+                    startColumnIndex: cell.columnIndex,
+                    endColumnIndex: cell.columnIndex,
+                }),
+        };
+        return (isAdjacent &&
+            [...iterateCellsInRange(lookupRange)].every(([rowIndex, columnIndex]) => {
+                return isNil(getUserEnteredValue(sheetId, rowIndex, columnIndex));
+            }));
+    });
+    const totalRowOffset = adjacentTable?.totalRow ? 1 : 0;
+    const isRowExpansion = adjacentTable
+        ? adjacentTable.range.endRowIndex + 1 - totalRowOffset === cell.rowIndex
+        : false;
+    const 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 const findAdjacentBandedRange = (sheetId, cell, bandedRanges, getUserEnteredValue) => {
+    const adjacentTable = bandedRanges?.find((bandedRange) => {
+        const rowExpansion = bandedRange.range.endRowIndex + 1 === cell.rowIndex;
+        const columnExpansion = bandedRange.range.endColumnIndex + 1 === cell.columnIndex;
+        const isAdjacent = (rowExpansion || columnExpansion) &&
+            isCellWithinBounds(cell, {
+                ...bandedRange.range,
+                endRowIndex: bandedRange.range.endRowIndex + 1,
+                endColumnIndex: bandedRange.range.endColumnIndex + 1,
+            });
+        if (!isAdjacent) {
+            return false;
+        }
+        const lookupRange = {
+            ...bandedRange.range,
+            ...(rowExpansion
+                ? {
+                    startRowIndex: cell.rowIndex,
+                    endRowIndex: cell.rowIndex,
+                }
+                : {
+                    startColumnIndex: cell.columnIndex,
+                    endColumnIndex: cell.columnIndex,
+                }),
+        };
+        return (isAdjacent &&
+            [...iterateCellsInRange(lookupRange)].every(([rowIndex, columnIndex]) => {
+                return isNil(getUserEnteredValue(sheetId, rowIndex, columnIndex));
+            }));
+    });
+    const isRowExpansion = adjacentTable
+        ? adjacentTable.range.endRowIndex + 1 === cell.rowIndex
+        : false;
+    const isColumnExpansion = adjacentTable
+        ? adjacentTable.range.endColumnIndex + 1 === cell.columnIndex
+        : false;
+    return [adjacentTable, isRowExpansion, isColumnExpansion];
+};
+// Check if table cells are fillable
+export const isTableColumnCellsFillable = (sheetId, range, excludeCell, existingColumnFormula, currentValue, activeSheetName, getUserEnteredValue) => {
+    const normalizedExistingFormula = normalizeFormulaString(existingColumnFormula);
+    const normalizedCurrentFormula = isAFormula(currentValue)
+        ? normalizeFormulaString(currentValue)
+        : undefined;
+    const templateFormula = normalizedExistingFormula ?? normalizedCurrentFormula;
+    if (!templateFormula) {
+        return false;
+    }
+    const normalizedTemplate = SheetCell.getRelativeFormula(templateFormula, excludeCell, excludeCell, activeSheetName) ?? templateFormula;
+    const templateHasReferences = formulaHasCellReferences(templateFormula);
+    const isAnchorCell = excludeCell.rowIndex === range.startRowIndex &&
+        excludeCell.columnIndex === range.startColumnIndex;
+    const normalizedCurrentLiteral = normalizeFormulaString(typeof currentValue === "string" ? currentValue : undefined);
+    if (normalizedExistingFormula && !templateHasReferences) {
+        return false;
+    }
+    return [...iterateCellsInRange(range)].every(([rowIndex, columnIndex]) => {
+        if (rowIndex === excludeCell.rowIndex &&
+            columnIndex === excludeCell.columnIndex) {
+            return true;
+        }
+        const userEnteredValue = getUserEnteredValue(sheetId, rowIndex, columnIndex);
+        if (isNil(userEnteredValue) || userEnteredValue === "") {
+            return true;
+        }
+        if (!isAFormula(userEnteredValue)) {
+            return false;
+        }
+        const relativeFormula = SheetCell.getRelativeFormula(userEnteredValue, { rowIndex, columnIndex }, excludeCell, activeSheetName);
+        const comparable = relativeFormula ?? userEnteredValue;
+        return normalizedTemplate === comparable;
+    });
+};
+const formulaHasCellReferences = (formula) => {
+    if (!formula || typeof formula !== "string" || !formula.startsWith("=")) {
+        return false;
+    }
+    const { tokens } = lexify(formula);
+    return tokens.some((token) => CELL_REFERENCE_TOKEN_NAMES.has(token.tokenType.name));
+};
+const CELL_REFERENCE_TOKEN_NAMES = new Set([
+    tokenVocabulary.Cell?.name,
+    tokenVocabulary.Column?.name,
+    tokenVocabulary.TableColumnName?.name,
+].filter((tokenName) => Boolean(tokenName)));
+const normalizeFormulaString = (value) => {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return trimmed.startsWith("=") ? trimmed : `=${trimmed}`;
+};
+// Add table name to formula
+export const addTableNameToTokens = (tokens, title) => {
+    const newTokens = [];
+    let offset = 0;
+    const len = title.length;
+    for (let i = 0; i < tokens.length; i++) {
+        const 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
+ */
+const replaceTable = (formula) => {
+    const bracketIndex = formula.indexOf("[");
+    if (bracketIndex === -1) {
+        return formula;
+    }
+    return formula.slice(bracketIndex);
+};
+export const removeTableName = (tokens, title) => {
+    // // Use regular expression to match the pattern and extract the column name
+    const newTokens = [];
+    let offset = 0;
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token.structured &&
+            isTableNameToken(token) &&
+            token.tableName === title) {
+            const len = token?.tableName?.length ?? 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 const shiftTableMovingRows = (table, dims, referenceIndex) => {
+    const { 0: firstDim, [dims.length - 1]: lastDim } = dims;
+    /**
+     * 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
+     */
+    const count = dims.length;
+    // Scenario 1
+    if (firstDim <= table.range.startRowIndex &&
+        lastDim >= table.range.endRowIndex) {
+        // User is moving the entire table
+        const delta = referenceIndex - firstDim;
+        table.range = moveRange(table.range, table.range, {
+            ...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 const shiftTableMovingColumns = (table, dims, referenceIndex) => {
+    const { 0: firstDim, [dims.length - 1]: lastDim } = dims;
+    /**
+     * 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
+     */
+    const count = dims.length;
+    // Scenario 1
+    if (firstDim <= table.range.startColumnIndex &&
+        lastDim >= table.range.endColumnIndex) {
+        // User is moving the entire table
+        const delta = referenceIndex - firstDim;
+        table.range = moveRange(table.range, table.range, {
+            ...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/esm/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/esm/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/esm/api/validation.js

@@ -0,0 +1,297 @@
+import { checkIfStringIsReference, escapeCharacters, isNil, stripDataValidationTextPrefix, toDate, toSerial, } from "@rowsncolumns/utils";
+import { convertToNumber } from "./datatype";
+const 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])+)\])/;
+const URL_REGEX = /^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$/;
+const splitDataValidationListValues = (listString) => {
+    if (isNil(listString)) {
+        return [];
+    }
+    const trimmedString = listString.replace(/^"(.*)"$/, "$1");
+    return trimmedString
+        .split(",")
+        .map((value) => value.trim())
+        // A leading apostrophe is Excel's text prefix (`'000s` is the text
+        // "000s"), never part of the value.
+        .map(stripDataValidationTextPrefix)
+        .map((userEnteredValue) => ({
+        userEnteredValue,
+    }));
+};
+export const validationValueToDate = (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 const checkBooleanRule = (rule, value, previousValue, getRangeValues, options) => {
+    void previousValue;
+    const { locale } = options ?? {};
+    const parseNumber = (val) => {
+        if (val === null || (typeof val === "object" && !(val instanceof Date))) {
+            return NaN;
+        }
+        return convertToNumber(val, locale);
+    };
+    const isErrorValue = (entry) => Boolean(entry &&
+        typeof entry === "object" &&
+        "type" in entry &&
+        "message" in entry);
+    const normalizeDate = (date) => new Date(date.getFullYear(), date.getMonth(), date.getDate());
+    const toComparableDate = (entry) => {
+        if (entry instanceof Date) {
+            return entry;
+        }
+        if (typeof entry === "number" && Number.isFinite(entry)) {
+            return toDate(entry);
+        }
+        if (typeof entry === "string") {
+            const trimmed = entry.trim();
+            if (!trimmed)
+                return undefined;
+            const asNumber = Number(trimmed);
+            if (Number.isFinite(asNumber)) {
+                return toDate(asNumber);
+            }
+            const parsed = new Date(trimmed);
+            if (!isNaN(parsed.getTime())) {
+                return parsed;
+            }
+        }
+        return undefined;
+    };
+    const getWeekStart = (date) => {
+        const day = date.getDay();
+        const diff = day === 0 ? -6 : 1 - day;
+        return new Date(date.getFullYear(), date.getMonth(), date.getDate() + diff);
+    };
+    const getTimePeriodRange = (type) => {
+        const today = normalizeDate(new Date());
+        const startOfDay = (date) => normalizeDate(date);
+        const endOfDay = (date) => 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": {
+                const target = new Date(today);
+                target.setDate(target.getDate() - 1);
+                return { start: startOfDay(target), end: endOfDay(target) };
+            }
+            case "DATE_TOMORROW": {
+                const target = new Date(today);
+                target.setDate(target.getDate() + 1);
+                return { start: startOfDay(target), end: endOfDay(target) };
+            }
+            case "DATE_LAST_7_DAYS": {
+                const start = new Date(today);
+                start.setDate(start.getDate() - 6);
+                return { start: startOfDay(start), end: endOfDay(today) };
+            }
+            case "DATE_THIS_WEEK": {
+                const start = getWeekStart(today);
+                const end = new Date(start);
+                end.setDate(end.getDate() + 6);
+                return { start: startOfDay(start), end: endOfDay(end) };
+            }
+            case "DATE_LAST_WEEK": {
+                const thisWeekStart = getWeekStart(today);
+                const start = new Date(thisWeekStart);
+                start.setDate(start.getDate() - 7);
+                const end = new Date(thisWeekStart);
+                end.setDate(end.getDate() - 1);
+                return { start: startOfDay(start), end: endOfDay(end) };
+            }
+            case "DATE_NEXT_WEEK": {
+                const thisWeekStart = getWeekStart(today);
+                const start = new Date(thisWeekStart);
+                start.setDate(start.getDate() + 7);
+                const end = new Date(thisWeekStart);
+                end.setDate(end.getDate() + 13);
+                return { start: startOfDay(start), end: endOfDay(end) };
+            }
+            case "DATE_THIS_MONTH": {
+                const start = new Date(today.getFullYear(), today.getMonth(), 1);
+                const end = new Date(today.getFullYear(), today.getMonth() + 1, 0);
+                return { start: startOfDay(start), end: endOfDay(end) };
+            }
+            case "DATE_LAST_MONTH": {
+                const start = new Date(today.getFullYear(), today.getMonth() - 1, 1);
+                const end = new Date(today.getFullYear(), today.getMonth(), 0);
+                return { start: startOfDay(start), end: endOfDay(end) };
+            }
+            case "DATE_NEXT_MONTH": {
+                const start = new Date(today.getFullYear(), today.getMonth() + 1, 1);
+                const end = new Date(today.getFullYear(), today.getMonth() + 2, 0);
+                return { start: startOfDay(start), end: endOfDay(end) };
+            }
+            default:
+                return undefined;
+        }
+    };
+    const condition = rule?.condition;
+    if (!condition || !condition.type) {
+        return true;
+    }
+    const allowBlank = rule?.allowBlank;
+    if (allowBlank && (value === "" || isNil(value))) {
+        return true;
+    }
+    const { type, values } = condition;
+    const valuesArray = values ?? [];
+    const firstValue = valuesArray[0] ?? { 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": {
+            const num = parseNumber(value);
+            const bound1 = parseNumber(firstValue.userEnteredValue);
+            const bound2 = parseNumber(valuesArray[1]?.userEnteredValue);
+            const min = Math.min(bound1, bound2);
+            const max = Math.max(bound1, bound2);
+            return num >= min && num <= max;
+        }
+        case "NUMBER_NOT_BETWEEN": {
+            const num = parseNumber(value);
+            const bound1 = parseNumber(firstValue.userEnteredValue);
+            const bound2 = parseNumber(valuesArray[1]?.userEnteredValue);
+            const min = Math.min(bound1, bound2);
+            const 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;
+            }
+            const userEnteredValue = valuesArray[0]?.userEnteredValue;
+            const isAddress = type === "ONE_OF_RANGE"
+                ? true
+                : checkIfStringIsReference(userEnteredValue);
+            const finalValues = isAddress
+                ? 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 `'`).
+            const candidate = value === "'" || isNil(value) ? "" : String(value);
+            return finalValues?.some((entry) => new RegExp("^" + escapeCharacters(entry.userEnteredValue) + "$", "gi").test(candidate));
+        }
+        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": {
+            const 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": {
+            const dateValue = toComparableDate(value);
+            if (!dateValue)
+                return false;
+            const range = getTimePeriodRange(type);
+            if (!range)
+                return false;
+            const 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(valuesArray[1]?.userEnteredValue)));
+        case "DATE_NOT_BETWEEN":
+            return !(Number(value) >=
+                toSerial(validationValueToDate(firstValue.userEnteredValue)) &&
+                Number(value) <=
+                    toSerial(validationValueToDate(valuesArray[1]?.userEnteredValue)));
+        default:
+            return true;
+    }
+};

package/dist/esm/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

package/dist/esm/api/xlsx-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xlsx-source.d.ts","sourceRoot":"","sources":["../../../api/xlsx-source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,MAAM,CAAC,KAAG,CAQ3C,CAAC"}