@rowsncolumns/toolkit 24.4.1

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

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

package/dist/esm/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/esm/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/esm/excel-parser/registry.js

@@ -0,0 +1,20 @@
+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 const PARSER_REGISTRY = {
+    xlsx: () => new XlsxPlugin(),
+    xlsm: () => new XlsmPlugin(),
+    xlsb: () => new XlsbPlugin(),
+    ods: () => new OdsPlugin(),
+};
+export function getPluginForFile(file) {
+    const fileName = typeof file === "string" ? file : file.name;
+    const extension = fileName.split(".").pop()?.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/esm/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/esm/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/esm/excel-parser/style-registry.js

@@ -0,0 +1,163 @@
+/**
+ * Excel-like style registry that mirrors Excel's XF (eXtended Format) architecture
+ */
+export class StyleRegistry {
+    // Store style XF records (cell formats used directly by cells)
+    cellXfs = [];
+    // Store style XF records (named styles that can be applied to cells)
+    styleXfs = [];
+    // Store number formats
+    numFmts = new Map();
+    // Store fonts
+    fonts = [];
+    // Store fills (background colors)
+    fills = [];
+    // Store borders
+    borders = [];
+    constructor() {
+        // 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
+     */
+    registerFont(font) {
+        // Check if font already exists
+        const fontStr = JSON.stringify(font);
+        for (let 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
+     */
+    registerFill(fill) {
+        // Check if fill already exists
+        const fillStr = JSON.stringify(fill);
+        for (let 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
+     */
+    registerBorder(border) {
+        // Check if border already exists
+        const borderStr = JSON.stringify(border);
+        for (let 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
+     */
+    registerNumberFormat(format) {
+        // Check if format already exists in built-in formats
+        for (const [id, fmt] of this.numFmts.entries()) {
+            if (fmt === format) {
+                return id;
+            }
+        }
+        // Assign a new ID (starting from 164 as Excel does for custom formats)
+        const 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
+     */
+    registerCellXf(format) {
+        // Extract components to register individually
+        let numFmtId = 0;
+        let fontId = 0;
+        let fillId = 0;
+        let borderId = 0;
+        // Register number format if present
+        if (format.numberFormat?.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
+        const xfRecord = {
+            ...format,
+            _refs: {
+                numFmtId,
+                fontId,
+                fillId,
+                borderId,
+            },
+        };
+        // Check if XF already exists
+        const xfStr = JSON.stringify(xfRecord);
+        for (let 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
+     */
+    getCellXf(index) {
+        return index >= 0 && index < this.cellXfs.length
+            ? this.cellXfs[index]
+            : this.cellXfs[0];
+    }
+    /**
+     * Export the style registry
+     */
+    export() {
+        return {
+            cellXfs: this.cellXfs,
+            styleXfs: this.styleXfs,
+            numFmts: Object.fromEntries(this.numFmts),
+            fonts: this.fonts,
+            fills: this.fills,
+            borders: this.borders,
+        };
+    }
+}

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

package/dist/esm/excel-parser/theme-default.js

@@ -0,0 +1,19 @@
+const lightColors = {
+    text1: "#000000",
+    background1: "#ffffff",
+    text2: "#44546A",
+    background2: "#E7E6E6",
+    accent1: "#5B9BD5",
+    accent2: "#ED7D31",
+    accent3: "#A5A5A5",
+    accent4: "#FFC000",
+    accent5: "#4472C4",
+    accent6: "#70AD47",
+    hyperlink: "#0563C1",
+};
+export const defaultSpreadsheetTheme = {
+    name: "Office",
+    primaryFontFamily: "Calibri",
+    themeColors: lightColors,
+    darkThemeColors: {},
+};