@cj-tech-master/excelts 1.5.0 → 1.6.1

package/dist/cjs/xlsx/xlsx.js

@@ -111,6 +111,8 @@ class XLSX {
         Object.values(model.tables).forEach((table) => {
             tableXform.reconcile(table, tableOptions);
         });
+        // Reconcile pivot tables - link pivot tables to worksheets and cache data
+        this._reconcilePivotTables(model);
         const sheetOptions = {
             styles: model.styles,
             sharedStrings: model.sharedStrings,
@@ -120,7 +122,8 @@ class XLSX {
             drawings: model.drawings,
             comments: model.comments,
             tables: model.tables,
-            vmlDrawings: model.vmlDrawings
+            vmlDrawings: model.vmlDrawings,
+            pivotTables: model.pivotTablesIndexed
         };
         model.worksheets.forEach((worksheet) => {
             worksheet.relationships = model.worksheetRels[worksheet.sheetNo];
@@ -138,6 +141,136 @@ class XLSX {
         delete model.drawings;
         delete model.drawingRels;
         delete model.vmlDrawings;
+        // Clean up raw pivot table data after reconciliation
+        delete model.pivotTableRels;
+        delete model.pivotCacheDefinitionRels;
+    }
+    /**
+     * Reconcile pivot tables by linking them to worksheets and their cache data.
+     * This builds a complete pivot table model ready for writing.
+     */
+    _reconcilePivotTables(model) {
+        // Skip if no pivot tables were loaded (object is empty or undefined)
+        const rawPivotTables = model.pivotTables || {};
+        if (typeof rawPivotTables !== "object" || Object.keys(rawPivotTables).length === 0) {
+            // Ensure pivotTables is an empty array (not an object)
+            model.pivotTables = [];
+            // Also create an empty indexed object for worksheet reconciliation
+            model.pivotTablesIndexed = {};
+            return;
+        }
+        // Build mapping from definition name to cacheId
+        const definitionToCacheId = this._buildDefinitionToCacheIdMap(model);
+        // Build a map of cache IDs to their definitions and records
+        const cacheMap = new Map();
+        // Process cache definitions
+        Object.entries(model.pivotCacheDefinitions || {}).forEach(([name, definition]) => {
+            // Get the cacheId from the mapping (derived from workbook.xml pivotCaches)
+            const cacheId = definitionToCacheId.get(name);
+            if (cacheId !== undefined) {
+                const recordsName = name.replace("Definition", "Records");
+                cacheMap.set(cacheId, {
+                    definition,
+                    records: model.pivotCacheRecords?.[recordsName],
+                    definitionName: name
+                });
+            }
+        });
+        // Process pivot tables and link to worksheets
+        const loadedPivotTables = [];
+        // Create indexed object for worksheet reconciliation (keyed by relative path)
+        const pivotTablesIndexed = {};
+        Object.entries(rawPivotTables).forEach(([pivotName, pivotTable]) => {
+            const pt = pivotTable;
+            const tableNumber = this._extractTableNumber(pivotName);
+            // Get cache data for this pivot table
+            const cacheData = cacheMap.get(pt.cacheId);
+            // Build complete pivot table model
+            const completePivotTable = {
+                // Core model data
+                ...pt,
+                tableNumber,
+                // Link to cache data
+                cacheDefinition: cacheData?.definition,
+                cacheRecords: cacheData?.records,
+                // Reconstruct cacheFields from definition for compatibility
+                cacheFields: cacheData?.definition?.cacheFields || [],
+                // Determine rows, columns, values from parsed data
+                rows: pt.rowFields.filter(f => f >= 0),
+                columns: pt.colFields.filter(f => f >= 0 && f !== -2),
+                values: pt.dataFields.map(df => df.fld),
+                // Determine metric from dataFields
+                metric: this._determineMetric(pt.dataFields),
+                // Preserve formatting options
+                applyWidthHeightFormats: pt.applyWidthHeightFormats || "0"
+            };
+            loadedPivotTables.push(completePivotTable);
+            // Index by relative path for worksheet reconciliation
+            pivotTablesIndexed[`../pivotTables/${pivotName}.xml`] = completePivotTable;
+        });
+        // Sort by table number to maintain order
+        loadedPivotTables.sort((a, b) => a.tableNumber - b.tableNumber);
+        // Replace pivotTables object with the processed array
+        // This is what the Workbook model setter expects
+        model.pivotTables = loadedPivotTables;
+        // Also keep indexed version for worksheet reconciliation
+        model.pivotTablesIndexed = pivotTablesIndexed;
+        // Also keep as loadedPivotTables for backward compatibility
+        model.loadedPivotTables = loadedPivotTables;
+    }
+    /**
+     * Extract table number from pivot table name (e.g., "pivotTable1" -> 1)
+     */
+    _extractTableNumber(name) {
+        const match = name.match(/pivotTable(\d+)/);
+        return match ? parseInt(match[1], 10) : 1;
+    }
+    /**
+     * Build a mapping from rId to cacheId using pivotCaches from workbook.xml
+     * and workbookRels to determine which definition file corresponds to which cacheId
+     */
+    _buildCacheIdMap(model) {
+        const rIdToCacheId = new Map();
+        // pivotCaches from workbook.xml contains {cacheId, rId} mappings
+        const pivotCaches = model.pivotCaches || [];
+        for (const cache of pivotCaches) {
+            if (cache.cacheId && cache.rId) {
+                rIdToCacheId.set(cache.rId, parseInt(cache.cacheId, 10));
+            }
+        }
+        return rIdToCacheId;
+    }
+    /**
+     * Build a mapping from definition name to cacheId
+     */
+    _buildDefinitionToCacheIdMap(model) {
+        const definitionToCacheId = new Map();
+        const rIdToCacheId = this._buildCacheIdMap(model);
+        const workbookRels = model.workbookRels || [];
+        // Map workbook rels to get definitionNumber -> cacheId mapping
+        for (const rel of workbookRels) {
+            if (rel.Type === XLSX.RelType.PivotCacheDefinition && rel.Target) {
+                // Extract definition number from target (e.g., "pivotCache/pivotCacheDefinition1.xml" -> 1)
+                const match = rel.Target.match(/pivotCacheDefinition(\d+)\.xml/);
+                if (match) {
+                    const defName = `pivotCacheDefinition${match[1]}`;
+                    const cacheId = rIdToCacheId.get(rel.Id);
+                    if (cacheId !== undefined) {
+                        definitionToCacheId.set(defName, cacheId);
+                    }
+                }
+            }
+        }
+        return definitionToCacheId;
+    }
+    /**
+     * Determine the aggregation metric from dataFields
+     */
+    _determineMetric(dataFields) {
+        if (dataFields.length > 0 && dataFields[0].subtotal === "count") {
+            return "count";
+        }
+        return "sum";
     }
     async _processWorksheetEntry(stream, model, sheetNo, options, path) {
         const xform = new worksheet_xform_js_1.WorkSheetXform(options);
@@ -240,6 +373,37 @@ class XLSX {
             stream.pipe(streamBuf);
         });
     }
+    async _processPivotTableEntry(stream, model, name) {
+        const xform = new pivot_table_xform_js_1.PivotTableXform();
+        const pivotTable = await xform.parseStream(stream);
+        if (pivotTable) {
+            model.pivotTables[name] = pivotTable;
+        }
+    }
+    async _processPivotTableRelsEntry(stream, model, name) {
+        const xform = new relationships_xform_js_1.RelationshipsXform();
+        const relationships = await xform.parseStream(stream);
+        model.pivotTableRels[name] = relationships;
+    }
+    async _processPivotCacheDefinitionEntry(stream, model, name) {
+        const xform = new pivot_cache_definition_xform_js_1.PivotCacheDefinitionXform();
+        const cacheDefinition = await xform.parseStream(stream);
+        if (cacheDefinition) {
+            model.pivotCacheDefinitions[name] = cacheDefinition;
+        }
+    }
+    async _processPivotCacheDefinitionRelsEntry(stream, model, name) {
+        const xform = new relationships_xform_js_1.RelationshipsXform();
+        const relationships = await xform.parseStream(stream);
+        model.pivotCacheDefinitionRels[name] = relationships;
+    }
+    async _processPivotCacheRecordsEntry(stream, model, name) {
+        const xform = new pivot_cache_records_xform_js_1.PivotCacheRecordsXform();
+        const cacheRecords = await xform.parseStream(stream);
+        if (cacheRecords) {
+            model.pivotCacheRecords[name] = cacheRecords;
+        }
+    }
     async read(stream, options) {
         // Use streaming unzip with fflate
         const allFiles = {};
@@ -349,7 +513,13 @@ class XLSX {
             drawingRels: {},
             comments: {},
             tables: {},
-            vmlDrawings: {}
+            vmlDrawings: {},
+            // Pivot table storage for loaded files
+            pivotTables: {},
+            pivotTableRels: {},
+            pivotCacheDefinitions: {},
+            pivotCacheDefinitionRels: {},
+            pivotCacheRecords: {}
         };
         // Convert fflate format to JSZip-like structure for compatibility
         const entries = Object.keys(zipData).map(name => ({
@@ -397,6 +567,9 @@ class XLSX {
                             model.views = workbook.views;
                             model.properties = workbook.properties;
                             model.calcProperties = workbook.calcProperties;
+                            // pivotCaches contains the mapping from rId to cacheId
+                            // needed for linking pivot tables to their cache data
+                            model.pivotCaches = workbook.pivotCaches;
                             break;
                         }
                         case "xl/sharedStrings.xml":
@@ -465,6 +638,33 @@ class XLSX {
                                 await this._processThemeEntry(stream, model, match[1]);
                                 break;
                             }
+                            // Pivot table files
+                            match = entryName.match(/xl\/pivotTables\/(pivotTable\d+)[.]xml/);
+                            if (match) {
+                                await this._processPivotTableEntry(stream, model, match[1]);
+                                break;
+                            }
+                            match = entryName.match(/xl\/pivotTables\/_rels\/(pivotTable\d+)[.]xml[.]rels/);
+                            if (match) {
+                                await this._processPivotTableRelsEntry(stream, model, match[1]);
+                                break;
+                            }
+                            // Pivot cache files
+                            match = entryName.match(/xl\/pivotCache\/(pivotCacheDefinition\d+)[.]xml/);
+                            if (match) {
+                                await this._processPivotCacheDefinitionEntry(stream, model, match[1]);
+                                break;
+                            }
+                            match = entryName.match(/xl\/pivotCache\/_rels\/(pivotCacheDefinition\d+)[.]xml[.]rels/);
+                            if (match) {
+                                await this._processPivotCacheDefinitionRelsEntry(stream, model, match[1]);
+                                break;
+                            }
+                            match = entryName.match(/xl\/pivotCache\/(pivotCacheRecords\d+)[.]xml/);
+                            if (match) {
+                                await this._processPivotCacheRecordsEntry(stream, model, match[1]);
+                                break;
+                            }
                         }
                     }
                 }
@@ -521,21 +721,24 @@ class XLSX {
                 Target: "sharedStrings.xml"
             });
         }
-        if ((model.pivotTables || []).length) {
-            const pivotTable = model.pivotTables[0];
+        // Add relationships for all pivot tables
+        (model.pivotTables || []).forEach((pivotTable) => {
             pivotTable.rId = `rId${count++}`;
             relationships.push({
                 Id: pivotTable.rId,
                 Type: XLSX.RelType.PivotCacheDefinition,
-                Target: "pivotCache/pivotCacheDefinition1.xml"
+                Target: `pivotCache/pivotCacheDefinition${pivotTable.tableNumber}.xml`
             });
-        }
-        model.worksheets.forEach((worksheet) => {
+        });
+        model.worksheets.forEach((worksheet, index) => {
+            // Use sequential index (1-based) for file naming, not worksheet.id (sheetId)
+            // sheetId can be non-sequential (e.g., 1, 3, 5) which would create gaps in filenames
             worksheet.rId = `rId${count++}`;
+            worksheet.fileIndex = index + 1; // Store for use in addWorksheets and content types
             relationships.push({
                 Id: worksheet.rId,
                 Type: XLSX.RelType.Worksheet,
-                Target: `worksheets/sheet${worksheet.id}.xml`
+                Target: `worksheets/sheet${worksheet.fileIndex}.xml`
             });
         });
         const xform = new relationships_xform_js_1.RelationshipsXform();
@@ -564,22 +767,24 @@ class XLSX {
         const commentsXform = new comments_xform_js_1.CommentsXform();
         const vmlNotesXform = new vml_notes_xform_js_1.VmlNotesXform();
         // write sheets
-        model.worksheets.forEach((worksheet) => {
+        model.worksheets.forEach((worksheet, index) => {
+            // Use fileIndex if set by addWorkbookRels, otherwise use index + 1
+            const fileIndex = worksheet.fileIndex || index + 1;
             let xmlStream = new xml_stream_js_1.XmlStream();
             worksheetXform.render(xmlStream, worksheet);
-            zip.append(xmlStream.xml, { name: `xl/worksheets/sheet${worksheet.id}.xml` });
+            zip.append(xmlStream.xml, { name: `xl/worksheets/sheet${fileIndex}.xml` });
             if (worksheet.rels && worksheet.rels.length) {
                 xmlStream = new xml_stream_js_1.XmlStream();
                 relationshipsXform.render(xmlStream, worksheet.rels);
-                zip.append(xmlStream.xml, { name: `xl/worksheets/_rels/sheet${worksheet.id}.xml.rels` });
+                zip.append(xmlStream.xml, { name: `xl/worksheets/_rels/sheet${fileIndex}.xml.rels` });
             }
             if (worksheet.comments.length > 0) {
                 xmlStream = new xml_stream_js_1.XmlStream();
                 commentsXform.render(xmlStream, worksheet);
-                zip.append(xmlStream.xml, { name: `xl/comments${worksheet.id}.xml` });
+                zip.append(xmlStream.xml, { name: `xl/comments${fileIndex}.xml` });
                 xmlStream = new xml_stream_js_1.XmlStream();
                 vmlNotesXform.render(xmlStream, worksheet);
-                zip.append(xmlStream.xml, { name: `xl/drawings/vmlDrawing${worksheet.id}.vml` });
+                zip.append(xmlStream.xml, { name: `xl/drawings/vmlDrawing${fileIndex}.vml` });
             }
         });
     }
@@ -632,37 +837,55 @@ class XLSX {
         if (!model.pivotTables.length) {
             return;
         }
-        const pivotTable = model.pivotTables[0];
         const pivotCacheRecordsXform = new pivot_cache_records_xform_js_1.PivotCacheRecordsXform();
         const pivotCacheDefinitionXform = new pivot_cache_definition_xform_js_1.PivotCacheDefinitionXform();
         const pivotTableXform = new pivot_table_xform_js_1.PivotTableXform();
         const relsXform = new relationships_xform_js_1.RelationshipsXform();
-        // pivot cache records
-        let xml = pivotCacheRecordsXform.toXml(pivotTable);
-        zip.append(xml, { name: "xl/pivotCache/pivotCacheRecords1.xml" });
-        // pivot cache definition
-        xml = pivotCacheDefinitionXform.toXml(pivotTable);
-        zip.append(xml, { name: "xl/pivotCache/pivotCacheDefinition1.xml" });
-        // pivot cache definition rels
-        xml = relsXform.toXml([
-            {
-                Id: "rId1",
-                Type: XLSX.RelType.PivotCacheRecords,
-                Target: "pivotCacheRecords1.xml"
+        // Generate files for each pivot table
+        model.pivotTables.forEach((pivotTable) => {
+            const n = pivotTable.tableNumber;
+            // For loaded pivot tables, use the stored cache data
+            // For new pivot tables, use the source data
+            const isLoaded = pivotTable.isLoaded;
+            if (isLoaded) {
+                // Loaded pivot table - use stored cache definition and records
+                if (pivotTable.cacheDefinition) {
+                    const xml = pivotCacheDefinitionXform.toXml(pivotTable.cacheDefinition);
+                    zip.append(xml, { name: `xl/pivotCache/pivotCacheDefinition${n}.xml` });
+                }
+                if (pivotTable.cacheRecords) {
+                    const xml = pivotCacheRecordsXform.toXml(pivotTable.cacheRecords);
+                    zip.append(xml, { name: `xl/pivotCache/pivotCacheRecords${n}.xml` });
+                }
             }
-        ]);
-        zip.append(xml, { name: "xl/pivotCache/_rels/pivotCacheDefinition1.xml.rels" });
-        // pivot table
-        xml = pivotTableXform.toXml(pivotTable);
-        zip.append(xml, { name: "xl/pivotTables/pivotTable1.xml" });
-        xml = relsXform.toXml([
-            {
-                Id: "rId1",
-                Type: XLSX.RelType.PivotCacheDefinition,
-                Target: "../pivotCache/pivotCacheDefinition1.xml"
+            else {
+                // New pivot table - generate from source
+                let xml = pivotCacheRecordsXform.toXml(pivotTable);
+                zip.append(xml, { name: `xl/pivotCache/pivotCacheRecords${n}.xml` });
+                xml = pivotCacheDefinitionXform.toXml(pivotTable);
+                zip.append(xml, { name: `xl/pivotCache/pivotCacheDefinition${n}.xml` });
             }
-        ]);
-        zip.append(xml, { name: "xl/pivotTables/_rels/pivotTable1.xml.rels" });
+            // pivot cache definition rels (same for both)
+            let xml = relsXform.toXml([
+                {
+                    Id: "rId1",
+                    Type: XLSX.RelType.PivotCacheRecords,
+                    Target: `pivotCacheRecords${n}.xml`
+                }
+            ]);
+            zip.append(xml, { name: `xl/pivotCache/_rels/pivotCacheDefinition${n}.xml.rels` });
+            // pivot table
+            xml = pivotTableXform.toXml(pivotTable);
+            zip.append(xml, { name: `xl/pivotTables/pivotTable${n}.xml` });
+            xml = relsXform.toXml([
+                {
+                    Id: "rId1",
+                    Type: XLSX.RelType.PivotCacheDefinition,
+                    Target: `../pivotCache/pivotCacheDefinition${n}.xml`
+                }
+            ]);
+            zip.append(xml, { name: `xl/pivotTables/_rels/pivotTable${n}.xml.rels` });
+        });
     }
     _finalize(zip) {
         return new Promise((resolve, reject) => {

package/dist/esm/doc/column.js

@@ -64,6 +64,9 @@ class Column {
             this.outlineLevel = 0;
         }
     }
+    /**
+     * Get header values as an array (for multi-row header support)
+     */
     get headers() {
         if (Array.isArray(this._header)) {
             return this._header;
@@ -74,7 +77,8 @@ class Column {
         return [];
     }
     /**
-     * Can be a string to set one row high header or an array to set multi-row high header
+     * Can be a single value or an array for multi-row headers.
+     * Supports any CellValue type including Date, number, string, etc.
      */
     get header() {
         return this._header;
@@ -82,8 +86,8 @@ class Column {
     set header(value) {
         if (value !== undefined) {
             this._header = value;
-            this.headers.forEach((text, index) => {
-                this._worksheet.getCell(index + 1, this.number).value = text;
+            this.headers.forEach((cellValue, index) => {
+                this._worksheet.getCell(index + 1, this.number).value = cellValue;
             });
         }
         else {