@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/api/datatype.js

@@ -0,0 +1,671 @@
+import { __read, __values } from "tslib";
+import { getDefaultDateFormat, getDefaultDateTimeFormat, isAFormula, isNil, ssfFormat, ssfFormatColor, toDate, toSerial, } from "@rowsncolumns/utils";
+import { detectDateFormatPattern, detectDateTimeFormatPattern, isValidDate, isValidDateTime, toTimeSerial, validateDate, validateDateTime, } from "./date";
+import { detectDecimalPattern } from "./decimals";
+import { buildGroupRegex, getGroupingInfo, getLocaleDigitMap, getLocaleSeparators, getPercentSignInfo, getSignInfo, } from "./intl";
+export var pattern_percent = "0%";
+export var pattern_percent_decimal = "0.00%";
+// Match Excel's built-in numFmtId 5 / 7 exactly. The trailing
+// `_);("$"#,##0)` branch is Excel's default for negative currency
+// (parens with whitespace padding for column alignment). Keeping the
+// exact built-in pattern means xlsx export can emit the built-in ID and
+// Excel renders the workbook identically to one it produced itself.
+export var pattern_currency = '"$"#,##0_);("$"#,##0)';
+export var pattern_currency_decimal = '"$"#,##0.00_);("$"#,##0.00)';
+export var date_pattern = "mm/dd/yyyy";
+export var time_pattern_base = "hh:mm:ss";
+export var time_pattern = "hh:mm:ss AM/PM";
+export var time_pattern_short = "h:mm AM/PM";
+// Pre-compile frequently used regular expressions
+var NUMBER_CONVERSION_PATTERN = /[^0-9.-]+/g;
+var URL_PATTERN = /^(https?:\/\/)?(localhost|([\da-z\.-]+)\.([a-z\.]{2,6}))(:\d+)?(\/[\/\w \.-]*)*(\?[^\s]*)?$/i;
+var EMAIL_PATTERN = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+// Cache common string values
+var TRUE_UPPER = "TRUE";
+var FALSE_UPPER = "FALSE";
+var PERCENT_CHAR = "%";
+var currencySymbolPattern = (function () {
+    try {
+        return new RegExp("\\p{Sc}", "gu");
+    }
+    catch (_a) {
+        return /[£$€¥₹]/g;
+    }
+})();
+// Non-global variant for quick symbol detection.
+var currencySymbolTestPattern = (function () {
+    try {
+        return new RegExp("\\p{Sc}", "u");
+    }
+    catch (_a) {
+        return /[£$€¥₹]/;
+    }
+})();
+var stripCurrencySymbols = function (text) {
+    return text.replace(currencySymbolPattern, "");
+};
+/**
+ * Extract the currency symbol from a string (e.g., "$", "€", "£", "¥")
+ * Returns the symbol and its position (prefix or suffix)
+ */
+var extractCurrencySymbol = function (value) {
+    var match = value.match(currencySymbolPattern);
+    if (!match)
+        return undefined;
+    var symbol = match[0];
+    var symbolIndex = value.indexOf(symbol);
+    var trimmed = value.trim();
+    // Check if symbol is at the start (prefix) or end (suffix) of the trimmed string
+    var position = symbolIndex < trimmed.length / 2 ? "prefix" : "suffix";
+    return { symbol: symbol, position: position };
+};
+var replaceLocalizedDigits = function (text, locale) {
+    var e_1, _a;
+    var _b;
+    var digitMap = getLocaleDigitMap(locale);
+    if (digitMap.size === 0) {
+        return text;
+    }
+    var normalized = "";
+    try {
+        for (var text_1 = __values(text), text_1_1 = text_1.next(); !text_1_1.done; text_1_1 = text_1.next()) {
+            var char = text_1_1.value;
+            normalized += (_b = digitMap.get(char)) !== null && _b !== void 0 ? _b : char;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (text_1_1 && !text_1_1.done && (_a = text_1.return)) _a.call(text_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return normalized;
+};
+var escapeForRegExp = function (value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+};
+/**
+ * Strip a sign if it appears in a locale-allowed position.
+ */
+var stripSign = function (text, sign, allowPrefix, allowSuffix) {
+    if (!sign) {
+        return { text: text, ok: true, removed: false };
+    }
+    var escaped = escapeForRegExp(sign);
+    var matches = text.match(new RegExp(escaped, "g"));
+    var count = matches ? matches.length : 0;
+    if (count === 0) {
+        return { text: text, ok: true, removed: false };
+    }
+    if (count > 1) {
+        return { text: text, ok: false, removed: false };
+    }
+    if (allowPrefix) {
+        var prefixRegex = new RegExp("^".concat(escaped, "\\s*"));
+        if (prefixRegex.test(text)) {
+            return { text: text.replace(prefixRegex, ""), ok: true, removed: true };
+        }
+    }
+    if (allowSuffix) {
+        var suffixRegex = new RegExp("\\s*".concat(escaped, "$"));
+        if (suffixRegex.test(text)) {
+            return { text: text.replace(suffixRegex, ""), ok: true, removed: true };
+        }
+    }
+    return { text: text, ok: false, removed: false };
+};
+// Support scientific notation (e.g., 1.5e10, -4.656e-10)
+var NUMBER_PATTERN = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+/**
+ * Validate and strip signs/symbols from a numeric string.
+ */
+/**
+ * Validate and strip signs/symbols from a numeric string.
+ */
+var stripNumericDecorations = function (value, locale) {
+    var _a = getLocaleSeparators(locale), minusSign = _a.minusSign, percentSign = _a.percentSign;
+    var text = replaceLocalizedDigits(value.trim(), locale);
+    var _b = getSignInfo(locale), allowParens = _b.allowParens, prefix = _b.prefix, suffix = _b.suffix;
+    var isNegative = false;
+    // Handle scientific notation early (e.g., "-4.656e-10", "1.5e+10")
+    // Must be done before sign stripping to avoid confusion with minus in exponent
+    var scientificPattern = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)[eE][+-]?\d+$/;
+    if (scientificPattern.test(text)) {
+        // Already valid scientific notation, just check for leading minus
+        if (text.startsWith("-")) {
+            return { text: text.slice(1), ok: true, isNegative: true };
+        }
+        if (text.startsWith("+")) {
+            return { text: text.slice(1), ok: true, isNegative: false };
+        }
+        return { text: text, ok: true, isNegative: false };
+    }
+    if (text.includes("(") || text.includes(")")) {
+        if (!allowParens) {
+            return { text: "", ok: false, isNegative: false };
+        }
+        if (text.startsWith("(") && text.endsWith(")")) {
+            text = text.slice(1, -1);
+            isNegative = true;
+        }
+        else {
+            return { text: "", ok: false, isNegative: false };
+        }
+    }
+    // Excel/Google-Sheets-parity: only currency symbols (e.g. $, €, £, ¥) are
+    // auto-detected. ISO codes like "USD" are never stripped or recognized on
+    // input — typing "USD 100" or "Top 250" stays plain text.
+    text = stripCurrencySymbols(text);
+    var percentInfo = getPercentSignInfo(locale);
+    var percentResult = stripSign(text, percentInfo.sign, percentInfo.prefix, percentInfo.suffix);
+    if (!percentResult.ok) {
+        return { text: "", ok: false, isNegative: false };
+    }
+    var minusResult = stripSign(percentResult.text, minusSign, prefix, suffix);
+    if (!minusResult.ok) {
+        return { text: "", ok: false, isNegative: false };
+    }
+    if (minusResult.removed) {
+        isNegative = true;
+    }
+    return { text: minusResult.text.trim(), ok: true, isNegative: isNegative };
+};
+/**
+ * Validate locale grouping and separators for a numeric string.
+ */
+var isValidLocaleNumberString = function (value, locale, lenientGrouping) {
+    var _a;
+    if (lenientGrouping === void 0) { lenientGrouping = false; }
+    var _b = getLocaleSeparators(locale), group = _b.group, decimal = _b.decimal;
+    var stripped = stripNumericDecorations(value, locale);
+    if (!stripped.ok) {
+        return false;
+    }
+    var text = stripped.text;
+    if (text === "") {
+        return false;
+    }
+    // Handle scientific notation separately (e.g., "1.5e10", "-4.656e-10")
+    if (/[eE]/.test(text)) {
+        // Scientific notation pattern: optional sign, digits, optional decimal point and digits, e/E, optional sign, digits
+        var scientificPattern = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)[eE][+-]?\d+$/;
+        return scientificPattern.test(text);
+    }
+    var groupSplit = group ? buildGroupRegex(group) : undefined;
+    var groupRemove = group ? buildGroupRegex(group, true) : undefined;
+    var decimalSeparator = decimal !== null && decimal !== void 0 ? decimal : ".";
+    var integerPart = text;
+    var decimalPart = "";
+    if (decimalSeparator && text.includes(decimalSeparator)) {
+        var parts = text.split(decimalSeparator);
+        if (parts.length !== 2) {
+            return false;
+        }
+        _a = __read(parts, 2), integerPart = _a[0], decimalPart = _a[1];
+        if (groupSplit && decimalPart && groupSplit.test(decimalPart)) {
+            return false;
+        }
+    }
+    if (groupSplit && integerPart && groupSplit.test(integerPart)) {
+        var groupingInfo_1 = getGroupingInfo(locale);
+        if (!groupingInfo_1) {
+            return false;
+        }
+        var segments = integerPart.split(groupSplit);
+        if (segments.some(function (segment) { return segment.length === 0 || !/^\d+$/.test(segment); })) {
+            return false;
+        }
+        if (lenientGrouping) {
+            // Even in lenient mode, the last segment must have exactly `primary` digits
+            // (typically 3), otherwise it's not valid thousands grouping.
+            // For example, "600.50" with . as thousands separator should be invalid
+            // because "50" only has 2 digits, not 3.
+            var lastLen = segments[segments.length - 1].length;
+            if (lastLen !== groupingInfo_1.primary) {
+                return false;
+            }
+            // Check that no segment exceeds the expected grouping size
+            if (segments.some(function (segment) { return segment.length > groupingInfo_1.secondary; })) {
+                return false;
+            }
+        }
+        else {
+            var lastLen = segments[segments.length - 1].length;
+            if (lastLen !== groupingInfo_1.primary) {
+                return false;
+            }
+            if (segments.length > 1) {
+                for (var i = segments.length - 2; i > 0; i -= 1) {
+                    if (segments[i].length !== groupingInfo_1.secondary) {
+                        return false;
+                    }
+                }
+                var firstLen = segments[0].length;
+                if (firstLen < 1 ||
+                    firstLen > groupingInfo_1.secondary ||
+                    !/^\d+$/.test(segments[0])) {
+                    return false;
+                }
+            }
+        }
+    }
+    else if (integerPart) {
+        var integerDigits = groupRemove
+            ? integerPart.replace(groupRemove, "")
+            : integerPart;
+        if (integerDigits !== "" && !/^\d+$/.test(integerDigits)) {
+            return false;
+        }
+    }
+    if (decimalPart !== "" && !/^\d+$/.test(decimalPart)) {
+        return false;
+    }
+    return true;
+};
+/**
+ * Normalize a numeric string to a parseable form using locale separators.
+ */
+var normalizeNumberString = function (value, locale) {
+    var _a = getLocaleSeparators(locale), group = _a.group, decimal = _a.decimal;
+    var stripped = stripNumericDecorations(value, locale);
+    if (!stripped.ok) {
+        return "";
+    }
+    var normalized = stripped.text.replace(/[\s\u00A0\u202F]/g, "");
+    // Handle scientific notation - just add minus sign if needed, no other normalization
+    if (/[eE]/.test(normalized)) {
+        if (stripped.isNegative && normalized !== "") {
+            normalized = "-".concat(normalized);
+        }
+        return normalized;
+    }
+    if (group) {
+        var groupPattern = /\s/.test(group) || group === "\u00A0" || group === "\u202F"
+            ? /[\s\u00A0\u202F]/g
+            : new RegExp(escapeForRegExp(group), "g");
+        normalized = normalized.replace(groupPattern, "");
+    }
+    if (decimal && decimal !== ".") {
+        normalized = normalized.split(decimal).join(".");
+    }
+    if (stripped.isNegative && normalized !== "") {
+        normalized = "-".concat(normalized);
+    }
+    return normalized;
+};
+/**
+ * Parse a locale-formatted numeric string into a JS number.
+ */
+var parseLocaleNumber = function (value, locale, lenientGrouping) {
+    if (lenientGrouping === void 0) { lenientGrouping = false; }
+    if (!isValidLocaleNumberString(value, locale, lenientGrouping)) {
+        return NaN;
+    }
+    var normalized = normalizeNumberString(value, locale);
+    if (normalized === "") {
+        return NaN;
+    }
+    if (!NUMBER_PATTERN.test(normalized)) {
+        return NaN;
+    }
+    // For scientific notation, skip the conversion pattern cleanup
+    // because the normalized string is already in the correct format
+    if (/[eE]/.test(normalized)) {
+        return Number(normalized);
+    }
+    return Number(normalized.replace(NUMBER_CONVERSION_PATTERN, ""));
+};
+/**
+ * Detect if a string contains any currency symbol.
+ */
+var hasCurrencySymbol = function (value) {
+    return currencySymbolTestPattern.test(value);
+};
+/**
+ * Detect if the string contains more than one currency symbol occurrence —
+ * e.g. ``"$100€"`` (mixed) or ``"$100$"`` (duplicated). Excel / Sheets
+ * accept a single ``$`` prefix or a single ``$`` suffix but never both at
+ * once, so the safest rule is: any second symbol means this is text.
+ */
+var hasMultipleCurrencySymbols = function (value) {
+    var matches = value.match(currencySymbolPattern);
+    return !!matches && matches.length > 1;
+};
+/**
+ * Check if value is currency.
+ *
+ * Excel / Google Sheets parity: only currency *symbols* (e.g. ``$``, ``€``,
+ * ``£``, ``¥``, ``₹`` — anything in the Unicode ``\p{Sc}`` block) trigger
+ * currency auto-detection on cell input. ISO 4217 codes like ``USD``,
+ * ``EUR``, ``TOP`` are never recognized as currency from typed text, since
+ * many of them collide with ordinary English words (``Top``, ``Try``,
+ * ``Bob``, ``Cup``, ``Won``, ``All``, ``Lek``, …). Currency styling via ISO
+ * code can still be applied through the explicit format menu — it just
+ * isn't inferred from raw input.
+ *
+ * Mixed-symbol strings (``"$100€"``, ``"€£50"``) are rejected as text —
+ * stripping both symbols and parsing the leftover digits would otherwise
+ * paint the cell as currency with whichever symbol the renderer picked.
+ */
+export var isCurrency = function (value, locale, lenientGrouping) {
+    if (lenientGrouping === void 0) { lenientGrouping = true; }
+    if (value === void 0)
+        return false;
+    var text = String(value).trim();
+    if (hasMultipleCurrencySymbols(text))
+        return false;
+    return (hasCurrencySymbol(text) &&
+        isValidLocaleNumberString(text, locale, lenientGrouping) &&
+        !isNaN(parseLocaleNumber(text, locale, lenientGrouping)));
+};
+/**
+ * Boolean
+ * @param str
+ * @returns
+ */
+export var isBoolean = function (value) {
+    if (typeof value === "boolean")
+        return true;
+    if (typeof value !== "string" && typeof value !== "number")
+        return false;
+    var upperValue = String(value).toUpperCase();
+    return upperValue === TRUE_UPPER || upperValue === FALSE_UPPER;
+};
+/**
+ * Detect if value is percentage
+ * @param value
+ * @returns
+ */
+export var isPercentage = function (value, locale, lenientGrouping) {
+    if (lenientGrouping === void 0) { lenientGrouping = true; }
+    if (isNil(value))
+        return false;
+    var strValue = String(value).trim();
+    var percentSign = getLocaleSeparators(locale).percentSign;
+    var hasPercent = strValue.endsWith(percentSign) ||
+        strValue.startsWith(percentSign) ||
+        strValue.endsWith(PERCENT_CHAR) ||
+        strValue.startsWith(PERCENT_CHAR);
+    if (!hasPercent) {
+        return false;
+    }
+    return !isNaN(parseLocaleNumber(strValue, locale, lenientGrouping));
+};
+/**
+ * Cleanup number value
+ * @param value
+ * @returns
+ */
+export var cleanNumberValue = function (value, locale) {
+    if (typeof value === "number")
+        return String(value);
+    if (isNil(value)) {
+        return "";
+    }
+    var trimmedValue = String(value).trim();
+    if (trimmedValue === "") {
+        return "";
+    }
+    return normalizeNumberString(trimmedValue, locale);
+};
+export var convertToNumber = function (text, locale, lenientGrouping) {
+    if (lenientGrouping === void 0) { lenientGrouping = true; }
+    if (typeof text === "number") {
+        return text;
+    }
+    return parseLocaleNumber(String(text), locale, lenientGrouping);
+};
+/**
+ * Create number value
+ * @param value
+ * @returns
+ */
+export var createNumberValue = function (value, numFormatType, locale, use1904, lenientGrouping) {
+    if (lenientGrouping === void 0) { lenientGrouping = true; }
+    if (isNil(value)) {
+        return undefined;
+    }
+    var isDate = numFormatType === "DATE";
+    var isDateTime = numFormatType === "DATE_TIME";
+    if (typeof value !== "boolean" && (isDate || isDateTime)) {
+        if (typeof value === "number") {
+            var dateValue_1 = createDateValueFromNumber(value, use1904);
+            if (!isNil(dateValue_1) && dateValue_1 instanceof Date) {
+                return toSerial(dateValue_1, use1904);
+            }
+        }
+        var dateValue = isDate
+            ? validateDate(value, locale)
+            : validateDateTime(value);
+        if (dateValue) {
+            var _a = dateValue.parts, year = _a.year, month = _a.month, day = _a.day, hour = _a.hour, minute = _a.minute, second = _a.second, isTimeOnly = dateValue.isTimeOnly;
+            if (isTimeOnly) {
+                return toTimeSerial(hour !== null && hour !== void 0 ? hour : 0, minute !== null && minute !== void 0 ? minute : 0, second !== null && second !== void 0 ? second : 0);
+            }
+            return toSerial(new Date(year, month, day, hour, minute, second, 0), use1904);
+        }
+    }
+    return convertToNumber(value, locale, lenientGrouping);
+};
+export var createDateValueFromNumber = function (value, use1904) {
+    if (typeof value === "number") {
+        return toDate(value, use1904);
+    }
+    return value;
+};
+/**
+ * Check if value is number
+ * @param str
+ * @returns
+ */
+export var isNumber = function (value, locale, lenientGrouping) {
+    if (lenientGrouping === void 0) { lenientGrouping = true; }
+    // If value is already a JavaScript number, no locale validation needed
+    if (typeof value === "number") {
+        return !isNaN(value);
+    }
+    // For strings and other types, apply locale parsing
+    return !isNaN(parseLocaleNumber(String(value !== null && value !== void 0 ? value : ""), locale, lenientGrouping));
+};
+/**
+ * Detect number format of a value
+ * @param value
+ * @returns
+ */
+export var detectNumberFormatType = function (value, locale, lenientGrouping) {
+    if (lenientGrouping === void 0) { lenientGrouping = true; }
+    if (isCurrency(value, locale, lenientGrouping)) {
+        return "CURRENCY";
+    }
+    if (isPercentage(value, locale, lenientGrouping)) {
+        return "PERCENT";
+    }
+    if (isNumber(value, locale, lenientGrouping)) {
+        return "NUMBER";
+    }
+    if (isValidDate(value, locale)) {
+        return "DATE";
+    }
+    if (isValidDateTime(value)) {
+        return "DATE_TIME";
+    }
+};
+/**
+ * Detect pattern of a number format
+ * @param type
+ * @returns
+ */
+export var detectNumberFormatPattern = function (value, numberValue, type, locale, use1904) {
+    var _a, _b;
+    if (type === "PERCENT") {
+        return detectDecimalPattern(value, pattern_percent, locale);
+    }
+    if (type === "CURRENCY") {
+        // Extract the actual currency symbol and position from the input
+        var currencyInfo = extractCurrencySymbol(String(value));
+        var symbol = (currencyInfo === null || currencyInfo === void 0 ? void 0 : currencyInfo.symbol) || "$";
+        var position = (currencyInfo === null || currencyInfo === void 0 ? void 0 : currencyInfo.position) || "prefix";
+        // Create a pattern with the detected currency symbol in the correct position
+        var baseCurrencyPattern = position === "suffix" ? "#,##0\"".concat(symbol, "\"") : "\"".concat(symbol, "\"#,##0");
+        return detectDecimalPattern(numberValue, baseCurrencyPattern, locale);
+    }
+    if (type === "DATE") {
+        return (_a = detectDateFormatPattern(value, locale)) !== null && _a !== void 0 ? _a : date_pattern;
+    }
+    if (type === "DATE_TIME") {
+        return (_b = detectDateTimeFormatPattern(value)) !== null && _b !== void 0 ? _b : time_pattern;
+    }
+    if (type === "NUMBER") {
+        // An integer zero with no explicit format stays "General" — typing `0`,
+        // `00`, or a signed zero into a blank cell shouldn't manufacture a `#`
+        // number pattern that renders the value as blank. This rule is
+        // specific to the implicit NUMBER format; explicit CURRENCY / PERCENT
+        // formats keep their own base pattern for zero (handled above), so `$0`
+        // stays `"$"#,##0` rather than collapsing to a bare `0`.
+        if (value === 0 ||
+            (typeof value === "string" && /^[-+]?0+$/.test(value.trim()))) {
+            return "General";
+        }
+        return detectDecimalPattern(value, undefined, locale);
+    }
+    return undefined;
+};
+/**
+ * Detect datatype of a value
+ * @param value
+ */
+export var detectValueType = function (value, locale, lenientGrouping) {
+    if (lenientGrouping === void 0) { lenientGrouping = true; }
+    if (isAFormula(value)) {
+        return "formulaValue";
+    }
+    if (isBoolean(value)) {
+        return "boolValue";
+    }
+    // Dates are treated as number
+    if (isNumber(value, locale, lenientGrouping) ||
+        isValidDate(value, locale) ||
+        isValidDateTime(value)) {
+        return "numberValue";
+    }
+    return "stringValue";
+};
+export var detectValueTypeAndPattern = function (value, locale, lenientGrouping, use1904) {
+    if (lenientGrouping === void 0) { lenientGrouping = true; }
+    if (isAFormula(value)) {
+        return ["formulaValue"];
+    }
+    if (isBoolean(value)) {
+        return ["boolValue"];
+    }
+    // A real JS Date instance (autofill/fill-down copies a date cell's value as
+    // a Date, and programmatic writes may pass one too). The string-based
+    // validateDate/validateDateTime paths below reject non-strings, so without
+    // this branch a Date falls through to ["stringValue"] and gets stored as its
+    // raw `.toString()` — e.g. "Tue Sep 01 2026 00:00:00 GMT+0800 (…)". Convert
+    // to a serial and pick DATE vs DATE_TIME from the time component, mirroring
+    // how the equivalent typed string is classified.
+    if (value instanceof Date) {
+        if (isNaN(value.getTime())) {
+            return ["stringValue"];
+        }
+        var serial = toSerial(value, use1904);
+        var hasTime = value.getHours() !== 0 ||
+            value.getMinutes() !== 0 ||
+            value.getSeconds() !== 0 ||
+            value.getMilliseconds() !== 0;
+        return hasTime
+            ? ["numberValue", "DATE_TIME", serial, getDefaultDateTimeFormat(locale)]
+            : ["numberValue", "DATE", serial, getDefaultDateFormat(locale)];
+    }
+    // Check currency first OR number (currency values may not pass isNumber)
+    var isCurr = isCurrency(value, locale, lenientGrouping);
+    var isNum = !isCurr && isNumber(value, locale, lenientGrouping);
+    if (isCurr || isNum) {
+        var numberValue = convertToNumber(value, locale, lenientGrouping);
+        // Check for scientific notation (e.g., 1.5e10, -4.656e-10)
+        if (!isCurr && typeof value === "string" && /[eE]/.test(value)) {
+            return ["numberValue", "SCIENTIFIC", numberValue, "0.00E+00"];
+        }
+        // Check currency
+        if (isCurr) {
+            // Extract the actual currency symbol and position from the input
+            var currencyInfo = extractCurrencySymbol(String(value));
+            var symbol = (currencyInfo === null || currencyInfo === void 0 ? void 0 : currencyInfo.symbol) || "$";
+            var position = (currencyInfo === null || currencyInfo === void 0 ? void 0 : currencyInfo.position) || "prefix";
+            // Create a pattern with the detected currency symbol in the correct position
+            var baseCurrencyPattern = position === "suffix" ? "#,##0\"".concat(symbol, "\"") : "\"".concat(symbol, "\"#,##0");
+            var pattern = detectDecimalPattern(numberValue, baseCurrencyPattern, locale);
+            return ["numberValue", "CURRENCY", numberValue, pattern];
+        }
+        // Numbers can be number, percent, date, datetime
+        if (isPercentage(value, locale, lenientGrouping)) {
+            var pattern = detectDecimalPattern(numberValue, pattern_percent, locale);
+            var percentValue = convertToNumber(value, locale, lenientGrouping) / 100;
+            return ["numberValue", "PERCENT", percentValue, pattern];
+        }
+        return [
+            "numberValue",
+            "NUMBER",
+            convertToNumber(value, locale, lenientGrouping),
+            detectNumberFormatPattern(value, numberValue, "NUMBER", locale),
+        ];
+    }
+    // Date time (check before date to catch time-only formats like "1:00 AM")
+    var dateTimeValue = validateDateTime(value);
+    if (dateTimeValue) {
+        var _a = dateTimeValue.parts, year = _a.year, month = _a.month, day = _a.day, hour = _a.hour, minute = _a.minute, second = _a.second, isTimeOnly = dateTimeValue.isTimeOnly;
+        var numberValue = isTimeOnly
+            ? toTimeSerial(hour !== null && hour !== void 0 ? hour : 0, minute !== null && minute !== void 0 ? minute : 0, second !== null && second !== void 0 ? second : 0)
+            : toSerial(new Date(year, month, day, hour, minute, second, 0), use1904);
+        return ["numberValue", "DATE_TIME", numberValue, dateTimeValue.format];
+    }
+    // Dates
+    var dateValue = validateDate(value, locale);
+    if (dateValue) {
+        var _b = dateValue.parts, year = _b.year, month = _b.month, day = _b.day, hour = _b.hour, minute = _b.minute, second = _b.second;
+        var numberValue = toSerial(new Date(year, month, day, hour, minute, second, 0), use1904);
+        return ["numberValue", "DATE", numberValue, dateValue.format];
+    }
+    return ["stringValue"];
+};
+/**
+ * Create formatted value
+ * @param value
+ * @param pattern
+ * @returns
+ */
+export var createFormattedValue = function (value, valueType, pattern, locale) {
+    var finalValue = valueType === "boolValue"
+        ? String(value).toUpperCase() === TRUE_UPPER
+        : value;
+    return ssfFormat(pattern, finalValue, locale);
+};
+export var createFormattedColor = function (value, valueType, pattern) {
+    var _a;
+    var finalValue = valueType === "boolValue"
+        ? String(value).toUpperCase() === TRUE_UPPER
+        : value;
+    return (_a = ssfFormatColor(pattern, finalValue)) !== null && _a !== void 0 ? _a : undefined;
+};
+export var isMultiline = function (str) {
+    return String(str).indexOf("\n") !== -1;
+};
+export var isValidURLorEmail = function (str) {
+    if (!str || typeof str !== "string")
+        return false;
+    // Quick check for common indicators before running expensive tests
+    if (str.includes("@"))
+        return EMAIL_PATTERN.test(str);
+    if (str.includes("://")) {
+        try {
+            new URL(str);
+            return true;
+        }
+        catch (_a) {
+            return URL_PATTERN.test(str);
+        }
+    }
+    return URL_PATTERN.test(str) || EMAIL_PATTERN.test(str);
+};

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

@@ -0,0 +1,27 @@
+export interface DateParts {
+    year: number;
+    month: number;
+    day: number;
+    hour?: number;
+    minute?: number;
+    second?: number;
+}
+export interface ValidDateResult {
+    format: string;
+    parts: DateParts;
+    isTimeOnly?: boolean;
+}
+export declare const validateDate: (value: string | number | boolean | Date | undefined, locale: string | undefined) => ValidDateResult | undefined;
+export declare const validateDateTime: (value: string | number | boolean | Date | undefined) => ValidDateResult | undefined;
+/**
+ * Convert a time-only value to an Excel serial fraction.
+ */
+export declare const toTimeSerial: (hour: number, minute: number, second: number) => number;
+export declare const isValidDate: (value: any, locale: string | undefined) => boolean;
+export declare const isValidDateTime: (value: any) => boolean;
+export declare const detectDateFormatPattern: (value: string | number | boolean | Date | undefined, locale: string | undefined) => string | undefined;
+export declare const detectDateTimeFormatPattern: (value: string | number | boolean | Date | undefined) => string | undefined;
+export declare const getCurrentYear: () => number;
+export declare const getCurrentMonth: () => number;
+export declare const getCurrentDay: () => number;
+//# sourceMappingURL=date.d.ts.map