@rowsncolumns/spreadsheet 10.2.68

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

@@ -0,0 +1,11 @@
+import type { CellInterface } from "@rowsncolumns/grid";
+import type { TableView } from "../types";
+/**
+ * Find table withing a cell
+ * @param sheetId
+ * @param cell
+ * @param tables
+ * @returns
+ */
+export declare const findActiveTableWithinCell: (sheetId: number, cell: CellInterface, tables: TableView[] | undefined | null) => TableView | undefined;
+//# sourceMappingURL=table.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../api/table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,GACpC,SAAS,MAAM,EACf,MAAM,aAAa,EACnB,QAAQ,SAAS,EAAE,GAAG,SAAS,GAAG,IAAI,0BAMvC,CAAC"}

package/dist/cjs/api/table.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findActiveTableWithinCell = void 0;
+var grid_1 = require("@rowsncolumns/grid");
+/**
+ * Find table withing a cell
+ * @param sheetId
+ * @param cell
+ * @param tables
+ * @returns
+ */
+var findActiveTableWithinCell = function (sheetId, cell, tables) {
+    return tables === null || tables === void 0 ? void 0 : tables.find(function (table) {
+        return table.sheetId === sheetId && (0, grid_1.isCellWithinBounds)(cell, table.range);
+    });
+};
+exports.findActiveTableWithinCell = findActiveTableWithinCell;

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

