sheetra 1.0.2 → 1.0.4

package/dist/index.js

@@ -526,22 +526,129 @@ class ExcelWriter {
         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());
+        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));
+            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 : '');
@@ -595,17 +702,150 @@ class ExcelWriter {
         xml += '</Relationships>';
         return xml;
     }
-    static generateStyles() {
+    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">';
-        xml += '<fonts count="1"><font><sz val="11"/><name val="Calibri"/></font></fonts>';
-        xml += '<fills count="2"><fill><patternFill patternType="none"/></fill><fill><patternFill patternType="gray125"/></fill></fills>';
-        xml += '<borders count="1"><border><left/><right/><top/><bottom/><diagonal/></border></borders>';
+        // 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>';
-        xml += '<cellXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/></cellXfs>';
+        // 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) => {
@@ -629,14 +869,32 @@ class ExcelWriter {
         xml += '</sst>';
         return xml;
     }
-    static generateWorksheet(sheet) {
+    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();
@@ -645,37 +903,54 @@ class ExcelWriter {
                 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}"><f>${this.escapeXml(cellData.formula)}</f></c>`;
+                        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}"><v>${cellData.value}</v></c>`;
+                            xml += `<c r="${cellRef}"${styleAttr}><v>${cellData.value}</v></c>`;
                         }
                         else if (typeof cellData.value === 'boolean') {
-                            xml += `<c r="${cellRef}" t="b"><v>${cellData.value ? 1 : 0}</v></c>`;
+                            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}"><v>${excelDate}</v></c>`;
+                            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}" t="s"><v>${stringIndex}</v></c>`;
+                                xml += `<c r="${cellRef}"${styleAttr} t="s"><v>${stringIndex}</v></c>`;
                             }
                             else {
                                 // Inline string as fallback
-                                xml += `<c r="${cellRef}" t="inlineStr"><is><t>${this.escapeXml(String(cellData.value))}</t></is></c>`;
+                                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;
     }
@@ -969,23 +1244,46 @@ class ExportBuilder {
         });
         return this;
     }
-    addDataRows(data, fields) {
-        data.forEach(item => {
+    /**
+     * Add multiple data rows to the sheet
+     * @param data Array of row data
+     * @param fields Optional array of field names (for object data)
+     * @param styles Optional array of styles per row or per cell
+     */
+    addDataRows(data, fields, styles) {
+        data.forEach((item, rowIdx) => {
             const row = this.currentSheet.createRow();
+            let rowStyle = undefined;
+            let cellStyles = undefined;
+            if (styles && styles[rowIdx]) {
+                if (Array.isArray(styles[rowIdx])) {
+                    cellStyles = styles[rowIdx];
+                }
+                else {
+                    rowStyle = styles[rowIdx];
+                }
+            }
             if (fields && fields.length > 0) {
-                fields.forEach(field => {
+                fields.forEach((field, colIdx) => {
                     const value = this.getNestedValue(item, field);
-                    row.createCell(value);
+                    const style = cellStyles ? cellStyles[colIdx] : rowStyle;
+                    row.createCell(value, style);
                 });
             }
             else if (Array.isArray(item)) {
-                item.forEach(value => row.createCell(value));
+                item.forEach((value, colIdx) => {
+                    const style = cellStyles ? cellStyles[colIdx] : rowStyle;
+                    row.createCell(value, style);
+                });
             }
             else if (typeof item === 'object') {
-                Object.values(item).forEach(value => row.createCell(value));
+                Object.values(item).forEach((value, colIdx) => {
+                    const style = cellStyles ? cellStyles[colIdx] : rowStyle;
+                    row.createCell(value, style);
+                });
             }
             else {
-                row.createCell(item);
+                row.createCell(item, rowStyle);
             }
         });
         return this;
@@ -1044,6 +1342,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 = [];
@@ -1168,6 +1515,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