@rowsncolumns/toolkit 24.4.1

package/dist/cjs/excel-parser/plugins/xlsx/value-type-detection.js

@@ -0,0 +1,407 @@
+import { __read } from "tslib";
+import { parse } from "@rowsncolumns/date-parser";
+import { isAFormula, isNil, toDate, toSerial } from "@rowsncolumns/utils";
+export var pattern_percent = "0%";
+export var pattern_percent_decimal = "0.00%";
+export var pattern_currency = '"$"#,##0';
+export var pattern_currency_decimal = '"$"#,##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";
+var CURRENCY_PATTERN = /^[£$€¥₹]\d+(?:[.,]\d{1,2})?$|^\d+(?:[.,]\d{1,2})?[£$€¥₹]$/;
+var CURRENCY_GROUPING_CHARS = /[,\s]/g;
+var NUMBER_CLEANUP_PATTERN = /[$,%]/gi;
+var NUMBER_CONVERSION_PATTERN = /[^0-9.-]+/g;
+var TRUE_UPPER = "TRUE";
+var FALSE_UPPER = "FALSE";
+var PERCENT_CHAR = "%";
+var PATTERN_SEPARATOR = ";";
+var DECIMAL_CLEANUP_REGEX = /[^0-9.,]/g;
+var DECIMAL_SPLIT_REGEX = /[.]/;
+// const THOUSAND_REGEX = /(\,[#,0]{3})/gi;
+// const THOUSAND_PATTERN = ",##0";
+var ISO_DATE_REGEX = /^(\d{4})[-/.](\d{2})[-/.](\d{2})$/;
+var TIME_REGEX = {
+    FULL_WITH_MERIDIAN: /^(\d{1,2}):(\d{1,2}):(\d{1,2})\s*(AM|PM|a|p)$/i,
+    FULL: /^(\d{1,2}):(\d{1,2}):(\d{1,2})$/,
+    SHORT_WITH_MERIDIAN: /^(\d{1,2}):(\d{1,2})\s*(AM|PM)$/i,
+    SHORT: /^(\d{1,2}):(\d{1,2})$/,
+};
+var TIME_FORMATS = {
+    FULL_WITH_MERIDIAN: "hh:mm:ss AM/PM",
+    FULL: "hh:mm:ss",
+    SHORT_WITH_MERIDIAN: "hh:mm AM/PM",
+    SHORT: "hh:mm",
+};
+var DECIMAL_REGEX = new RegExp("(?<prefix>[\\d#,]+)(?<decimal>\\.)?(?<suffix>\\d{1,})?", "i");
+export var isCurrency = function (value) {
+    if (value === void 0)
+        return false;
+    var text = String(value).trim();
+    var normalized = text.replace(CURRENCY_GROUPING_CHARS, "");
+    return CURRENCY_PATTERN.test(normalized);
+};
+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;
+};
+export var isPercentage = function (value) {
+    if (isNil(value))
+        return false;
+    var strValue = String(value).trim();
+    return strValue.endsWith(PERCENT_CHAR) || strValue.startsWith(PERCENT_CHAR);
+};
+export var cleanNumberValue = function (value) {
+    if (typeof value === "number")
+        return String(value);
+    if (isNil(value)) {
+        return "";
+    }
+    var trimmedValue = String(value).trim();
+    if (trimmedValue === "") {
+        return "";
+    }
+    return trimmedValue.replace(NUMBER_CLEANUP_PATTERN, "");
+};
+export var convertToNumber = function (text) {
+    if (typeof text === "number") {
+        return text;
+    }
+    return Number(String(text).replace(NUMBER_CONVERSION_PATTERN, ""));
+};
+export var createNumberValue = function (value, numFormatType, locale) {
+    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);
+            if (!isNil(dateValue_1) && dateValue_1 instanceof Date) {
+                return toSerial(dateValue_1);
+            }
+        }
+        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;
+            return toSerial(new Date(year, month, day, hour, minute, second, 0));
+        }
+    }
+    return convertToNumber(value);
+};
+export var createDateValueFromNumber = function (value) {
+    if (typeof value === "number") {
+        return toDate(value);
+    }
+    return value;
+};
+export var isNumber = function (value) {
+    var sanitizedValue = cleanNumberValue(value);
+    if (sanitizedValue === "") {
+        return false;
+    }
+    return !isNaN(Number(sanitizedValue));
+};
+var createZeros = function (len) {
+    return Array.from({ length: len })
+        .map(function () { return "0"; })
+        .join("");
+};
+export var getDecimalPlaces = function (value) {
+    var cleanedValue = value.replace(DECIMAL_CLEANUP_REGEX, "");
+    var parts = cleanedValue.split(DECIMAL_SPLIT_REGEX);
+    if (parts.length === 1) {
+        return 0;
+    }
+    var decimalPart = parts[parts.length - 1];
+    return decimalPart.length;
+};
+export var detectDecimalPattern = function (value, defaultPattern) {
+    if (defaultPattern === void 0) { defaultPattern = "#"; }
+    var str = String(value);
+    var hasThousands = str.indexOf(",") !== -1;
+    var decimalsLen = getDecimalPlaces(str);
+    var numValue = Number(str.replace(/[^0-9.-]/g, ""));
+    var needsLeadingZero = Math.abs(numValue) < 1;
+    var prefix = hasThousands ? "#,##0" : defaultPattern;
+    if (decimalsLen !== 0) {
+        if (needsLeadingZero && prefix === "#") {
+            prefix = "0";
+        }
+        return changeDecimals(prefix, decimalsLen, true);
+    }
+    return prefix;
+};
+export var changeDecimals = function (pattern, changeBy, delta) {
+    if (pattern === void 0) { pattern = ""; }
+    if (changeBy === void 0) { changeBy = 1; }
+    if (delta === void 0) { delta = true; }
+    var patterns = pattern.split(PATTERN_SEPARATOR);
+    return patterns
+        .map(function (p) {
+        var match = p.match(DECIMAL_REGEX);
+        if (match && match.groups) {
+            var _a = match.groups, decimal = _a.decimal, suffix = _a.suffix;
+            if (!decimal) {
+                var newDecimals = Math.max(changeBy, 0);
+                var zeros_1 = createZeros(newDecimals);
+                return p.replace(DECIMAL_REGEX, "$1$2".concat(zeros_1.length ? "." + zeros_1 : ""));
+            }
+            var newSuffix = 0;
+            if (suffix) {
+                newSuffix = Math.max(delta ? suffix.length + changeBy : changeBy, 0);
+            }
+            var zeros = createZeros(newSuffix);
+            return p.replace(DECIMAL_REGEX, "$1".concat(zeros.length ? "$2" + zeros : ""));
+        }
+        if (!p) {
+            var newDecimals = Math.max(changeBy, 0);
+            var zeros = createZeros(newDecimals);
+            return "0".concat(zeros.length ? "." + zeros : "");
+        }
+        return p;
+    })
+        .join(PATTERN_SEPARATOR);
+};
+export var validateDate = function (value, locale) {
+    if (typeof value === "number") {
+        var match = ISO_DATE_REGEX.exec(String(value));
+        if (match) {
+            var _a = __read(match, 4), yearStr = _a[1], monthStr = _a[2], dayStr = _a[3];
+            var year = Number(yearStr);
+            var month = Number(monthStr) - 1;
+            var day = Number(dayStr);
+            var dateValue_2 = new Date(year, month, day);
+            if (dateValue_2.getFullYear() === year &&
+                dateValue_2.getMonth() === month &&
+                dateValue_2.getDate() === Number(dayStr)) {
+                return {
+                    format: "yyyy-mm-dd",
+                    parts: {
+                        year: year,
+                        month: month,
+                        day: day,
+                        hour: 0,
+                        minute: 0,
+                        second: 0,
+                    },
+                };
+            }
+        }
+    }
+    if (typeof value !== "string")
+        return undefined;
+    var result = parse(value, { locale: locale });
+    if (!result)
+        return undefined;
+    var dateValue = result.dateValue;
+    return {
+        format: result.pattern,
+        parts: {
+            year: dateValue.getFullYear(),
+            month: dateValue.getMonth(),
+            day: dateValue.getDate(),
+            hour: dateValue.getHours(),
+            minute: dateValue.getMinutes(),
+            second: dateValue.getSeconds(),
+        },
+    };
+};
+export var validateDateTime = function (value) {
+    if (typeof value !== "string")
+        return undefined;
+    var str = value.trim();
+    var match;
+    if ((match = TIME_REGEX.FULL_WITH_MERIDIAN.exec(str))) {
+        var hour = parseInt(match[1], 10);
+        var minute = parseInt(match[2], 10);
+        var second = parseInt(match[3], 10);
+        var meridian = match[4];
+        if (isValidTimeComponents(hour, minute, second, meridian)) {
+            return createTimeResult(TIME_FORMATS.FULL_WITH_MERIDIAN, adjustHour(hour, meridian), minute, second);
+        }
+    }
+    if ((match = TIME_REGEX.FULL.exec(str))) {
+        var hour = parseInt(match[1], 10);
+        var minute = parseInt(match[2], 10);
+        var second = parseInt(match[3], 10);
+        if (isValidTimeComponents(hour, minute, second)) {
+            return createTimeResult(TIME_FORMATS.FULL, hour, minute, second);
+        }
+    }
+    if ((match = TIME_REGEX.SHORT_WITH_MERIDIAN.exec(str))) {
+        var hour = parseInt(match[1], 10);
+        var minute = parseInt(match[2], 10);
+        var meridian = match[3];
+        if (isValidTimeComponents(hour, minute, 0, meridian)) {
+            return createTimeResult(TIME_FORMATS.SHORT_WITH_MERIDIAN, adjustHour(hour, meridian), minute, 0);
+        }
+    }
+    if ((match = TIME_REGEX.SHORT.exec(str))) {
+        var hour = parseInt(match[1], 10);
+        var minute = parseInt(match[2], 10);
+        if (isValidTimeComponents(hour, minute, 0)) {
+            return createTimeResult(TIME_FORMATS.SHORT, hour, minute, 0);
+        }
+    }
+    return undefined;
+};
+var isValidTimeComponents = function (hour, minute, second, meridian) {
+    if (hour > 24 ||
+        minute > 59 ||
+        second > 59 ||
+        ((meridian === null || meridian === void 0 ? void 0 : meridian.toUpperCase()) === "AM" && hour > 12)) {
+        return false;
+    }
+    return true;
+};
+var adjustHour = function (hour, meridian) {
+    if ((meridian === null || meridian === void 0 ? void 0 : meridian.toLowerCase().charAt(0)) === "p" && hour < 12) {
+        return hour + 12;
+    }
+    return hour;
+};
+var createTimeResult = function (format, hour, minute, second) {
+    var now = new Date();
+    return {
+        format: format,
+        parts: {
+            year: now.getFullYear(),
+            month: now.getMonth(),
+            day: now.getDate(),
+            hour: hour,
+            minute: minute,
+            second: second,
+        },
+    };
+};
+export var detectDateFormatPattern = function (value, locale) {
+    var _a;
+    if (!value || (typeof value !== "string" && !(value instanceof Date))) {
+        return undefined;
+    }
+    return (_a = validateDate(value, locale)) === null || _a === void 0 ? void 0 : _a.format;
+};
+export var detectDateTimeFormatPattern = function (value) {
+    var _a, _b;
+    if (!value || typeof value !== "string") {
+        return undefined;
+    }
+    return (_b = (_a = validateDateTime(value)) === null || _a === void 0 ? void 0 : _a.format) !== null && _b !== void 0 ? _b : time_pattern;
+};
+export var detectNumberFormatType = function (value, locale) {
+    if (isCurrency(value)) {
+        return "CURRENCY";
+    }
+    if (isPercentage(value)) {
+        return "PERCENT";
+    }
+    if (isNumber(value)) {
+        return "NUMBER";
+    }
+    if (isValidDate(value, locale)) {
+        return "DATE";
+    }
+    if (isValidDateTime(value)) {
+        return "DATE_TIME";
+    }
+};
+export var detectNumberFormatPattern = function (value, numberValue, type, locale) {
+    var _a, _b;
+    if (type === "PERCENT") {
+        return detectDecimalPattern(value, pattern_percent);
+    }
+    if (type === "CURRENCY") {
+        return detectDecimalPattern(numberValue, pattern_currency);
+    }
+    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" — imported `0`,
+        // `00`, and signed zero values with a General number format shouldn't
+        // manufacture a `#` pattern that renders the value as blank.
+        // Explicit CURRENCY / PERCENT formats keep their own base pattern for
+        // zero (handled above), so `$0` stays `"$"#,##0`, not a bare `0`.
+        if (value === 0 ||
+            (typeof value === "string" && /^[-+]?0+$/.test(value.trim()))) {
+            return "General";
+        }
+        return detectDecimalPattern(value);
+    }
+    return undefined;
+};
+export var detectValueType = function (value, locale) {
+    if (isAFormula(value)) {
+        return "formulaValue";
+    }
+    if (isBoolean(value)) {
+        return "boolValue";
+    }
+    if (isNumber(value) || isValidDate(value, locale) || isValidDateTime(value)) {
+        return "numberValue";
+    }
+    return "stringValue";
+};
+export var detectValueTypeAndPattern = function (value, locale) {
+    if (isAFormula(value)) {
+        return ["formulaValue"];
+    }
+    if (isBoolean(value)) {
+        return ["boolValue"];
+    }
+    if (isNumber(value)) {
+        var numberValue = convertToNumber(value);
+        if (isCurrency(value)) {
+            var pattern = detectDecimalPattern(numberValue, pattern_currency);
+            return ["numberValue", "CURRENCY", numberValue, pattern];
+        }
+        if (isPercentage(value)) {
+            var pattern = detectDecimalPattern(numberValue, pattern_percent);
+            var percentValue = convertToNumber(value) / 100;
+            return ["numberValue", "PERCENT", percentValue, pattern];
+        }
+        return [
+            "numberValue",
+            "NUMBER",
+            convertToNumber(value),
+            detectNumberFormatPattern(value, numberValue, "NUMBER", locale),
+        ];
+    }
+    var dateValue = validateDate(value, locale);
+    if (dateValue) {
+        var _a = dateValue.parts, year = _a.year, month = _a.month, day = _a.day, hour = _a.hour, minute = _a.minute, second = _a.second;
+        var numberValue = toSerial(new Date(year, month, day, hour, minute, second, 0));
+        return ["numberValue", "DATE", numberValue, dateValue.format];
+    }
+    var dateTimeValue = validateDateTime(value);
+    if (dateTimeValue) {
+        var _b = dateTimeValue.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));
+        return ["numberValue", "DATE_TIME", numberValue, dateTimeValue.format];
+    }
+    return ["stringValue"];
+};
+export var isValidDate = function (value, locale) {
+    if (!value || (typeof value !== "string" && !(value instanceof Date))) {
+        return false;
+    }
+    return !!validateDate(value, locale);
+};
+export var isValidDateTime = function (value) {
+    if (!value || typeof value !== "string") {
+        return false;
+    }
+    return !!validateDateTime(value);
+};

