sheetra 1.0.1 → 1.0.3

package/dist/index.js

@@ -404,6 +404,593 @@ class Worksheet {
     }
 }
 
+/**
+ * Minimal ZIP file creator for XLSX generation (no external dependencies)
+ * Uses STORE method (no compression) for simplicity and compatibility
+ */
+class ZipWriter {
+    constructor() {
+        this.files = [];
+        this.encoder = new TextEncoder();
+    }
+    addFile(name, content) {
+        this.files.push({
+            name,
+            data: this.encoder.encode(content)
+        });
+    }
+    generate() {
+        const localFiles = [];
+        const centralDirectory = [];
+        let offset = 0;
+        for (const file of this.files) {
+            const localHeader = this.createLocalFileHeader(file.name, file.data);
+            localFiles.push(localHeader);
+            localFiles.push(file.data);
+            const centralHeader = this.createCentralDirectoryHeader(file.name, file.data, offset);
+            centralDirectory.push(centralHeader);
+            offset += localHeader.length + file.data.length;
+        }
+        const centralDirStart = offset;
+        let centralDirSize = 0;
+        for (const header of centralDirectory) {
+            centralDirSize += header.length;
+        }
+        const endOfCentralDir = this.createEndOfCentralDirectory(this.files.length, centralDirSize, centralDirStart);
+        // Combine all parts
+        const totalSize = offset + centralDirSize + endOfCentralDir.length;
+        const result = new Uint8Array(totalSize);
+        let pos = 0;
+        for (const local of localFiles) {
+            result.set(local, pos);
+            pos += local.length;
+        }
+        for (const central of centralDirectory) {
+            result.set(central, pos);
+            pos += central.length;
+        }
+        result.set(endOfCentralDir, pos);
+        return result;
+    }
+    createLocalFileHeader(name, data) {
+        const nameBytes = this.encoder.encode(name);
+        const crc = this.crc32(data);
+        const header = new Uint8Array(30 + nameBytes.length);
+        const view = new DataView(header.buffer);
+        view.setUint32(0, 0x04034b50, true); // Local file header signature
+        view.setUint16(4, 20, true); // Version needed to extract
+        view.setUint16(6, 0, true); // General purpose bit flag
+        view.setUint16(8, 0, true); // Compression method (STORE)
+        view.setUint16(10, 0, true); // File last modification time
+        view.setUint16(12, 0, true); // File last modification date
+        view.setUint32(14, crc, true); // CRC-32
+        view.setUint32(18, data.length, true); // Compressed size
+        view.setUint32(22, data.length, true); // Uncompressed size
+        view.setUint16(26, nameBytes.length, true); // File name length
+        view.setUint16(28, 0, true); // Extra field length
+        header.set(nameBytes, 30);
+        return header;
+    }
+    createCentralDirectoryHeader(name, data, localHeaderOffset) {
+        const nameBytes = this.encoder.encode(name);
+        const crc = this.crc32(data);
+        const header = new Uint8Array(46 + nameBytes.length);
+        const view = new DataView(header.buffer);
+        view.setUint32(0, 0x02014b50, true); // Central directory file header signature
+        view.setUint16(4, 20, true); // Version made by
+        view.setUint16(6, 20, true); // Version needed to extract
+        view.setUint16(8, 0, true); // General purpose bit flag
+        view.setUint16(10, 0, true); // Compression method (STORE)
+        view.setUint16(12, 0, true); // File last modification time
+        view.setUint16(14, 0, true); // File last modification date
+        view.setUint32(16, crc, true); // CRC-32
+        view.setUint32(20, data.length, true); // Compressed size
+        view.setUint32(24, data.length, true); // Uncompressed size
+        view.setUint16(28, nameBytes.length, true); // File name length
+        view.setUint16(30, 0, true); // Extra field length
+        view.setUint16(32, 0, true); // File comment length
+        view.setUint16(34, 0, true); // Disk number start
+        view.setUint16(36, 0, true); // Internal file attributes
+        view.setUint32(38, 0, true); // External file attributes
+        view.setUint32(42, localHeaderOffset, true); // Relative offset of local header
+        header.set(nameBytes, 46);
+        return header;
+    }
+    createEndOfCentralDirectory(numFiles, centralDirSize, centralDirOffset) {
+        const header = new Uint8Array(22);
+        const view = new DataView(header.buffer);
+        view.setUint32(0, 0x06054b50, true); // End of central directory signature
+        view.setUint16(4, 0, true); // Number of this disk
+        view.setUint16(6, 0, true); // Disk where central directory starts
+        view.setUint16(8, numFiles, true); // Number of central directory records on this disk
+        view.setUint16(10, numFiles, true); // Total number of central directory records
+        view.setUint32(12, centralDirSize, true); // Size of central directory
+        view.setUint32(16, centralDirOffset, true); // Offset of start of central directory
+        view.setUint16(20, 0, true); // Comment length
+        return header;
+    }
+    crc32(data) {
+        let crc = 0xFFFFFFFF;
+        for (let i = 0; i < data.length; i++) {
+            crc ^= data[i];
+            for (let j = 0; j < 8; j++) {
+                crc = (crc >>> 1) ^ (crc & 1 ? 0xEDB88320 : 0);
+            }
+        }
+        return (crc ^ 0xFFFFFFFF) >>> 0;
+    }
+}
+class ExcelWriter {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static async write(workbook, _options) {
+        const zip = new ZipWriter();
+        const sheets = workbook['sheets'];
+        const sheetNames = sheets.map((sheet, index) => sheet.getName() || `Sheet${index + 1}`);
+        // Collect all styles from sheets
+        const styleRegistry = this.collectStyles(sheets);
+        // Add required XLSX files
+        zip.addFile('[Content_Types].xml', this.generateContentTypes(sheetNames));
+        zip.addFile('_rels/.rels', this.generateRels());
+        zip.addFile('xl/workbook.xml', this.generateWorkbook(sheetNames));
+        zip.addFile('xl/_rels/workbook.xml.rels', this.generateWorkbookRels(sheetNames));
+        zip.addFile('xl/styles.xml', this.generateStyles(styleRegistry));
+        zip.addFile('xl/sharedStrings.xml', this.generateSharedStrings(sheets));
+        // Add each worksheet
+        sheets.forEach((sheet, index) => {
+            zip.addFile(`xl/worksheets/sheet${index + 1}.xml`, this.generateWorksheet(sheet, styleRegistry));
+        });
+        const buffer = zip.generate();
+        return new Blob([buffer.buffer], {
+            type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+        });
+    }
+    /**
+     * Collect all unique styles from sheets
+     */
+    static collectStyles(sheets) {
+        const registry = {
+            fonts: new Map(),
+            fills: new Map(),
+            borders: new Map(),
+            cellXfs: new Map()
+        };
+        // Add default font (Calibri 11)
+        const defaultFont = this.serializeFont({});
+        registry.fonts.set(defaultFont, 0);
+        // Add required fills (none and gray125)
+        registry.fills.set('none', 0);
+        registry.fills.set('gray125', 1);
+        // Add default border
+        registry.borders.set('none', 0);
+        // Add default cellXf (no style)
+        registry.cellXfs.set('default', 0);
+        // Collect styles from all cells
+        sheets.forEach((sheet) => {
+            const rows = sheet.getRows();
+            rows.forEach((row) => {
+                row.getCells().forEach((cell) => {
+                    const cellData = cell.toData();
+                    if (cellData.style) {
+                        this.registerStyle(cellData.style, registry);
+                    }
+                });
+            });
+        });
+        return registry;
+    }
+    /**
+     * Register a style and get its cellXf index
+     */
+    static registerStyle(style, registry) {
+        var _a, _b, _c, _d;
+        // Serialize and register font
+        const fontKey = this.serializeFont(style);
+        if (!registry.fonts.has(fontKey)) {
+            registry.fonts.set(fontKey, registry.fonts.size);
+        }
+        // Serialize and register fill
+        const fillKey = this.serializeFill(style);
+        if (fillKey !== 'none' && !registry.fills.has(fillKey)) {
+            registry.fills.set(fillKey, registry.fills.size);
+        }
+        // Serialize and register border
+        const borderKey = this.serializeBorder(style);
+        if (borderKey !== 'none' && !registry.borders.has(borderKey)) {
+            registry.borders.set(borderKey, registry.borders.size);
+        }
+        // Create cellXf key
+        const fontIndex = (_a = registry.fonts.get(fontKey)) !== null && _a !== void 0 ? _a : 0;
+        const fillIndex = (_b = registry.fills.get(fillKey)) !== null && _b !== void 0 ? _b : 0;
+        const borderIndex = (_c = registry.borders.get(borderKey)) !== null && _c !== void 0 ? _c : 0;
+        let alignment = this.serializeAlignment(style);
+        if (!alignment)
+            alignment = '{}';
+        const xfKey = `f${fontIndex}:l${fillIndex}:b${borderIndex}:a${alignment}`;
+        if (!registry.cellXfs.has(xfKey)) {
+            registry.cellXfs.set(xfKey, registry.cellXfs.size);
+        }
+        return (_d = registry.cellXfs.get(xfKey)) !== null && _d !== void 0 ? _d : 0;
+    }
+    /**
+     * Get style index for a cell style
+     */
+    static getStyleIndex(style, registry) {
+        if (!style)
+            return 0;
+        return this.registerStyle(style, registry);
+    }
+    static serializeFont(style) {
+        var _a, _b, _c, _d, _e, _f;
+        const bold = style.bold || ((_a = style.font) === null || _a === void 0 ? void 0 : _a.bold);
+        const italic = style.italic || ((_b = style.font) === null || _b === void 0 ? void 0 : _b.italic);
+        const underline = style.underline || ((_c = style.font) === null || _c === void 0 ? void 0 : _c.underline);
+        const color = style.color || ((_d = style.font) === null || _d === void 0 ? void 0 : _d.color);
+        const size = style.fontSize || ((_e = style.font) === null || _e === void 0 ? void 0 : _e.size) || 11;
+        const name = style.fontFamily || ((_f = style.font) === null || _f === void 0 ? void 0 : _f.name) || 'Calibri';
+        return JSON.stringify({ bold, italic, underline, color, size, name });
+    }
+    static serializeFill(style) {
+        var _a;
+        const bgColor = style.backgroundColor || ((_a = style.fill) === null || _a === void 0 ? void 0 : _a.fgColor);
+        if (!bgColor)
+            return 'none';
+        return JSON.stringify({ bgColor });
+    }
+    static serializeBorder(style) {
+        if (!style.border && !style.borderAll)
+            return 'none';
+        return JSON.stringify({ border: style.border, borderAll: style.borderAll });
+    }
+    static serializeAlignment(style) {
+        const h = style.alignment;
+        const v = style.verticalAlignment;
+        const wrap = style.wrapText;
+        if (!h && !v && !wrap)
+            return '';
+        return JSON.stringify({ h, v, wrap });
+    }
+    static escapeXml(str) {
+        if (typeof str !== 'string')
+            return String(str !== null && str !== void 0 ? str : '');
+        return str
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&apos;');
+    }
+    static generateContentTypes(sheetNames) {
+        let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
+        xml += '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">';
+        xml += '<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>';
+        xml += '<Default Extension="xml" ContentType="application/xml"/>';
+        xml += '<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>';
+        xml += '<Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>';
+        xml += '<Override PartName="/xl/sharedStrings.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml"/>';
+        sheetNames.forEach((_, index) => {
+            xml += `<Override PartName="/xl/worksheets/sheet${index + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`;
+        });
+        xml += '</Types>';
+        return xml;
+    }
+    static generateRels() {
+        let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
+        xml += '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">';
+        xml += '<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>';
+        xml += '</Relationships>';
+        return xml;
+    }
+    static generateWorkbook(sheetNames) {
+        let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
+        xml += '<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">';
+        xml += '<sheets>';
+        sheetNames.forEach((name, index) => {
+            xml += `<sheet name="${this.escapeXml(name)}" sheetId="${index + 1}" r:id="rId${index + 1}"/>`;
+        });
+        xml += '</sheets>';
+        xml += '</workbook>';
+        return xml;
+    }
+    static generateWorkbookRels(sheetNames) {
+        let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
+        xml += '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">';
+        sheetNames.forEach((_, index) => {
+            xml += `<Relationship Id="rId${index + 1}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet${index + 1}.xml"/>`;
+        });
+        xml += `<Relationship Id="rId${sheetNames.length + 1}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>`;
+        xml += `<Relationship Id="rId${sheetNames.length + 2}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" Target="sharedStrings.xml"/>`;
+        xml += '</Relationships>';
+        return xml;
+    }
+    static generateStyles(registry) {
+        let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
+        xml += '<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">';
+        // Generate fonts
+        xml += `<fonts count="${registry.fonts.size}">`;
+        const fontEntries = Array.from(registry.fonts.entries()).sort((a, b) => a[1] - b[1]);
+        for (const [fontKey] of fontEntries) {
+            const font = JSON.parse(fontKey);
+            xml += '<font>';
+            if (font.bold)
+                xml += '<b/>';
+            if (font.italic)
+                xml += '<i/>';
+            if (font.underline)
+                xml += '<u/>';
+            xml += `<sz val="${font.size || 11}"/>`;
+            if (font.color) {
+                const colorHex = this.colorToARGB(font.color);
+                xml += `<color rgb="${colorHex}"/>`;
+            }
+            xml += `<name val="${font.name || 'Calibri'}"/>`;
+            xml += '</font>';
+        }
+        xml += '</fonts>';
+        // Generate fills
+        xml += `<fills count="${registry.fills.size}">`;
+        const fillEntries = Array.from(registry.fills.entries()).sort((a, b) => a[1] - b[1]);
+        for (const [fillKey] of fillEntries) {
+            if (fillKey === 'none') {
+                xml += '<fill><patternFill patternType="none"/></fill>';
+            }
+            else if (fillKey === 'gray125') {
+                xml += '<fill><patternFill patternType="gray125"/></fill>';
+            }
+            else {
+                const fill = JSON.parse(fillKey);
+                const colorHex = this.colorToARGB(fill.bgColor);
+                xml += `<fill><patternFill patternType="solid"><fgColor rgb="${colorHex}"/><bgColor indexed="64"/></patternFill></fill>`;
+            }
+        }
+        xml += '</fills>';
+        // Generate borders
+        xml += `<borders count="${registry.borders.size}">`;
+        const borderEntries = Array.from(registry.borders.entries()).sort((a, b) => a[1] - b[1]);
+        for (const [borderKey] of borderEntries) {
+            if (borderKey === 'none') {
+                xml += '<border><left/><right/><top/><bottom/><diagonal/></border>';
+            }
+            else {
+                const borderData = JSON.parse(borderKey);
+                xml += '<border>';
+                if (borderData.borderAll) {
+                    const style = borderData.borderAll.style || 'thin';
+                    const color = borderData.borderAll.color ? this.colorToARGB(borderData.borderAll.color) : 'FF000000';
+                    xml += `<left style="${style}"><color rgb="${color}"/></left>`;
+                    xml += `<right style="${style}"><color rgb="${color}"/></right>`;
+                    xml += `<top style="${style}"><color rgb="${color}"/></top>`;
+                    xml += `<bottom style="${style}"><color rgb="${color}"/></bottom>`;
+                }
+                else if (borderData.border) {
+                    const b = borderData.border;
+                    xml += this.generateBorderEdge('left', b.left);
+                    xml += this.generateBorderEdge('right', b.right);
+                    xml += this.generateBorderEdge('top', b.top);
+                    xml += this.generateBorderEdge('bottom', b.bottom);
+                }
+                xml += '<diagonal/></border>';
+            }
+        }
+        xml += '</borders>';
+        // Generate cellStyleXfs (base styles)
+        xml += '<cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs>';
+        // Generate cellXfs (cell formats)
+        xml += `<cellXfs count="${registry.cellXfs.size}">`;
+        const xfEntries = Array.from(registry.cellXfs.entries()).sort((a, b) => a[1] - b[1]);
+        for (const [xfKey] of xfEntries) {
+            if (xfKey === 'default') {
+                xml += '<xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>';
+            }
+            else {
+                // Parse xf key: f{fontIndex}:l{fillIndex}:b{borderIndex}:a{alignment}
+                const parts = xfKey.split(':');
+                const fontId = parseInt(parts[0].substring(1)) || 0;
+                const fillId = parseInt(parts[1].substring(1)) || 0;
+                const borderId = parseInt(parts[2].substring(1)) || 0;
+                const alignmentJson = parts[3].substring(1);
+                let xf = `<xf numFmtId="0" fontId="${fontId}" fillId="${fillId}" borderId="${borderId}" xfId="0"`;
+                if (fontId > 0)
+                    xf += ' applyFont="1"';
+                if (fillId > 0)
+                    xf += ' applyFill="1"';
+                if (borderId > 0)
+                    xf += ' applyBorder="1"';
+                let align = {};
+                if (alignmentJson && alignmentJson.trim().startsWith('{')) {
+                    try {
+                        align = JSON.parse(alignmentJson);
+                    }
+                    catch (e) {
+                        align = {};
+                    }
+                }
+                if (Object.keys(align).length > 0) {
+                    xf += ' applyAlignment="1">';
+                    xf += '<alignment';
+                    if (align.h)
+                        xf += ` horizontal="${align.h}"`;
+                    if (align.v)
+                        xf += ` vertical="${align.v === 'middle' ? 'center' : align.v}"`;
+                    if (align.wrap)
+                        xf += ' wrapText="1"';
+                    xf += '/></xf>';
+                }
+                else {
+                    xf += '/>';
+                }
+                xml += xf;
+            }
+        }
+        xml += '</cellXfs>';
+        xml += '</styleSheet>';
+        return xml;
+    }
+    static generateBorderEdge(side, edge) {
+        if (!edge || !edge.style)
+            return `<${side}/>`;
+        const color = edge.color ? this.colorToARGB(edge.color) : 'FF000000';
+        return `<${side} style="${edge.style}"><color rgb="${color}"/></${side}>`;
+    }
+    static colorToARGB(color) {
+        if (!color)
+            return 'FF000000';
+        // Remove # if present
+        let hex = color.replace('#', '').toUpperCase();
+        // Add alpha if not present (6 chars -> 8 chars)
+        if (hex.length === 6) {
+            hex = 'FF' + hex;
+        }
+        // Handle 3 char hex
+        if (hex.length === 3) {
+            hex = 'FF' + hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+        }
+        return hex;
+    }
+    static generateSharedStrings(sheets) {
+        const strings = [];
+        sheets.forEach((sheet) => {
+            const rows = sheet.getRows();
+            rows.forEach((row) => {
+                row.getCells().forEach((cell) => {
+                    const cellData = cell.toData();
+                    if (typeof cellData.value === 'string' && !cellData.formula) {
+                        if (!strings.includes(cellData.value)) {
+                            strings.push(cellData.value);
+                        }
+                    }
+                });
+            });
+        });
+        let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
+        xml += `<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="${strings.length}" uniqueCount="${strings.length}">`;
+        strings.forEach(str => {
+            xml += `<si><t>${this.escapeXml(str)}</t></si>`;
+        });
+        xml += '</sst>';
+        return xml;
+    }
+    static generateWorksheet(sheet, styleRegistry) {
+        const rows = sheet.getRows();
+        const columns = sheet.getColumns();
+        const allStrings = this.collectAllStrings(sheet);
+        let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
+        xml += '<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">';
+        // Add sheet dimension
+        const dimension = this.getSheetDimension(rows);
+        xml += `<dimension ref="${dimension}"/>`;
+        // Add column widths if defined
+        if (columns.length > 0) {
+            xml += '<cols>';
+            columns.forEach((col, index) => {
+                const colData = col.toData();
+                if (colData.width !== undefined && colData.width > 0) {
+                    // Excel width is in character units, convert from pixels: width / 7
+                    const excelWidth = colData.width / 7;
+                    xml += `<col min="${index + 1}" max="${index + 1}" width="${excelWidth}" customWidth="1"`;
+                    if (colData.hidden) {
+                        xml += ' hidden="1"';
+                    }
+                    xml += '/>';
+                }
+            });
+            xml += '</cols>';
+        }
+        xml += '<sheetData>';
+        rows.forEach((row, rowIndex) => {
+            const cells = row.getCells();
+            if (cells.length > 0) {
+                xml += `<row r="${rowIndex + 1}">`;
+                cells.forEach((cell, colIndex) => {
+                    const cellData = cell.toData();
+                    const cellRef = this.columnToLetter(colIndex + 1) + (rowIndex + 1);
+                    const styleIndex = this.getStyleIndex(cellData.style, styleRegistry);
+                    const styleAttr = styleIndex > 0 ? ` s="${styleIndex}"` : '';
+                    if (cellData.formula) {
+                        xml += `<c r="${cellRef}"${styleAttr}><f>${this.escapeXml(cellData.formula)}</f></c>`;
+                    }
+                    else if (cellData.value !== null && cellData.value !== undefined && cellData.value !== '') {
+                        if (typeof cellData.value === 'number') {
+                            xml += `<c r="${cellRef}"${styleAttr}><v>${cellData.value}</v></c>`;
+                        }
+                        else if (typeof cellData.value === 'boolean') {
+                            xml += `<c r="${cellRef}"${styleAttr} t="b"><v>${cellData.value ? 1 : 0}</v></c>`;
+                        }
+                        else if (cellData.type === 'date') {
+                            const excelDate = DateFormatter.toExcelDate(cellData.value);
+                            xml += `<c r="${cellRef}"${styleAttr}><v>${excelDate}</v></c>`;
+                        }
+                        else {
+                            // String value - use shared string index
+                            const stringIndex = allStrings.indexOf(String(cellData.value));
+                            if (stringIndex >= 0) {
+                                xml += `<c r="${cellRef}"${styleAttr} t="s"><v>${stringIndex}</v></c>`;
+                            }
+                            else {
+                                // Inline string as fallback
+                                xml += `<c r="${cellRef}"${styleAttr} t="inlineStr"><is><t>${this.escapeXml(String(cellData.value))}</t></is></c>`;
+                            }
+                        }
+                    }
+                    else if (styleIndex > 0) {
+                        // Empty cell with style
+                        xml += `<c r="${cellRef}"${styleAttr}/>`;
+                    }
+                });
+                xml += '</row>';
+            }
+        });
+        xml += '</sheetData>';
+        // Add merged cells if any
+        const sheetData = sheet.toData();
+        if (sheetData.mergeCells && sheetData.mergeCells.length > 0) {
+            xml += '<mergeCells>';
+            sheetData.mergeCells.forEach(merge => {
+                const startRef = this.columnToLetter(merge.startCol + 1) + (merge.startRow + 1);
+                const endRef = this.columnToLetter(merge.endCol + 1) + (merge.endRow + 1);
+                xml += `<mergeCell ref="${startRef}:${endRef}"/>`;
+            });
+            xml += '</mergeCells>';
+        }
+        xml += '</worksheet>';
+        return xml;
+    }
+    static collectAllStrings(sheet) {
+        const strings = [];
+        const rows = sheet.getRows();
+        rows.forEach((row) => {
+            row.getCells().forEach((cell) => {
+                const cellData = cell.toData();
+                if (typeof cellData.value === 'string' && !cellData.formula) {
+                    if (!strings.includes(cellData.value)) {
+                        strings.push(cellData.value);
+                    }
+                }
+            });
+        });
+        return strings;
+    }
+    static getSheetDimension(rows) {
+        if (rows.length === 0)
+            return 'A1';
+        let maxCol = 1;
+        rows.forEach(row => {
+            const cellCount = row.getCells().length;
+            if (cellCount > maxCol)
+                maxCol = cellCount;
+        });
+        return `A1:${this.columnToLetter(maxCol)}${rows.length}`;
+    }
+    static columnToLetter(column) {
+        let letters = '';
+        while (column > 0) {
+            const temp = (column - 1) % 26;
+            letters = String.fromCharCode(temp + 65) + letters;
+            column = Math.floor((column - temp - 1) / 26);
+        }
+        return letters || 'A';
+    }
+}
+
 class CSVWriter {
     static async write(workbook, _options) {
         const sheets = workbook['sheets'];
@@ -475,102 +1062,6 @@ class JSONWriter {
     }
 }
 
-class ExcelWriter {
-    static async write(workbook, _options) {
-        const data = this.generateExcelData(workbook);
-        const buffer = this.createExcelFile(data);
-        const uint8Buffer = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-        const arrayBuffer = uint8Buffer.slice().buffer;
-        return new Blob([arrayBuffer], { type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' });
-    }
-    static generateExcelData(workbook) {
-        const sheets = workbook['sheets'];
-        return {
-            Sheets: sheets.reduce((acc, sheet, index) => {
-                const sheetName = sheet.getName() || `Sheet${index + 1}`;
-                acc[sheetName] = this.generateSheetData(sheet);
-                return acc;
-            }, {}),
-            SheetNames: sheets.map((sheet, index) => sheet.getName() || `Sheet${index + 1}`)
-        };
-    }
-    static generateSheetData(sheet) {
-        const rows = sheet.getRows();
-        const data = [];
-        rows.forEach((row) => {
-            const rowData = [];
-            row.getCells().forEach((cell) => {
-                const cellData = cell.toData();
-                if (cellData.formula) {
-                    rowData.push({ f: cellData.formula });
-                }
-                else if (cellData.type === 'date' &&
-                    (typeof cellData.value === 'string' ||
-                        typeof cellData.value === 'number' ||
-                        cellData.value instanceof Date)) {
-                    rowData.push(DateFormatter.toExcelDate(cellData.value));
-                }
-                else {
-                    rowData.push(cellData.value);
-                }
-            });
-            data.push(rowData);
-        });
-        return {
-            '!ref': this.getSheetRange(data),
-            '!rows': rows.map(row => ({
-                hpt: row['height'],
-                hidden: row['hidden'],
-                outlineLevel: row['outlineLevel'],
-                collapsed: row['collapsed']
-            })),
-            '!cols': sheet.getColumns().map(col => ({
-                wch: col['width'],
-                hidden: col['hidden'],
-                outlineLevel: col['outlineLevel'],
-                collapsed: col['collapsed']
-            })),
-            '!merges': sheet['mergeCells'],
-            '!freeze': sheet['freezePane']
-        };
-    }
-    static getSheetRange(data) {
-        if (data.length === 0)
-            return 'A1:A1';
-        const lastRow = data.length;
-        const lastCol = Math.max(...data.map(row => row.length));
-        return `A1:${this.columnToLetter(lastCol)}${lastRow}`;
-    }
-    static columnToLetter(column) {
-        let letters = '';
-        while (column > 0) {
-            const temp = (column - 1) % 26;
-            letters = String.fromCharCode(temp + 65) + letters;
-            column = (column - temp - 1) / 26;
-        }
-        return letters || 'A';
-    }
-    static createExcelFile(data) {
-        // This is a simplified Excel file generator
-        // In a real implementation, you'd generate proper XLSX binary format
-        // For now, we'll return a simple XML-based structure
-        const xmlHeader = '<?xml version="1.0" encoding="UTF-8"?>';
-        const workbook = this.generateWorkbookXML(data);
-        const encoder = new TextEncoder();
-        return encoder.encode(xmlHeader + workbook);
-    }
-    static generateWorkbookXML(data) {
-        let xml = '<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">';
-        xml += '<sheets>';
-        data.SheetNames.forEach((name, index) => {
-            xml += `<sheet name="${name}" sheetId="${index + 1}" r:id="rId${index + 1}"/>`;
-        });
-        xml += '</sheets>';
-        xml += '</workbook>';
-        return xml;
-    }
-}
-
 class Workbook {
     constructor(data) {
         this.sheets = [];
@@ -828,6 +1319,55 @@ class ExportBuilder {
         });
         return this;
     }
+    /**
+     * Merge cells in the current worksheet
+     * @param startRow Start row index (0-based)
+     * @param startCol Start column index (0-based)
+     * @param endRow End row index (0-based)
+     * @param endCol End column index (0-based)
+     */
+    mergeCells(startRow, startCol, endRow, endCol) {
+        this.currentSheet.mergeCells(startRow, startCol, endRow, endCol);
+        return this;
+    }
+    /**
+     * Set alignment for a specific cell
+     * @param row Row index (0-based)
+     * @param col Column index (0-based)
+     * @param horizontal Horizontal alignment
+     * @param vertical Vertical alignment (optional)
+     */
+    setAlignment(row, col, horizontal, vertical) {
+        const rowObj = this.currentSheet.getRow(row);
+        if (rowObj) {
+            const cells = rowObj.getCells();
+            if (cells[col]) {
+                const style = StyleBuilder.create().align(horizontal);
+                if (vertical) {
+                    style.verticalAlign(vertical);
+                }
+                cells[col].setStyle(style.build());
+            }
+        }
+        return this;
+    }
+    /**
+     * Set alignment for a range of cells
+     * @param startRow Start row index (0-based)
+     * @param startCol Start column index (0-based)
+     * @param endRow End row index (0-based)
+     * @param endCol End column index (0-based)
+     * @param horizontal Horizontal alignment
+     * @param vertical Vertical alignment (optional)
+     */
+    setRangeAlignment(startRow, startCol, endRow, endCol, horizontal, vertical) {
+        for (let r = startRow; r <= endRow; r++) {
+            for (let c = startCol; c <= endCol; c++) {
+                this.setAlignment(r, c, horizontal, vertical);
+            }
+        }
+        return this;
+    }
     autoSizeColumns() {
         const rows = this.currentSheet.getRows();
         const maxLengths = [];
@@ -952,6 +1492,28 @@ class SheetBuilder {
         });
         return this;
     }
+    /**
+     * Set the width of a specific column
+     * @param colIndex Column index
+     * @param width Width to set
+     */
+    setColumnWidth(colIndex, width) {
+        const column = this.getOrCreateColumn(colIndex);
+        column.setWidth(width);
+        return this;
+    }
+    /**
+     * Set the height of a specific row
+     * @param rowIndex Row index
+     * @param height Height to set
+     */
+    setRowHeight(rowIndex, height) {
+        const row = this.worksheet.getRow(rowIndex);
+        if (row) {
+            row.setHeight(height);
+        }
+        return this;
+    }
     /**
      * Add a title row
      * @param title Title text