@cj-tech-master/excelts 4.2.3-canary.20260115111903.b80904d → 4.2.3-canary.20260122075539.cc11b20

package/dist/browser/modules/excel/xlsx/xform/pivot-table/pivot-table-xform.js

@@ -4,18 +4,30 @@ import { BaseXform } from "../base-xform.js";
 class PivotTableXform extends BaseXform {
     constructor() {
         super();
+        // Parser state consolidated into object for easier reset
+        this.state = {
+            inPivotFields: false,
+            inRowFields: false,
+            inColFields: false,
+            inDataFields: false,
+            inRowItems: false,
+            inColItems: false,
+            inLocation: false,
+            inItems: false,
+            inPivotTableStyleInfo: false,
+            inChartFormats: false,
+            inPivotArea: false
+        };
+        // Current parsing context
+        this.currentPivotField = null;
+        this.currentRowItem = null;
+        this.currentColItem = null;
+        this.currentChartFormat = null;
+        // Buffer for collecting pivotArea XML
+        this.pivotAreaXmlBuffer = [];
+        this.pivotAreaDepth = 0;
         this.map = {};
         this.model = null;
-        this.inPivotFields = false;
-        this.inRowFields = false;
-        this.inColFields = false;
-        this.inDataFields = false;
-        this.inRowItems = false;
-        this.inColItems = false;
-        this.inLocation = false;
-        this.currentPivotField = null;
-        this.inItems = false;
-        this.inPivotTableStyleInfo = false;
     }
     prepare(_model) {
         // No preparation needed
@@ -26,16 +38,17 @@ class PivotTableXform extends BaseXform {
     }
     reset() {
         this.model = null;
-        this.inPivotFields = false;
-        this.inRowFields = false;
-        this.inColFields = false;
-        this.inDataFields = false;
-        this.inRowItems = false;
-        this.inColItems = false;
-        this.inLocation = false;
+        // Reset all parser state flags using object
+        Object.keys(this.state).forEach(key => {
+            this.state[key] = false;
+        });
+        // Reset current context
         this.currentPivotField = null;
-        this.inItems = false;
-        this.inPivotTableStyleInfo = false;
+        this.currentRowItem = null;
+        this.currentColItem = null;
+        this.currentChartFormat = null;
+        this.pivotAreaXmlBuffer = [];
+        this.pivotAreaDepth = 0;
     }
     /**
      * Render pivot table XML.
@@ -156,8 +169,7 @@ class PivotTableXform extends BaseXform {
      * Render loaded pivot table (preserving original structure)
      */
     renderLoaded(xmlStream, model) {
-        xmlStream.openXml(XmlStream.StdDocAttributes);
-        xmlStream.openNode(this.tag, {
+        const attrs = {
             ...PivotTableXform.PIVOT_TABLE_ATTRIBUTES,
             name: model.name || "PivotTable1",
             cacheId: model.cacheId,
@@ -166,7 +178,8 @@ class PivotTableXform extends BaseXform {
             applyFontFormats: model.applyFontFormats || "0",
             applyPatternFormats: model.applyPatternFormats || "0",
             applyAlignmentFormats: model.applyAlignmentFormats || "0",
-            applyWidthHeightFormats: model.applyWidthHeightFormats || "0",
+            // Preserve original value when present; default to Excel's typical "0".
+            applyWidthHeightFormats: model.applyWidthHeightFormats ?? "0",
             dataCaption: model.dataCaption || "Values",
             updatedVersion: model.updatedVersion || "8",
             minRefreshableVersion: model.minRefreshableVersion || "3",
@@ -174,10 +187,27 @@ class PivotTableXform extends BaseXform {
             itemPrintTitles: model.itemPrintTitles ? "1" : "0",
             createdVersion: model.createdVersion || "8",
             indent: model.indent !== undefined ? String(model.indent) : "0",
-            compact: model.compact ? "1" : "0",
-            compactData: model.compactData ? "1" : "0",
             multipleFieldFilters: model.multipleFieldFilters ? "1" : "0"
-        });
+        };
+        // Add outline attributes if present
+        if (model.outline) {
+            attrs.outline = "1";
+        }
+        if (model.outlineData) {
+            attrs.outlineData = "1";
+        }
+        if (model.chartFormat !== undefined) {
+            attrs.chartFormat = String(model.chartFormat);
+        }
+        // Only add compact/compactData if they are true (some files don't have them)
+        if (model.compact) {
+            attrs.compact = "1";
+        }
+        if (model.compactData) {
+            attrs.compactData = "1";
+        }
+        xmlStream.openXml(XmlStream.StdDocAttributes);
+        xmlStream.openNode(this.tag, attrs);
         // Location
         if (model.location) {
             xmlStream.leafNode("location", {
@@ -203,12 +233,19 @@ class PivotTableXform extends BaseXform {
             }
             xmlStream.closeNode();
         }
-        // Row items (simplified - just grand total)
-        xmlStream.writeXml(`
-      <rowItems count="1">
-        <i t="grand"><x /></i>
-      </rowItems>`);
+        // Row items - use parsed items if available; otherwise emit a minimal grand total
+        if (model.rowItems && model.rowItems.length > 0) {
+            xmlStream.openNode("rowItems", { count: model.rowItems.length });
+            for (const item of model.rowItems) {
+                this.renderRowColItem(xmlStream, item);
+            }
+            xmlStream.closeNode();
+        }
+        else {
+            xmlStream.writeXml('<rowItems count="1"><i t="grand"><x/></i></rowItems>');
+        }
         // Col fields
+        // Excel commonly emits a synthetic field x=-2 when there are no column fields.
         const colFieldCount = model.colFields.length === 0 ? 1 : model.colFields.length;
         xmlStream.openNode("colFields", { count: colFieldCount });
         if (model.colFields.length === 0) {
@@ -220,25 +257,52 @@ class PivotTableXform extends BaseXform {
             }
         }
         xmlStream.closeNode();
-        // Col items (simplified - just grand total)
-        xmlStream.writeXml(`
-      <colItems count="1">
-        <i t="grand"><x /></i>
-      </colItems>`);
+        // Col items - use parsed items if available
+        if (model.colItems && model.colItems.length > 0) {
+            xmlStream.openNode("colItems", { count: model.colItems.length });
+            for (const item of model.colItems) {
+                this.renderRowColItem(xmlStream, item);
+            }
+            xmlStream.closeNode();
+        }
+        else {
+            xmlStream.writeXml('<colItems count="1"><i t="grand"><x/></i></colItems>');
+        }
         // Data fields
         if (model.dataFields.length > 0) {
             xmlStream.openNode("dataFields", { count: model.dataFields.length });
             for (const dataField of model.dataFields) {
-                const attrs = {
+                const dfAttrs = {
                     name: dataField.name,
                     fld: dataField.fld,
                     baseField: dataField.baseField ?? 0,
                     baseItem: dataField.baseItem ?? 0
                 };
                 if (dataField.subtotal && dataField.subtotal !== "sum") {
-                    attrs.subtotal = dataField.subtotal;
+                    dfAttrs.subtotal = dataField.subtotal;
+                }
+                xmlStream.leafNode("dataField", dfAttrs);
+            }
+            xmlStream.closeNode();
+        }
+        // Chart formats (for pivot charts) - preserve original pivotArea XML
+        if (model.chartFormats && model.chartFormats.length > 0) {
+            xmlStream.openNode("chartFormats", { count: model.chartFormats.length });
+            for (const cf of model.chartFormats) {
+                xmlStream.openNode("chartFormat", {
+                    chart: cf.chart,
+                    format: cf.format,
+                    series: cf.series ? "1" : undefined
+                });
+                // Use preserved pivotArea XML or fallback to default
+                if (cf.pivotAreaXml) {
+                    xmlStream.writeXml(cf.pivotAreaXml);
+                }
+                else {
+                    // Fallback for newly created chart formats (shouldn't happen for loaded models)
+                    xmlStream.writeXml(`<pivotArea type="data" outline="0" fieldPosition="0"><references count="1"><reference field="4294967294" count="1" selected="0"><x v="0"/></reference></references></pivotArea>`);
                 }
-                xmlStream.leafNode("dataField", attrs);
+                xmlStream.closeNode();
             }
             xmlStream.closeNode();
         }
@@ -252,46 +316,48 @@ class PivotTableXform extends BaseXform {
             showLastColumn: "1"
         });
         // Extensions
-        xmlStream.writeXml(`
-      <extLst>
-        <ext
-          uri="{962EF5D1-5CA2-4c93-8EF4-DBF5C05439D2}"
-          xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"
-        >
-          <x14:pivotTableDefinition
-            hideValuesRow="1"
-            xmlns:xm="http://schemas.microsoft.com/office/excel/2006/main"
-          />
-        </ext>
-        <ext
-          uri="{747A6164-185A-40DC-8AA5-F01512510D54}"
-          xmlns:xpdl="http://schemas.microsoft.com/office/spreadsheetml/2016/pivotdefaultlayout"
-        >
-          <xpdl:pivotTableDefinition16
-            EnabledSubtotalsDefault="0"
-            SubtotalsOnTopDefault="0"
-          />
-        </ext>
-      </extLst>
-    `);
+        xmlStream.writeXml(`<extLst><ext uri="{962EF5D1-5CA2-4c93-8EF4-DBF5C05439D2}" xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"><x14:pivotTableDefinition hideValuesRow="1" xmlns:xm="http://schemas.microsoft.com/office/excel/2006/main"/></ext><ext uri="{747A6164-185A-40DC-8AA5-F01512510D54}" xmlns:xpdl="http://schemas.microsoft.com/office/spreadsheetml/2016/pivotdefaultlayout"><xpdl:pivotTableDefinition16/></ext></extLst>`);
         xmlStream.closeNode();
     }
+    /**
+     * Render a row or column item element
+     */
+    renderRowColItem(xmlStream, item) {
+        const attrs = {};
+        if (item.t) {
+            attrs.t = item.t;
+        }
+        if (item.x && item.x.length > 0) {
+            xmlStream.openNode("i", attrs);
+            for (const x of item.x) {
+                if (x.v && x.v !== 0) {
+                    xmlStream.leafNode("x", { v: x.v });
+                }
+                else {
+                    xmlStream.leafNode("x");
+                }
+            }
+            xmlStream.closeNode();
+        }
+        else {
+            // Empty item (like <i/> in colItems)
+            xmlStream.leafNode("i", attrs);
+        }
+    }
     /**
      * Render a loaded pivot field
      */
     renderPivotFieldLoaded(xmlStream, field) {
-        const attrs = {
-            compact: field.compact ? "1" : "0",
-            outline: field.outline ? "1" : "0",
-            showAll: field.showAll ? "1" : "0",
-            defaultSubtotal: field.defaultSubtotal ? "1" : "0"
-        };
+        const attrs = {};
+        // Only add attributes that were present in the original
         if (field.axis) {
             attrs.axis = field.axis;
         }
         if (field.dataField) {
             attrs.dataField = "1";
         }
+        // showAll is typically always present
+        attrs.showAll = field.showAll ? "1" : "0";
         if (field.items && field.items.length > 0) {
             xmlStream.openNode("pivotField", attrs);
             xmlStream.openNode("items", { count: field.items.length + 1 });
@@ -299,7 +365,7 @@ class PivotTableXform extends BaseXform {
                 xmlStream.leafNode("item", { x: itemIndex });
             }
             // Grand total item
-            xmlStream.writeXml('<item t="default" />');
+            xmlStream.writeXml('<item t="default"/>');
             xmlStream.closeNode(); // items
             xmlStream.closeNode(); // pivotField
         }
@@ -337,6 +403,12 @@ class PivotTableXform extends BaseXform {
                     compact: attributes.compact === "1",
                     compactData: attributes.compactData === "1",
                     multipleFieldFilters: attributes.multipleFieldFilters === "1",
+                    outline: attributes.outline === "1",
+                    outlineData: attributes.outlineData === "1",
+                    chartFormat: attributes.chartFormat ? parseInt(attributes.chartFormat, 10) : undefined,
+                    rowItems: [],
+                    colItems: [],
+                    chartFormats: [],
                     isLoaded: true
                 };
                 break;
@@ -357,10 +429,10 @@ class PivotTableXform extends BaseXform {
                 }
                 break;
             case "pivotFields":
-                this.inPivotFields = true;
+                this.state.inPivotFields = true;
                 break;
             case "pivotField":
-                if (this.inPivotFields) {
+                if (this.state.inPivotFields) {
                     this.currentPivotField = {
                         axis: attributes.axis,
                         dataField: attributes.dataField === "1",
@@ -374,43 +446,101 @@ class PivotTableXform extends BaseXform {
                 break;
             case "items":
                 if (this.currentPivotField) {
-                    this.inItems = true;
+                    this.state.inItems = true;
                 }
                 break;
             case "item":
-                if (this.inItems && this.currentPivotField && attributes.x !== undefined) {
+                if (this.state.inItems && this.currentPivotField && attributes.x !== undefined) {
                     this.currentPivotField.items.push(parseInt(attributes.x, 10));
                 }
                 break;
             case "rowFields":
-                this.inRowFields = true;
+                this.state.inRowFields = true;
                 break;
             case "colFields":
-                this.inColFields = true;
+                this.state.inColFields = true;
                 break;
             case "dataFields":
-                this.inDataFields = true;
+                this.state.inDataFields = true;
                 break;
             case "rowItems":
-                this.inRowItems = true;
+                this.state.inRowItems = true;
                 break;
             case "colItems":
-                this.inColItems = true;
+                this.state.inColItems = true;
+                break;
+            case "i":
+                // Handle row/col item element
+                if (this.state.inRowItems && this.model) {
+                    this.currentRowItem = { t: attributes.t, x: [] };
+                }
+                else if (this.state.inColItems && this.model) {
+                    this.currentColItem = { t: attributes.t, x: [] };
+                }
+                break;
+            case "x":
+                // Handle x element inside row/col items or pivotArea
+                if (this.state.inPivotArea) {
+                    // Collect x element for pivotArea XML
+                    const xAttrs = Object.entries(attributes)
+                        .map(([k, v]) => `${k}="${v}"`)
+                        .join(" ");
+                    this.pivotAreaXmlBuffer.push(xAttrs ? `<x ${xAttrs}/>` : "<x/>");
+                }
+                else if (this.currentRowItem) {
+                    this.currentRowItem.x.push({ v: attributes.v ? parseInt(attributes.v, 10) : 0 });
+                }
+                else if (this.currentColItem) {
+                    this.currentColItem.x.push({ v: attributes.v ? parseInt(attributes.v, 10) : 0 });
+                }
+                break;
+            case "chartFormats":
+                this.state.inChartFormats = true;
+                break;
+            case "chartFormat":
+                if (this.state.inChartFormats && this.model) {
+                    this.currentChartFormat = {
+                        chart: attributes.chart ? parseInt(attributes.chart, 10) : 0,
+                        format: attributes.format ? parseInt(attributes.format, 10) : 0,
+                        series: attributes.series === "1"
+                    };
+                }
+                break;
+            case "pivotArea":
+                // Start collecting pivotArea XML for chartFormat
+                if (this.currentChartFormat) {
+                    this.state.inPivotArea = true;
+                    const attrsStr = Object.entries(attributes)
+                        .map(([k, v]) => `${k}="${v}"`)
+                        .join(" ");
+                    this.pivotAreaXmlBuffer = [attrsStr ? `<pivotArea ${attrsStr}>` : "<pivotArea>"];
+                }
+                break;
+            case "references":
+            case "reference":
+                // Collect nested elements in pivotArea
+                if (this.state.inPivotArea) {
+                    this.pivotAreaDepth++;
+                    const attrsStr = Object.entries(attributes)
+                        .map(([k, v]) => `${k}="${v}"`)
+                        .join(" ");
+                    this.pivotAreaXmlBuffer.push(`<${name}${attrsStr ? " " + attrsStr : ""}>`);
+                }
                 break;
             case "field":
                 // Handle field element (used in rowFields, colFields)
                 if (this.model) {
                     const fieldIndex = parseInt(attributes.x || "0", 10);
-                    if (this.inRowFields) {
+                    if (this.state.inRowFields) {
                         this.model.rowFields.push(fieldIndex);
                     }
-                    else if (this.inColFields) {
+                    else if (this.state.inColFields) {
                         this.model.colFields.push(fieldIndex);
                     }
                 }
                 break;
             case "dataField":
-                if (this.inDataFields && this.model) {
+                if (this.state.inDataFields && this.model) {
                     this.model.dataFields.push({
                         name: xmlDecode(attributes.name || ""),
                         fld: parseInt(attributes.fld || "0", 10),
@@ -432,12 +562,32 @@ class PivotTableXform extends BaseXform {
         // No text content in pivot table elements
     }
     parseClose(name) {
+        // Handle pivotArea nested elements - close tags
+        if (this.state.inPivotArea) {
+            if (name === "pivotArea") {
+                this.pivotAreaXmlBuffer.push("</pivotArea>");
+                if (this.currentChartFormat) {
+                    this.currentChartFormat.pivotAreaXml = this.pivotAreaXmlBuffer.join("");
+                }
+                this.state.inPivotArea = false;
+                this.pivotAreaXmlBuffer = [];
+                this.pivotAreaDepth = 0;
+                return true;
+            }
+            else if (name === "references" || name === "reference") {
+                this.pivotAreaXmlBuffer.push(`</${name}>`);
+                this.pivotAreaDepth--;
+                return true;
+            }
+            // x elements are self-closing, no need to handle close
+            return true;
+        }
         switch (name) {
             case this.tag:
                 // End of pivotTableDefinition
                 return false;
             case "pivotFields":
-                this.inPivotFields = false;
+                this.state.inPivotFields = false;
                 break;
             case "pivotField":
                 if (this.currentPivotField && this.model) {
@@ -446,22 +596,42 @@ class PivotTableXform extends BaseXform {
                 }
                 break;
             case "items":
-                this.inItems = false;
+                this.state.inItems = false;
                 break;
             case "rowFields":
-                this.inRowFields = false;
+                this.state.inRowFields = false;
                 break;
             case "colFields":
-                this.inColFields = false;
+                this.state.inColFields = false;
                 break;
             case "dataFields":
-                this.inDataFields = false;
+                this.state.inDataFields = false;
                 break;
             case "rowItems":
-                this.inRowItems = false;
+                this.state.inRowItems = false;
                 break;
             case "colItems":
-                this.inColItems = false;
+                this.state.inColItems = false;
+                break;
+            case "i":
+                // Finish row/col item
+                if (this.currentRowItem && this.model) {
+                    this.model.rowItems.push(this.currentRowItem);
+                    this.currentRowItem = null;
+                }
+                else if (this.currentColItem && this.model) {
+                    this.model.colItems.push(this.currentColItem);
+                    this.currentColItem = null;
+                }
+                break;
+            case "chartFormats":
+                this.state.inChartFormats = false;
+                break;
+            case "chartFormat":
+                if (this.currentChartFormat && this.model) {
+                    this.model.chartFormats.push(this.currentChartFormat);
+                    this.currentChartFormat = null;
+                }
                 break;
         }
         return true;

package/dist/browser/modules/excel/xlsx/xform/sheet/worksheet-xform.js

@@ -188,6 +188,23 @@ class WorkSheetXform extends BaseXform {
                 vmlDrawing: `vmlDrawing${model.id}`
             });
         }
+        // Handle pre-loaded drawing (from file read) that may contain charts or other non-image content
+        // This preserves drawings through round-trip even if they don't contain images
+        // Note: Always assign a new rId since rels are rebuilt during write
+        if (model.drawing && model.drawing.anchors) {
+            // This is a loaded drawing that needs to be added to relationships
+            const drawing = model.drawing;
+            drawing.rId = nextRid(rels);
+            if (!drawing.name) {
+                drawing.name = `drawing${++options.drawingsCount}`;
+            }
+            options.drawings.push(drawing);
+            rels.push({
+                Id: drawing.rId,
+                Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing",
+                Target: drawingRelTargetFromWorksheet(drawing.name)
+            });
+        }
         const drawingRelsHash = [];
         let bookImage;
         model.media.forEach(medium => {
@@ -599,17 +616,27 @@ class WorkSheetXform extends BaseXform {
             if (match) {
                 const drawingName = match[1];
                 const drawing = options.drawings[drawingName];
-                drawing.anchors.forEach(anchor => {
-                    if (anchor.medium) {
-                        const image = {
-                            type: "image",
-                            imageId: anchor.medium.index,
-                            range: anchor.range,
-                            hyperlinks: anchor.picture.hyperlinks
-                        };
-                        model.media.push(image);
-                    }
-                });
+                if (drawing) {
+                    // Preserve the drawing object for round-trip (charts, etc.)
+                    // This includes the name, anchors, and rels
+                    model.drawing = {
+                        ...drawing,
+                        name: drawingName,
+                        rels: options.drawingRels?.[drawingName] || drawing.rels || []
+                    };
+                    // Also extract images to model.media for backward compatibility
+                    drawing.anchors.forEach(anchor => {
+                        if (anchor.medium) {
+                            const image = {
+                                type: "image",
+                                imageId: anchor.medium.index,
+                                range: anchor.range,
+                                hyperlinks: anchor.picture.hyperlinks
+                            };
+                            model.media.push(image);
+                        }
+                    });
+                }
             }
         }
         const backgroundRel = model.background && rels[model.background.rId];

package/dist/browser/modules/excel/xlsx/xlsx.browser.d.ts

@@ -144,6 +144,30 @@ declare class XLSX {
      * This is the foundation for TRUE streaming reads on platforms that have a
      * streaming ZIP parser (e.g. Node.js `modules/archive` Parse).
      */
+    /**
+     * Create an empty model for parsing XLSX files.
+     * Shared by loadFromZipEntries and loadFromFiles.
+     */
+    private createEmptyModel;
+    /**
+     * Collect all data from a stream into a single Uint8Array.
+     * Reusable helper for passthrough and drawing processing.
+     */
+    protected collectStreamData(stream: IParseStream): Promise<Uint8Array>;
+    /**
+     * Check if a drawing has chart references in its relationships
+     */
+    private drawingHasChartReference;
+    /**
+     * Check if a drawing rels list references charts.
+     * Used to decide whether we need to keep raw drawing XML for passthrough.
+     */
+    private drawingRelsHasChartReference;
+    /**
+     * Process a known OOXML entry (workbook, styles, shared strings, etc.)
+     * Returns true if handled, false if should be passed to _processDefaultEntry
+     */
+    protected _processKnownEntry(stream: IParseStream, model: any, entryName: string, options?: XlsxOptions): Promise<boolean>;
     protected loadFromZipEntries(entries: AsyncIterable<ZipEntryLike>, options?: XlsxOptions): Promise<any>;
     /**
      * Write workbook to buffer
@@ -189,8 +213,14 @@ declare class XLSX {
     loadFromFiles(zipData: Record<string, Uint8Array>, options?: any): Promise<any>;
     /**
      * Process default entries (drawings, comments, tables, etc.)
+     * @param rawData Optional raw entry data for passthrough preservation (used by loadFromFiles)
      */
-    protected _processDefaultEntry(stream: IParseStream, model: any, entryName: string): Promise<boolean>;
+    protected _processDefaultEntry(stream: IParseStream, model: any, entryName: string, rawData?: Uint8Array): Promise<boolean>;
+    /**
+     * Store a passthrough file for preservation during read/write cycles.
+     * These files are not parsed but stored as raw bytes to be written back unchanged.
+     */
+    _processPassthroughEntry(stream: IParseStream, model: any, entryName: string): Promise<void>;
     addContentTypes(zip: IZipWriter, model: any): Promise<void>;
     addApp(zip: IZipWriter, model: any): Promise<void>;
     addCore(zip: IZipWriter, model: any): Promise<void>;
@@ -204,6 +234,11 @@ declare class XLSX {
     addWorksheets(zip: IZipWriter, model: any): Promise<void>;
     addDrawings(zip: IZipWriter, model: any): void;
     addTables(zip: IZipWriter, model: any): void;
+    /**
+     * Write passthrough files (charts, etc.) that were preserved during read.
+     * These files are written back unchanged to preserve unsupported features.
+     */
+    addPassthrough(zip: IZipWriter, model: any): void;
     addPivotTables(zip: IZipWriter, model: any): void;
     _finalize(zip: IZipWriter): Promise<this>;
     prepareModel(model: any, options: any): void;