@@ -0,0 +1,98 @@
+import type { CellInterface, GridRange } from "@rowsncolumns/grid";
+import type { CellData, ConditionType, ConditionValue, CustomFormulaResult, DataValidationRule, DataValidationRuleAlert, FilterCriteria, Maybe, ProtectedRange, SheetProtection, TimePeriodTypes } from "../types";
+export type CheckBooleanRuleOptions = {
+    locale?: string;
+};
+/**
+ * Conditional Validation
+ * @param condition
+ * @param value
+ * @returns
+ */
+export declare const checkBooleanRule: <T extends CellData>(rule?: DataValidationRule | undefined, value?: CustomFormulaResult, previousValue?: CustomFormulaResult, getRangeValues?: (address: string) => ConditionValue[], options?: CheckBooleanRuleOptions) => boolean | undefined;
+export declare const checkFilterRule: (filterCriteria: FilterCriteria, value?: CustomFormulaResult) => boolean | undefined;
+export declare const validationValueToDate: (value: string | TimePeriodTypes) => Date;
+/**
+ * A small helper function for list validation
+ * @param type
+ * @returns
+ */
+export declare const showValidationDropdownArrow: (rule?: DataValidationRule | null | undefined) => boolean;
+/**
+ * Check if a cell is within a protected range
+ * @param cell
+ * @param protectedRanges
+ * @returns
+ */
+export declare const isProtectedCell: (sheetId: number, cell: CellInterface, protectedRanges: ProtectedRange[]) => boolean;
+/**
+ * Check if the entire sheet is protected
+ * @param sheetId
+ * @param protectedRanges
+ * @returns
+ */
+export declare const isProtectedSheet: (sheetId: number, protectedRanges?: ProtectedRange[]) => boolean;
+/**
+ * Structural operations that worksheet protection (`<sheetProtection>`) can
+ * prohibit. Every member except `mergeCells` maps 1:1 to the OOXML flag of
+ * the same name; `mergeCells` has no allow flag in Excel — merging/unmerging
+ * is always refused while the sheet is protected.
+ */
+export type SheetProtectionAction = "formatCells" | "formatColumns" | "formatRows" | "insertColumns" | "insertRows" | "insertHyperlinks" | "deleteColumns" | "deleteRows" | "sort" | "autoFilter" | "pivotTables" | "mergeCells";
+/**
+ * Whether worksheet protection is turned on at all (`<sheetProtection
+ * sheet="1">`). All other flags are inert until this master switch is set.
+ */
+export declare const isSheetProtectionActive: (sheetProtection?: Maybe<SheetProtection>) => boolean;
+/**
+ * Whether an active worksheet protection prohibits a structural action.
+ * `false` when protection is inactive. For an active protection, a flag set
+ * `true` prohibits, `false` allows, and an ABSENT flag falls back to the
+ * OOXML schema default — prohibited for every action here (the schema only
+ * defaults `selectLockedCells`/`selectUnlockedCells` to allowed, and those
+ * are not structural actions). `mergeCells` is always prohibited while the
+ * sheet is protected (Excel has no allow flag for it).
+ */
+export declare const isActionBlockedBySheetProtection: (sheetProtection: Maybe<SheetProtection> | undefined, action: SheetProtectionAction) => boolean;
+/**
+ * Whether a cell refuses edits under an active worksheet protection. Excel's
+ * per-cell default is LOCKED, so a cell is locked unless its
+ * `protection.locked` is explicitly `false`. Always `false` when the sheet's
+ * protection is inactive.
+ */
+export declare const isCellLockedUnderProtection: (sheetProtection: Maybe<SheetProtection> | undefined, cellProtection: Maybe<Pick<NonNullable<CellData["protection"]>, "locked">>) => boolean;
+/**
+ * Check if a range is protected
+ * @param sheetId
+ * @param range
+ * @param protectedRanges
+ * @returns
+ */
+export declare const isProtectedRange: (sheetId: number, range: GridRange, protectedRanges: ProtectedRange[] | undefined | null) => boolean | undefined;
+/**
+ * Get protect range
+ * @param sheetId
+ * @param range
+ * @param protectedRanges
+ * @returns
+ */
+export declare const getProtectedRange: (sheetId: number, range: GridRange, protectedRanges: ProtectedRange[] | undefined) => ProtectedRange | undefined;
+export declare const shouldUsePreviousValue: (_type: Maybe<ConditionType>) => boolean;
+/**
+ * How a freshly-entered cell value should be committed, given its data
+ * validation alert. Mirrors Excel's `errorStyle` semantics.
+ */
+export type ValidationCommitDecision = "proceed" | "block" | "confirm";
+/**
+ * Decide how to commit an entered value against a data validation alert:
+ * - valid value, or no alert configured -> "proceed" (write normally)
+ * - invalid + style "stop"               -> "block"   (reject, keep the cell)
+ * - invalid + "warning" / "information"  -> "confirm" (allow override)
+ *
+ * Excel only blocks on `stop`; `warning`/`information` let the user keep the
+ * value. When no alert is configured the cell is still flagged with the red
+ * "Invalid" marker (handled by `SheetCell.validate`), matching today's
+ * Google-Sheets-style behaviour.
+ */
+export declare const decideValidationCommit: (alert: Maybe<DataValidationRuleAlert>, isValid: boolean) => ValidationCommitDecision;
+//# 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":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AASnE,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EACb,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EAClB,uBAAuB,EAEvB,cAAc,EACd,KAAK,EACL,cAAc,EACd,eAAe,EACf,eAAe,EAChB,MAAM,UAAU,CAAC;AAElB,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AA6CF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,QAAQ,EACjD,OAAO,kBAAkB,GAAG,SAAS,EACrC,QAAQ,mBAAmB,EAC3B,gBAAgB,mBAAmB,EACnC,iBAAiB,CAAC,OAAO,EAAE,MAAM,KAAK,cAAc,EAAE,EACtD,UAAU,uBAAuB,wBAgVlC,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,gBAAgB,cAAc,EAC9B,QAAQ,mBAAmB,wBAM5B,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,OAAO,MAAM,GAAG,eAAe,SA+BpE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,GACtC,OAAO,kBAAkB,GAAG,IAAI,GAAG,SAAS,YAO7C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAC1B,SAAS,MAAM,EACf,MAAM,aAAa,EACnB,iBAAiB,cAAc,EAAE,YA2BlC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAC3B,SAAS,MAAM,EACf,kBAAkB,cAAc,EAAE,YAcnC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,GAC7B,aAAa,GACb,eAAe,GACf,YAAY,GACZ,eAAe,GACf,YAAY,GACZ,kBAAkB,GAClB,eAAe,GACf,YAAY,GACZ,MAAM,GACN,YAAY,GACZ,aAAa,GACb,YAAY,CAAC;AAEjB;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAClC,kBAAkB,KAAK,CAAC,eAAe,CAAC,KACvC,OAA0C,CAAC;AAE9C;;;;;;;;GAQG;AACH,eAAO,MAAM,gCAAgC,GAC3C,iBAAiB,KAAK,CAAC,eAAe,CAAC,GAAG,SAAS,EACnD,QAAQ,qBAAqB,KAC5B,OAQF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,GACtC,iBAAiB,KAAK,CAAC,eAAe,CAAC,GAAG,SAAS,EACnD,gBAAgB,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,KACzE,OAC2E,CAAC;AAE/E;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAC3B,SAAS,MAAM,EACf,OAAO,SAAS,EAChB,iBAAiB,cAAc,EAAE,GAAG,SAAS,GAAG,IAAI,wBAWrD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAC5B,SAAS,MAAM,EACf,OAAO,SAAS,EAChB,iBAAiB,cAAc,EAAE,GAAG,SAAS,+BAW9C,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,OAAO,KAAK,CAAC,aAAa,CAAC,YAGjE,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;AAEvE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,GACjC,OAAO,KAAK,CAAC,uBAAuB,CAAC,EACrC,SAAS,OAAO,KACf,wBAKF,CAAC"}