package/dist/cjs/excel-parser/registry.d.ts

@@ -0,0 +1,5 @@
+import type { IWorkbookPlugin } from "./interface";
+export type PluginFactory = () => IWorkbookPlugin;
+export declare const PARSER_REGISTRY: Record<string, PluginFactory>;
+export declare function getPluginForFile(file: File | string): IWorkbookPlugin;
+//# sourceMappingURL=registry.d.ts.map

package/dist/cjs/excel-parser/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../excel-parser/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAMnD,MAAM,MAAM,aAAa,GAAG,MAAM,eAAe,CAAC;AAElD,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAKzD,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,eAAe,CAWrE"}

package/dist/cjs/excel-parser/registry.js

@@ -0,0 +1,21 @@
+import { OdsPlugin } from "./plugins/ods/index";
+import { XlsbPlugin } from "./plugins/xlsb/index";
+import { XlsmPlugin } from "./plugins/xlsm/index";
+import { XlsxPlugin } from "./plugins/xlsx/index";
+export var PARSER_REGISTRY = {
+    xlsx: function () { return new XlsxPlugin(); },
+    xlsm: function () { return new XlsmPlugin(); },
+    xlsb: function () { return new XlsbPlugin(); },
+    ods: function () { return new OdsPlugin(); },
+};
+export function getPluginForFile(file) {
+    var _a;
+    var fileName = typeof file === "string" ? file : file.name;
+    var extension = (_a = fileName.split(".").pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    if (extension && PARSER_REGISTRY[extension]) {
+        return PARSER_REGISTRY[extension]();
+    }
+    // Default to xlsx for now if unknown, or maybe throw error?
+    // Current behavior assumes everything is xlsx-like
+    return new XlsxPlugin();
+}

package/dist/cjs/excel-parser/style-registry.d.ts

@@ -0,0 +1,51 @@
+import type { CellFormat, TextFormat } from "@rowsncolumns/spreadsheet";
+/**
+ * Excel-like style registry that mirrors Excel's XF (eXtended Format) architecture
+ */
+export declare class StyleRegistry {
+    private cellXfs;
+    private styleXfs;
+    private numFmts;
+    private fonts;
+    private fills;
+    private borders;
+    constructor();
+    /**
+     * Register a font and return its index
+     */
+    registerFont(font: TextFormat): number;
+    /**
+     * Register a fill and return its index
+     */
+    registerFill(fill: any): number;
+    /**
+     * Register a border and return its index
+     */
+    registerBorder(border: any): number;
+    /**
+     * Register a number format and return its index
+     */
+    registerNumberFormat(format: string): number;
+    /**
+     * Register a cell XF (format) and return its index
+     */
+    registerCellXf(format: CellFormat): number;
+    /**
+     * Get a cell XF by index
+     */
+    getCellXf(index: number): CellFormat;
+    /**
+     * Export the style registry
+     */
+    export(): {
+        cellXfs: CellFormat[];
+        styleXfs: CellFormat[];
+        numFmts: {
+            [k: string]: string;
+        };
+        fonts: TextFormat[];
+        fills: any[];
+        borders: any[];
+    };
+}
+//# sourceMappingURL=style-registry.d.ts.map

package/dist/cjs/excel-parser/style-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"style-registry.d.ts","sourceRoot":"","sources":["../../../excel-parser/style-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAExE;;GAEG;AACH,qBAAa,aAAa;IAExB,OAAO,CAAC,OAAO,CAAoB;IAGnC,OAAO,CAAC,QAAQ,CAAoB;IAGpC,OAAO,CAAC,OAAO,CAAkC;IAGjD,OAAO,CAAC,KAAK,CAAoB;IAGjC,OAAO,CAAC,KAAK,CAAa;IAG1B,OAAO,CAAC,OAAO,CAAa;;IAoB5B;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM;IActC;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,MAAM;IAc/B;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,GAAG,GAAG,MAAM;IAcnC;;OAEG;IACH,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAc5C;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM;IAsD1C;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU;IAMpC;;OAEG;IACH,MAAM;;;;;;;;;;CAUP"}

package/dist/cjs/excel-parser/style-registry.js

@@ -0,0 +1,175 @@
+import { __assign, __read, __values } from "tslib";
+/**
+ * Excel-like style registry that mirrors Excel's XF (eXtended Format) architecture
+ */
+var StyleRegistry = /** @class */ (function () {
+    function StyleRegistry() {
+        // Store style XF records (cell formats used directly by cells)
+        this.cellXfs = [];
+        // Store style XF records (named styles that can be applied to cells)
+        this.styleXfs = [];
+        // Store number formats
+        this.numFmts = new Map();
+        // Store fonts
+        this.fonts = [];
+        // Store fills (background colors)
+        this.fills = [];
+        // Store borders
+        this.borders = [];
+        // Initialize with default formats
+        this.cellXfs.push({}); // Default empty format at index 0
+        this.styleXfs.push({}); // Default empty style at index 0
+        this.fonts.push({}); // Default font at index 0
+        this.fills.push({ patternType: "none" }); // Default fill (none) at index 0
+        this.fills.push({ patternType: "gray125" }); // Default fill (gray125) at index 1
+        this.borders.push({}); // Default border (none) at index 0
+        // Standard number formats (0-49 are built-in in Excel)
+        this.numFmts.set(0, "General");
+        this.numFmts.set(1, "0");
+        this.numFmts.set(2, "0.00");
+        this.numFmts.set(3, "#,##0");
+        this.numFmts.set(4, "#,##0.00");
+        // And so on...
+    }
+    /**
+     * Register a font and return its index
+     */
+    StyleRegistry.prototype.registerFont = function (font) {
+        // Check if font already exists
+        var fontStr = JSON.stringify(font);
+        for (var i = 0; i < this.fonts.length; i++) {
+            if (JSON.stringify(this.fonts[i]) === fontStr) {
+                return i;
+            }
+        }
+        // Add new font
+        this.fonts.push(font);
+        return this.fonts.length - 1;
+    };
+    /**
+     * Register a fill and return its index
+     */
+    StyleRegistry.prototype.registerFill = function (fill) {
+        // Check if fill already exists
+        var fillStr = JSON.stringify(fill);
+        for (var i = 0; i < this.fills.length; i++) {
+            if (JSON.stringify(this.fills[i]) === fillStr) {
+                return i;
+            }
+        }
+        // Add new fill
+        this.fills.push(fill);
+        return this.fills.length - 1;
+    };
+    /**
+     * Register a border and return its index
+     */
+    StyleRegistry.prototype.registerBorder = function (border) {
+        // Check if border already exists
+        var borderStr = JSON.stringify(border);
+        for (var i = 0; i < this.borders.length; i++) {
+            if (JSON.stringify(this.borders[i]) === borderStr) {
+                return i;
+            }
+        }
+        // Add new border
+        this.borders.push(border);
+        return this.borders.length - 1;
+    };
+    /**
+     * Register a number format and return its index
+     */
+    StyleRegistry.prototype.registerNumberFormat = function (format) {
+        var e_1, _a;
+        try {
+            // Check if format already exists in built-in formats
+            for (var _b = __values(this.numFmts.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), id = _d[0], fmt = _d[1];
+                if (fmt === format) {
+                    return id;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        // Assign a new ID (starting from 164 as Excel does for custom formats)
+        var newId = 164 + (this.numFmts.size - 50); // 50 is the number of built-in formats
+        this.numFmts.set(newId, format);
+        return newId;
+    };
+    /**
+     * Register a cell XF (format) and return its index
+     */
+    StyleRegistry.prototype.registerCellXf = function (format) {
+        var _a;
+        // Extract components to register individually
+        var numFmtId = 0;
+        var fontId = 0;
+        var fillId = 0;
+        var borderId = 0;
+        // Register number format if present
+        if ((_a = format.numberFormat) === null || _a === void 0 ? void 0 : _a.pattern) {
+            numFmtId = this.registerNumberFormat(format.numberFormat.pattern);
+        }
+        // Register font if present
+        if (format.textFormat) {
+            fontId = this.registerFont(format.textFormat);
+        }
+        // Register fill if present
+        if (format.backgroundColor) {
+            fillId = this.registerFill({
+                patternType: "solid",
+                fgColor: format.backgroundColor,
+            });
+        }
+        // Register border if present
+        if (format.borders) {
+            borderId = this.registerBorder(format.borders);
+        }
+        // Create an XF record with references
+        var xfRecord = __assign(__assign({}, format), { _refs: {
+                numFmtId: numFmtId,
+                fontId: fontId,
+                fillId: fillId,
+                borderId: borderId,
+            } });
+        // Check if XF already exists
+        var xfStr = JSON.stringify(xfRecord);
+        for (var i = 0; i < this.cellXfs.length; i++) {
+            if (JSON.stringify(this.cellXfs[i]) === xfStr) {
+                return i;
+            }
+        }
+        // Add new XF
+        this.cellXfs.push(xfRecord);
+        return this.cellXfs.length - 1;
+    };
+    /**
+     * Get a cell XF by index
+     */
+    StyleRegistry.prototype.getCellXf = function (index) {
+        return index >= 0 && index < this.cellXfs.length
+            ? this.cellXfs[index]
+            : this.cellXfs[0];
+    };
+    /**
+     * Export the style registry
+     */
+    StyleRegistry.prototype.export = function () {
+        return {
+            cellXfs: this.cellXfs,
+            styleXfs: this.styleXfs,
+            numFmts: Object.fromEntries(this.numFmts),
+            fonts: this.fonts,
+            fills: this.fills,
+            borders: this.borders,
+        };
+    };
+    return StyleRegistry;
+}());
+export { StyleRegistry };

package/dist/cjs/excel-parser/theme-default.d.ts

@@ -0,0 +1,3 @@
+import type { SpreadsheetTheme } from "@rowsncolumns/spreadsheet";
+export declare const defaultSpreadsheetTheme: SpreadsheetTheme;
+//# sourceMappingURL=theme-default.d.ts.map

package/dist/cjs/excel-parser/theme-default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-default.d.ts","sourceRoot":"","sources":["../../../excel-parser/theme-default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAe,MAAM,2BAA2B,CAAC;AAgB/E,eAAO,MAAM,uBAAuB,EAAE,gBAKrC,CAAC"}