package/dist/cjs/api/validation.js

@@ -0,0 +1,506 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decideValidationCommit = exports.shouldUsePreviousValue = exports.getProtectedRange = exports.isProtectedRange = exports.isCellLockedUnderProtection = exports.isActionBlockedBySheetProtection = exports.isSheetProtectionActive = exports.isProtectedSheet = exports.isProtectedCell = exports.showValidationDropdownArrow = exports.validationValueToDate = exports.checkFilterRule = exports.checkBooleanRule = void 0;
+var grid_1 = require("@rowsncolumns/grid");
+var utils_1 = require("@rowsncolumns/utils");
+var config_1 = require("../config");
+var helpers_1 = require("../helpers");
+/**
+ * Parse a number value with locale awareness
+ * Handles common decimal separators like comma (e.g., "6,5" in German)
+ */
+var parseLocaleNumber = function (value, locale) {
+    var _a, _b;
+    if (typeof value === "number")
+        return value;
+    if (value === undefined || value === null || value === "")
+        return NaN;
+    if (typeof value === "boolean")
+        return value ? 1 : 0;
+    if (value instanceof Date)
+        return value.getTime();
+    if (typeof value === "object")
+        return NaN; // Error objects
+    var trimmed = String(value).trim();
+    if (!trimmed)
+        return NaN;
+    // Try standard Number parsing first
+    var standardParsed = Number(trimmed);
+    if (!isNaN(standardParsed))
+        return standardParsed;
+    // Handle locale-specific decimal separator (comma -> period)
+    // This handles cases like "6,5" in German locale
+    if (locale) {
+        try {
+            var parts = new Intl.NumberFormat(locale).formatToParts(1.1);
+            var decimalSep = (_b = (_a = parts.find(function (p) { return p.type === "decimal"; })) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : ".";
+            if (decimalSep !== ".") {
+                var normalized = trimmed.replace(new RegExp("\\".concat(decimalSep), "g"), ".");
+                var parsed = Number(normalized);
+                if (!isNaN(parsed))
+                    return parsed;
+            }
+        }
+        catch (_c) {
+            // Fallback if Intl fails
+        }
+    }
+    return NaN;
+};
+/**
+ * Conditional Validation
+ * @param condition
+ * @param value
+ * @returns
+ */
+var checkBooleanRule = function (rule, value, previousValue, getRangeValues, options) {
+    var _a, _b, _c;
+    var locale = (options !== null && options !== void 0 ? options : {}).locale;
+    var parseNumber = function (val) {
+        return parseLocaleNumber(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 (0, utils_1.toDate)(entry);
+        }
+        if (typeof entry === "string") {
+            var trimmed = entry.trim();
+            if (!trimmed)
+                return undefined;
+            var asNumber = Number(trimmed);
+            if (Number.isFinite(asNumber)) {
+                return (0, utils_1.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;
+    // Exit early
+    if (!condition || !condition.type) {
+        // Set as valid
+        return true;
+    }
+    // Exit early
+    var allowBlank = rule === null || rule === void 0 ? void 0 : rule.allowBlank;
+    if (allowBlank && (value === "" || (0, utils_1.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("^" + (0, utils_1.escapeCharacters)(firstValue.userEnteredValue) + "$", "gi").test(String(value));
+        case "BLANK":
+            return value === "" || (0, utils_1.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 === "" || (0, utils_1.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":
+            // Deprecated: previous-value conditions aren't supported in Excel exports.
+            return false;
+        case "NUMBER_NOT_EQ":
+            return parseNumber(value) !== parseNumber(firstValue.userEnteredValue);
+        case "TEXT_CONTAINS":
+            return new RegExp((0, utils_1.escapeCharacters)(firstValue.userEnteredValue), "gi").test(String(value));
+        case "TEXT_ENDS_WITH":
+            return new RegExp((0, utils_1.escapeCharacters)(firstValue.userEnteredValue) + "$", "gi").test(String(value));
+        case "TEXT_NOT_CONTAINS":
+            return !new RegExp((0, utils_1.escapeCharacters)(firstValue.userEnteredValue), "gi").test(String(value));
+        case "NOT_BLANK":
+            return !((0, utils_1.isNil)(value) || value === "");
+        case "TEXT_NOT_EQ":
+            return !new RegExp((0, utils_1.escapeCharacters)(firstValue.userEnteredValue), "gi").test(String(value));
+        case "TEXT_STARTS_WITH":
+            return new RegExp("^" + (0, utils_1.escapeCharacters)(firstValue.userEnteredValue), "gi").test(String(value));
+        case "ONE_OF_RANGE":
+        case "ONE_OF_LIST": {
+            // Validate allowBlank
+            if (allowBlank && !value) {
+                return true;
+            }
+            var firstValue_1 = valuesArray[0].userEnteredValue;
+            var isAddress = type === "ONE_OF_RANGE" ? true : (0, helpers_1.checkIfStringIsReference)(firstValue_1);
+            var finalValues = isAddress
+                ? getRangeValues === null || getRangeValues === void 0 ? void 0 : getRangeValues(firstValue_1)
+                : (0, helpers_1.splitDataValidationListValues)(firstValue_1);
+            // 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 === "'" || (0, utils_1.isNil)(value) ? "" : String(value);
+            return finalValues === null || finalValues === void 0 ? void 0 : finalValues.some(function (_a) {
+                var userEnteredValue = _a.userEnteredValue;
+                return new RegExp("^" + (0, utils_1.escapeCharacters)(userEnteredValue) + "$", "gi").test(candidate_1);
+            });
+        }
+        case "TEXT_IS_EMAIL":
+            return new RegExp(config_1.EMAIL_REGEX, "gi").test(String(value));
+        case "TEXT_IS_URL":
+            return new RegExp(config_1.URL_REGEX, "gi").test(String(value));
+        case "DATE_EQ":
+            return (value === (0, utils_1.toSerial)((0, exports.validationValueToDate)(firstValue.userEnteredValue)));
+        case "DATE_AFTER":
+            return (value >
+                (0, utils_1.toSerial)((0, exports.validationValueToDate)(firstValue.userEnteredValue)));
+        case "DATE_BEFORE":
+            return (value <
+                (0, utils_1.toSerial)((0, exports.validationValueToDate)(firstValue.userEnteredValue)));
+        case "DATE_IS_VALID": {
+            var dateValue = (0, utils_1.toDate)(value);
+            return dateValue instanceof Date && !isNaN(dateValue === null || dateValue === void 0 ? void 0 : 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 !== (0, utils_1.toSerial)((0, exports.validationValueToDate)(firstValue.userEnteredValue)));
+        case "DATE_ON_OR_AFTER":
+            return (value >=
+                (0, utils_1.toSerial)((0, exports.validationValueToDate)(firstValue.userEnteredValue)));
+        case "DATE_ON_OR_BEFORE":
+            return (value <=
+                (0, utils_1.toSerial)((0, exports.validationValueToDate)(firstValue.userEnteredValue)));
+        case "DATE_BETWEEN":
+            return (value >=
+                (0, utils_1.toSerial)((0, exports.validationValueToDate)(firstValue.userEnteredValue)) &&
+                value <=
+                    (0, utils_1.toSerial)((0, exports.validationValueToDate)(valuesArray[1].userEnteredValue)));
+        case "DATE_NOT_BETWEEN":
+            return !(value >=
+                (0, utils_1.toSerial)((0, exports.validationValueToDate)(firstValue.userEnteredValue)) &&
+                value <=
+                    (0, utils_1.toSerial)((0, exports.validationValueToDate)(valuesArray[1].userEnteredValue)));
+        default:
+            return true;
+    }
+};
+exports.checkBooleanRule = checkBooleanRule;
+var checkFilterRule = function (filterCriteria, value) {
+    if (filterCriteria.condition) {
+        return (0, exports.checkBooleanRule)({ condition: filterCriteria.condition }, value);
+    }
+    return false;
+};
+exports.checkFilterRule = checkFilterRule;
+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);
+    }
+};
+exports.validationValueToDate = validationValueToDate;
+/**
+ * A small helper function for list validation
+ * @param type
+ * @returns
+ */
+var showValidationDropdownArrow = function (rule) {
+    var _a, _b, _c;
+    var isList = ((_a = rule === null || rule === void 0 ? void 0 : rule.condition) === null || _a === void 0 ? void 0 : _a.type) === "ONE_OF_LIST" ||
+        ((_b = rule === null || rule === void 0 ? void 0 : rule.condition) === null || _b === void 0 ? void 0 : _b.type) === "ONE_OF_RANGE";
+    var displayStyle = (_c = rule === null || rule === void 0 ? void 0 : rule.displayStyle) !== null && _c !== void 0 ? _c : "arrow";
+    return isList && displayStyle === "arrow";
+};
+exports.showValidationDropdownArrow = showValidationDropdownArrow;
+/**
+ * Check if a cell is within a protected range
+ * @param cell
+ * @param protectedRanges
+ * @returns
+ */
+var isProtectedCell = function (sheetId, cell, protectedRanges) {
+    return protectedRanges.some(function (_a) {
+        var range = _a.range, unprotectedRanges = _a.unprotectedRanges;
+        var rangeExists = range.startRowIndex &&
+            range.endRowIndex &&
+            range.startColumnIndex &&
+            range.endColumnIndex;
+        // For sheet protection, we have to look in unprotected ranges
+        var isSheetProtectionEnabled = !rangeExists && range.sheetId;
+        // Entire sheet is protected, so look in unprotected ranges exclusion
+        if (isSheetProtectionEnabled) {
+            return unprotectedRanges
+                ? !(unprotectedRanges === null || unprotectedRanges === void 0 ? void 0 : unprotectedRanges.some(function (range) {
+                    return (0, grid_1.isCellWithinBounds)(cell, range) && range.sheetId === sheetId;
+                }))
+                : range.sheetId === sheetId;
+        }
+        else {
+            return (range.sheetId === sheetId &&
+                (0, grid_1.isCellWithinBounds)(cell, range));
+        }
+    });
+};
+exports.isProtectedCell = isProtectedCell;
+/**
+ * Check if the entire sheet is protected
+ * @param sheetId
+ * @param protectedRanges
+ * @returns
+ */
+var isProtectedSheet = function (sheetId, protectedRanges) {
+    if (!protectedRanges) {
+        return false;
+    }
+    return protectedRanges.some(function (_a) {
+        var range = _a.range;
+        var rangeExists = range.startRowIndex &&
+            range.endRowIndex &&
+            range.startColumnIndex &&
+            range.endColumnIndex;
+        return range.sheetId === sheetId && !rangeExists;
+    });
+};
+exports.isProtectedSheet = isProtectedSheet;
+/**
+ * Whether worksheet protection is turned on at all (`<sheetProtection
+ * sheet="1">`). All other flags are inert until this master switch is set.
+ */
+var isSheetProtectionActive = function (sheetProtection) { return (sheetProtection === null || sheetProtection === void 0 ? void 0 : sheetProtection.sheet) === true; };
+exports.isSheetProtectionActive = isSheetProtectionActive;
+/**
+ * Whether an active worksheet protection prohibits a structural action.
+ * `false` when protection is inactive. For an active protection, a flag set
+ * `true` prohibits, `false` allows, and an ABSENT flag falls back to the
+ * OOXML schema default — prohibited for every action here (the schema only
+ * defaults `selectLockedCells`/`selectUnlockedCells` to allowed, and those
+ * are not structural actions). `mergeCells` is always prohibited while the
+ * sheet is protected (Excel has no allow flag for it).
+ */
+var isActionBlockedBySheetProtection = function (sheetProtection, action) {
+    if (!(0, exports.isSheetProtectionActive)(sheetProtection)) {
+        return false;
+    }
+    if (action === "mergeCells") {
+        return true;
+    }
+    return (sheetProtection === null || sheetProtection === void 0 ? void 0 : sheetProtection[action]) !== false;
+};
+exports.isActionBlockedBySheetProtection = isActionBlockedBySheetProtection;
+/**
+ * Whether a cell refuses edits under an active worksheet protection. Excel's
+ * per-cell default is LOCKED, so a cell is locked unless its
+ * `protection.locked` is explicitly `false`. Always `false` when the sheet's
+ * protection is inactive.
+ */
+var isCellLockedUnderProtection = function (sheetProtection, cellProtection) {
+    return (0, exports.isSheetProtectionActive)(sheetProtection) && (cellProtection === null || cellProtection === void 0 ? void 0 : cellProtection.locked) !== false;
+};
+exports.isCellLockedUnderProtection = isCellLockedUnderProtection;
+/**
+ * Check if a range is protected
+ * @param sheetId
+ * @param range
+ * @param protectedRanges
+ * @returns
+ */
+var isProtectedRange = function (sheetId, range, protectedRanges) {
+    return protectedRanges === null || protectedRanges === void 0 ? void 0 : protectedRanges.some(function (protectedRange) {
+        return (protectedRange.range.sheetId === sheetId &&
+            protectedRange.range.startRowIndex === range.startRowIndex &&
+            protectedRange.range.startColumnIndex === range.startColumnIndex &&
+            protectedRange.range.endRowIndex === range.endRowIndex &&
+            protectedRange.range.endColumnIndex === range.endColumnIndex);
+    });
+};
+exports.isProtectedRange = isProtectedRange;
+/**
+ * Get protect range
+ * @param sheetId
+ * @param range
+ * @param protectedRanges
+ * @returns
+ */
+var getProtectedRange = function (sheetId, range, protectedRanges) {
+    return protectedRanges === null || protectedRanges === void 0 ? void 0 : protectedRanges.find(function (protectedRange) {
+        return (protectedRange.range.sheetId === sheetId &&
+            protectedRange.range.startRowIndex === range.startRowIndex &&
+            protectedRange.range.startColumnIndex === range.startColumnIndex &&
+            protectedRange.range.endRowIndex === range.endRowIndex &&
+            protectedRange.range.endColumnIndex === range.endColumnIndex);
+    });
+};
+exports.getProtectedRange = getProtectedRange;
+var shouldUsePreviousValue = function (_type) {
+    // Deprecated: previous-value conditions aren't supported in Excel exports.
+    return false;
+};
+exports.shouldUsePreviousValue = shouldUsePreviousValue;
+/**
+ * Decide how to commit an entered value against a data validation alert:
+ * - valid value, or no alert configured -> "proceed" (write normally)
+ * - invalid + style "stop"               -> "block"   (reject, keep the cell)
+ * - invalid + "warning" / "information"  -> "confirm" (allow override)
+ *
+ * Excel only blocks on `stop`; `warning`/`information` let the user keep the
+ * value. When no alert is configured the cell is still flagged with the red
+ * "Invalid" marker (handled by `SheetCell.validate`), matching today's
+ * Google-Sheets-style behaviour.
+ */
+var decideValidationCommit = function (alert, isValid) {
+    if (isValid || !alert) {
+        return "proceed";
+    }
+    return alert.style === "stop" ? "block" : "confirm";
+};
+exports.decideValidationCommit = decideValidationCommit;

package/dist/cjs/atoms/active-editor.atom.d.ts

@@ -0,0 +1,8 @@
+import type { TextEditorRef } from "@rowsncolumns/ui";
+export declare const activeEditorAtom: import("jotai").PrimitiveAtom<TextEditorRef | undefined> & {
+    init: TextEditorRef | undefined;
+};
+export declare const useActiveEditor: () => TextEditorRef | undefined;
+export declare const useSetActiveEditor: () => (args_0: TextEditorRef | ((prev: TextEditorRef | undefined) => TextEditorRef | undefined) | undefined) => void;
+export declare const useEditorVisibility: () => [boolean, (args_0: boolean | ((prev: boolean) => boolean)) => void];
+//# sourceMappingURL=active-editor.atom.d.ts.map

package/dist/cjs/atoms/active-editor.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-editor.atom.d.ts","sourceRoot":"","sources":["../../../atoms/active-editor.atom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGtD,eAAO,MAAM,gBAAgB;;CAA6C,CAAC;AAE3E,eAAO,MAAM,eAAe,iCAAuC,CAAC;AACpE,eAAO,MAAM,kBAAkB,sHAAqC,CAAC;AAIrE,eAAO,MAAM,mBAAmB,2EAAgC,CAAC"}

package/dist/cjs/atoms/active-editor.atom.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEditorVisibility = exports.useSetActiveEditor = exports.useActiveEditor = exports.activeEditorAtom = void 0;
+var jotai_1 = require("jotai");
+exports.activeEditorAtom = (0, jotai_1.atom)(undefined);
+var useActiveEditor = function () { return (0, jotai_1.useAtomValue)(exports.activeEditorAtom); };
+exports.useActiveEditor = useActiveEditor;
+var useSetActiveEditor = function () { return (0, jotai_1.useSetAtom)(exports.activeEditorAtom); };
+exports.useSetActiveEditor = useSetActiveEditor;
+var showEditorAtom = (0, jotai_1.atom)(false);
+var useEditorVisibility = function () { return (0, jotai_1.useAtom)(showEditorAtom); };
+exports.useEditorVisibility = useEditorVisibility;