@cj-tech-master/excelts 4.2.3 → 5.0.0-canary.20260123012457.1fdf506

package/dist/browser/modules/excel/xlsx/xlsx.browser.js

@@ -34,6 +34,7 @@ import { StreamingZip, ZipDeflateFile } from "../../archive/zip/stream.js";
 import { ZipParser } from "../../archive/unzip/zip-parser.js";
 import { PassThrough, concatUint8Arrays } from "../../stream/index.browser.js";
 import { commentsPath, commentsRelTargetFromWorksheetName, ctrlPropPath, drawingPath, drawingRelsPath, OOXML_REL_TARGETS, pivotTableRelTargetFromWorksheetName, pivotCacheDefinitionRelTargetFromWorkbook, getCommentsIndexFromPath, getDrawingNameFromPath, getDrawingNameFromRelsPath, getMediaFilenameFromPath, mediaPath, getPivotCacheDefinitionNameFromPath, getPivotCacheDefinitionNameFromRelsPath, getPivotCacheRecordsNameFromPath, getPivotTableNameFromPath, getPivotTableNameFromRelsPath, pivotCacheDefinitionPath, pivotCacheDefinitionRelsPath, pivotCacheDefinitionRelTargetFromPivotTable, pivotCacheRecordsPath, pivotCacheRecordsRelTarget, pivotTablePath, pivotTableRelsPath, getTableNameFromPath, tablePath, tableRelTargetFromWorksheetName, themePath, getThemeNameFromPath, getVmlDrawingNameFromPath, getWorksheetNoFromWorksheetPath, getWorksheetNoFromWorksheetRelsPath, isBinaryEntryPath, normalizeZipPath, OOXML_PATHS, vmlDrawingRelTargetFromWorksheetName, vmlDrawingPath, worksheetPath, worksheetRelsPath } from "../utils/ooxml-paths.js";
+import { PassthroughManager } from "../utils/passthrough-manager.js";
 class StreamingZipWriterAdapter {
     constructor(options) {
         this.events = new Map();
@@ -201,6 +202,7 @@ class XLSX {
         this.addDrawings(zip, model);
         this.addTables(zip, model);
         this.addPivotTables(zip, model);
+        this.addPassthrough(zip, model);
         await Promise.all([this.addThemes(zip, model), this.addStyles(zip, model)]);
         await this.addFeaturePropertyBag(zip, model);
         await this.addMedia(zip, model);
@@ -300,8 +302,12 @@ 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).
      */
-    async loadFromZipEntries(entries, options) {
-        const model = {
+    /**
+     * Create an empty model for parsing XLSX files.
+     * Shared by loadFromZipEntries and loadFromFiles.
+     */
+    createEmptyModel() {
+        return {
             worksheets: [],
             worksheetHash: {},
             worksheetRels: [],
@@ -310,6 +316,8 @@ class XLSX {
             mediaIndex: {},
             drawings: {},
             drawingRels: {},
+            // Raw drawing XML data for passthrough (when drawing contains chart references)
+            rawDrawings: {},
             comments: {},
             tables: {},
             vmlDrawings: {},
@@ -317,8 +325,104 @@ class XLSX {
             pivotTableRels: {},
             pivotCacheDefinitions: {},
             pivotCacheDefinitionRels: {},
-            pivotCacheRecords: {}
+            pivotCacheRecords: {},
+            // Passthrough storage for unknown/unsupported files (charts, etc.)
+            passthrough: {}
         };
+    }
+    /**
+     * Collect all data from a stream into a single Uint8Array.
+     * Reusable helper for passthrough and drawing processing.
+     */
+    async collectStreamData(stream) {
+        const chunks = [];
+        await new Promise((resolve, reject) => {
+            stream.on("data", (chunk) => {
+                if (typeof chunk === "string") {
+                    chunks.push(new TextEncoder().encode(chunk));
+                }
+                else if (chunk instanceof Uint8Array) {
+                    chunks.push(chunk);
+                }
+                else {
+                    chunks.push(new Uint8Array(chunk));
+                }
+            });
+            stream.on("end", () => resolve());
+            stream.on("error", reject);
+        });
+        return concatUint8Arrays(chunks);
+    }
+    /**
+     * Check if a drawing has chart references in its relationships
+     */
+    drawingHasChartReference(drawing) {
+        return (drawing.rels && drawing.rels.some((rel) => rel.Target && rel.Target.includes("/charts/")));
+    }
+    /**
+     * Check if a drawing rels list references charts.
+     * Used to decide whether we need to keep raw drawing XML for passthrough.
+     */
+    drawingRelsHasChartReference(drawingRels) {
+        return (Array.isArray(drawingRels) &&
+            drawingRels.some(rel => typeof rel?.Target === "string" && rel.Target.includes("/charts/")));
+    }
+    /**
+     * Process a known OOXML entry (workbook, styles, shared strings, etc.)
+     * Returns true if handled, false if should be passed to _processDefaultEntry
+     */
+    async _processKnownEntry(stream, model, entryName, options) {
+        const sheetNo = getWorksheetNoFromWorksheetPath(entryName);
+        if (sheetNo !== undefined) {
+            await this._processWorksheetEntry(stream, model, sheetNo, options, entryName);
+            return true;
+        }
+        switch (entryName) {
+            case OOXML_PATHS.rootRels:
+                model.globalRels = await this.parseRels(stream);
+                return true;
+            case OOXML_PATHS.xlWorkbook: {
+                const workbook = await this.parseWorkbook(stream);
+                model.sheets = workbook.sheets;
+                model.definedNames = workbook.definedNames;
+                model.views = workbook.views;
+                model.properties = workbook.properties;
+                model.calcProperties = workbook.calcProperties;
+                model.pivotCaches = workbook.pivotCaches;
+                return true;
+            }
+            case OOXML_PATHS.xlSharedStrings:
+                model.sharedStrings = new SharedStringsXform();
+                await model.sharedStrings.parseStream(stream);
+                return true;
+            case OOXML_PATHS.xlWorkbookRels:
+                model.workbookRels = await this.parseRels(stream);
+                return true;
+            case OOXML_PATHS.docPropsApp: {
+                const appXform = new AppXform();
+                const appProperties = await appXform.parseStream(stream);
+                if (appProperties) {
+                    model.company = appProperties.company;
+                    model.manager = appProperties.manager;
+                }
+                return true;
+            }
+            case OOXML_PATHS.docPropsCore: {
+                const coreXform = new CoreXform();
+                const coreProperties = await coreXform.parseStream(stream);
+                Object.assign(model, coreProperties);
+                return true;
+            }
+            case OOXML_PATHS.xlStyles:
+                model.styles = new StylesXform();
+                await model.styles.parseStream(stream);
+                return true;
+            default:
+                return false;
+        }
+    }
+    async loadFromZipEntries(entries, options) {
+        const model = this.createEmptyModel();
         for await (const entry of entries) {
             let drained = false;
             const drainEntry = async () => {
@@ -335,58 +439,12 @@ class XLSX {
             const entryName = normalizeZipPath(entry.name);
             const stream = entry.stream;
             try {
-                const sheetNo = getWorksheetNoFromWorksheetPath(entryName);
-                if (sheetNo !== undefined) {
-                    await this._processWorksheetEntry(stream, model, sheetNo, options, entryName);
-                    continue;
-                }
-                switch (entryName) {
-                    case OOXML_PATHS.rootRels:
-                        model.globalRels = await this.parseRels(stream);
-                        break;
-                    case OOXML_PATHS.xlWorkbook: {
-                        const workbook = await this.parseWorkbook(stream);
-                        model.sheets = workbook.sheets;
-                        model.definedNames = workbook.definedNames;
-                        model.views = workbook.views;
-                        model.properties = workbook.properties;
-                        model.calcProperties = workbook.calcProperties;
-                        model.pivotCaches = workbook.pivotCaches;
-                        break;
-                    }
-                    case OOXML_PATHS.xlSharedStrings:
-                        model.sharedStrings = new SharedStringsXform();
-                        await model.sharedStrings.parseStream(stream);
-                        break;
-                    case OOXML_PATHS.xlWorkbookRels:
-                        model.workbookRels = await this.parseRels(stream);
-                        break;
-                    case OOXML_PATHS.docPropsApp: {
-                        const appXform = new AppXform();
-                        const appProperties = await appXform.parseStream(stream);
-                        if (appProperties) {
-                            model.company = appProperties.company;
-                            model.manager = appProperties.manager;
-                        }
-                        break;
-                    }
-                    case OOXML_PATHS.docPropsCore: {
-                        const coreXform = new CoreXform();
-                        const coreProperties = await coreXform.parseStream(stream);
-                        Object.assign(model, coreProperties);
-                        break;
-                    }
-                    case OOXML_PATHS.xlStyles:
-                        model.styles = new StylesXform();
-                        await model.styles.parseStream(stream);
-                        break;
-                    default: {
-                        const handled = await this._processDefaultEntry(stream, model, entryName);
-                        if (!handled) {
-                            // Important for true streaming parsers: always consume unknown entries
-                            await drainEntry();
-                        }
-                        break;
+                const handled = await this._processKnownEntry(stream, model, entryName, options);
+                if (!handled) {
+                    const defaultHandled = await this._processDefaultEntry(stream, model, entryName);
+                    if (!defaultHandled) {
+                        // Important for true streaming parsers: always consume unknown entries
+                        await drainEntry();
                     }
                 }
             }
@@ -500,6 +558,15 @@ class XLSX {
                 drawingXform.reconcile(drawing, drawingOptions);
             }
         });
+        // Trim raw drawings for non-chart drawings to avoid bloating the serialized workbook model.
+        if (model.rawDrawings && model.drawingRels) {
+            for (const name of Object.keys(model.rawDrawings)) {
+                const drawingRel = model.drawingRels[name];
+                if (drawingRel && !this.drawingRelsHasChartReference(drawingRel)) {
+                    delete model.rawDrawings[name];
+                }
+            }
+        }
         // reconcile tables with the default styles
         const tableOptions = {
             styles: model.styles
@@ -516,6 +583,7 @@ class XLSX {
             mediaIndex: model.mediaIndex,
             date1904: model.properties && model.properties.date1904,
             drawings: model.drawings,
+            drawingRels: model.drawingRels,
             comments: model.comments,
             tables: model.tables,
             vmlDrawings: model.vmlDrawings,
@@ -532,6 +600,8 @@ class XLSX {
         delete model.sharedStrings;
         delete model.workbookRels;
         delete model.sheetDefs;
+        // Preserve default font before deleting styles
+        model.defaultFont = model.styles?.defaultFont;
         delete model.styles;
         delete model.mediaIndex;
         delete model.drawings;
@@ -692,9 +762,15 @@ class XLSX {
         }
     }
     async _processDrawingEntry(entry, model, name) {
+        // Collect raw data first so we can preserve drawings that reference charts.
+        const rawData = await this.collectStreamData(entry);
+        // Parse the drawing for normal processing (images, etc.)
         const xform = new DrawingXform();
-        const drawing = await xform.parseStream(entry);
+        const xmlString = this.bufferToString(rawData);
+        const drawing = await xform.parseStream(this.createTextStream(xmlString));
         model.drawings[name] = drawing;
+        // Store raw data; reconcile() may later drop it if charts are not referenced.
+        model.rawDrawings[name] = rawData;
     }
     async _processDrawingRelsEntry(entry, model, name) {
         const xform = new RelationshipsXform();
@@ -769,24 +845,7 @@ class XLSX {
     // loadFromFiles - shared logic for loading from pre-extracted ZIP data
     // ===========================================================================
     async loadFromFiles(zipData, options) {
-        const model = {
-            worksheets: [],
-            worksheetHash: {},
-            worksheetRels: [],
-            themes: {},
-            media: [],
-            mediaIndex: {},
-            drawings: {},
-            drawingRels: {},
-            comments: {},
-            tables: {},
-            vmlDrawings: {},
-            pivotTables: {},
-            pivotTableRels: {},
-            pivotCacheDefinitions: {},
-            pivotCacheDefinitionRels: {},
-            pivotCacheRecords: {}
-        };
+        const model = this.createEmptyModel();
         const entries = Object.keys(zipData).map(name => ({
             name,
             dir: name.endsWith("/"),
@@ -800,54 +859,10 @@ class XLSX {
                 const stream = isBinaryEntry
                     ? this.createBinaryStream(entry.data)
                     : this.createTextStream(this.bufferToString(entry.data));
-                const sheetNo = getWorksheetNoFromWorksheetPath(entryName);
-                if (sheetNo !== undefined) {
-                    await this._processWorksheetEntry(stream, model, sheetNo, options, entryName);
-                }
-                else {
-                    switch (entryName) {
-                        case OOXML_PATHS.rootRels:
-                            model.globalRels = await this.parseRels(stream);
-                            break;
-                        case OOXML_PATHS.xlWorkbook: {
-                            const workbook = await this.parseWorkbook(stream);
-                            model.sheets = workbook.sheets;
-                            model.definedNames = workbook.definedNames;
-                            model.views = workbook.views;
-                            model.properties = workbook.properties;
-                            model.calcProperties = workbook.calcProperties;
-                            model.pivotCaches = workbook.pivotCaches;
-                            break;
-                        }
-                        case OOXML_PATHS.xlSharedStrings:
-                            model.sharedStrings = new SharedStringsXform();
-                            await model.sharedStrings.parseStream(stream);
-                            break;
-                        case OOXML_PATHS.xlWorkbookRels:
-                            model.workbookRels = await this.parseRels(stream);
-                            break;
-                        case OOXML_PATHS.docPropsApp: {
-                            const appXform = new AppXform();
-                            const appProperties = await appXform.parseStream(stream);
-                            if (appProperties) {
-                                model.company = appProperties.company;
-                                model.manager = appProperties.manager;
-                            }
-                            break;
-                        }
-                        case OOXML_PATHS.docPropsCore: {
-                            const coreXform = new CoreXform();
-                            const coreProperties = await coreXform.parseStream(stream);
-                            Object.assign(model, coreProperties);
-                            break;
-                        }
-                        case OOXML_PATHS.xlStyles:
-                            model.styles = new StylesXform();
-                            await model.styles.parseStream(stream);
-                            break;
-                        default:
-                            await this._processDefaultEntry(stream, model, entryName);
-                    }
+                const handled = await this._processKnownEntry(stream, model, entryName, options);
+                if (!handled) {
+                    // Pass raw entry data for drawings to enable passthrough
+                    await this._processDefaultEntry(stream, model, entryName, entry.data);
                 }
             }
         }
@@ -857,11 +872,11 @@ class XLSX {
     }
     /**
      * Process default entries (drawings, comments, tables, etc.)
+     * @param rawData Optional raw entry data for passthrough preservation (used by loadFromFiles)
      */
-    async _processDefaultEntry(stream, model, entryName) {
-        const worksheetRelsSheetNo = getWorksheetNoFromWorksheetRelsPath(entryName);
-        if (worksheetRelsSheetNo !== undefined) {
-            const sheetNo = worksheetRelsSheetNo;
+    async _processDefaultEntry(stream, model, entryName, rawData) {
+        const sheetNo = getWorksheetNoFromWorksheetRelsPath(entryName);
+        if (sheetNo !== undefined) {
             await this._processWorksheetRelsEntry(stream, model, sheetNo);
             return true;
         }
@@ -873,6 +888,10 @@ class XLSX {
         const drawingName = getDrawingNameFromPath(entryName);
         if (drawingName) {
             await this._processDrawingEntry(stream, model, drawingName);
+            // For loadFromFiles path, store raw data for passthrough (drawings with charts)
+            if (rawData) {
+                model.rawDrawings[drawingName] = rawData;
+            }
             return true;
         }
         const drawingRelsName = getDrawingNameFromRelsPath(entryName);
@@ -927,8 +946,27 @@ class XLSX {
             await this._processPivotCacheRecordsEntry(stream, model, pivotCacheRecordsName);
             return true;
         }
+        // Store passthrough files (charts, etc.) for preservation
+        if (PassthroughManager.isPassthroughPath(entryName)) {
+            // If raw data is available (loadFromFiles path), use it directly
+            if (rawData) {
+                model.passthrough[entryName] = rawData;
+            }
+            else {
+                await this._processPassthroughEntry(stream, model, entryName);
+            }
+            return true;
+        }
         return false;
     }
+    /**
+     * 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.
+     */
+    async _processPassthroughEntry(stream, model, entryName) {
+        const data = await this.collectStreamData(stream);
+        model.passthrough[entryName] = data;
+    }
     // ===========================================================================
     // Write methods - shared by all platforms
     // ===========================================================================
@@ -1071,14 +1109,46 @@ class XLSX {
     addDrawings(zip, model) {
         const drawingXform = new DrawingXform();
         const relsXform = new RelationshipsXform();
+        const rawDrawings = model.rawDrawings || {};
         model.worksheets.forEach((worksheet) => {
             const { drawing } = worksheet;
             if (drawing) {
-                drawingXform.prepare(drawing);
-                let xml = drawingXform.toXml(drawing);
-                zip.append(xml, { name: drawingPath(drawing.name) });
-                xml = relsXform.toXml(drawing.rels);
-                zip.append(xml, { name: drawingRelsPath(drawing.name) });
+                // Check if drawing rels contain chart references using helper
+                const hasChartReference = this.drawingHasChartReference(drawing);
+                if (hasChartReference && rawDrawings[drawing.name]) {
+                    // Use raw data for drawings with chart references (passthrough)
+                    zip.append(rawDrawings[drawing.name], { name: drawingPath(drawing.name) });
+                }
+                else {
+                    // Use regenerated XML for normal drawings (images, shapes)
+                    // Filter out invalid anchors (null, undefined, or missing content)
+                    const filteredAnchors = (drawing.anchors || []).filter((a) => {
+                        if (a == null) {
+                            return false;
+                        }
+                        // Form controls have range.br and shape properties
+                        if (a.range?.br && a.shape) {
+                            return true;
+                        }
+                        // One-cell anchors need a valid picture
+                        if (!a.br && !a.picture) {
+                            return false;
+                        }
+                        // Two-cell anchors need either picture or shape
+                        if (a.br && !a.picture && !a.shape) {
+                            return false;
+                        }
+                        return true;
+                    });
+                    const drawingForWrite = drawing.anchors
+                        ? { ...drawing, anchors: filteredAnchors }
+                        : drawing;
+                    drawingXform.prepare(drawingForWrite);
+                    const xml = drawingXform.toXml(drawingForWrite);
+                    zip.append(xml, { name: drawingPath(drawing.name) });
+                }
+                const relsXml = relsXform.toXml(drawing.rels);
+                zip.append(relsXml, { name: drawingRelsPath(drawing.name) });
             }
         });
     }
@@ -1093,6 +1163,15 @@ class XLSX {
             });
         });
     }
+    /**
+     * Write passthrough files (charts, etc.) that were preserved during read.
+     * These files are written back unchanged to preserve unsupported features.
+     */
+    addPassthrough(zip, model) {
+        const passthroughManager = new PassthroughManager();
+        passthroughManager.fromRecord(model.passthrough || {});
+        passthroughManager.writeToZip(zip);
+    }
     addPivotTables(zip, model) {
         if (!model.pivotTables.length) {
             return;
@@ -1158,7 +1237,12 @@ class XLSX {
             options.useSharedStrings !== undefined ? options.useSharedStrings : true;
         model.useStyles = options.useStyles !== undefined ? options.useStyles : true;
         model.sharedStrings = new SharedStringsXform();
+        // Preserve default font from parsed styles if available
+        const oldDefaultFont = model.defaultFont;
         model.styles = model.useStyles ? new StylesXform(true) : new StylesXform.Mock();
+        if (oldDefaultFont && model.styles.setDefaultFont) {
+            model.styles.setDefaultFont(oldDefaultFont);
+        }
         const workbookXform = new WorkbookXform();
         const worksheetXform = new WorkSheetXform();
         workbookXform.prepare(model);
@@ -1185,6 +1269,11 @@ class XLSX {
         });
         // ContentTypesXform expects this flag
         model.hasCheckboxes = model.styles.hasCheckboxes;
+        // Build passthroughContentTypes for ContentTypesXform using PassthroughManager
+        const passthrough = model.passthrough || {};
+        const passthroughManager = new PassthroughManager();
+        passthroughManager.fromRecord(passthrough);
+        model.passthroughContentTypes = passthroughManager.getContentTypes();
     }
 }
 XLSX.RelType = RelType;

package/dist/browser/modules/stream/streams.browser.js

@@ -845,9 +845,6 @@ export class Readable extends EventEmitter {
                     yield chunk;
                 }
             }
-            if (streamError) {
-                throw streamError;
-            }
         }
         finally {
             this.off("data", dataHandler);

package/dist/cjs/modules/csv/csv.browser.js

@@ -119,7 +119,7 @@ class CSV {
         const dateFormats = options?.dateFormats ?? DEFAULT_DATE_FORMATS;
         const map = options?.map ||
             createDefaultValueMapper(dateFormats, {
-                decimalSeparator: options?.valueMapperOptions?.decimalSeparator ?? options?.parserOptions?.decimalSeparator
+                decimalSeparator: options?.valueMapperOptions?.decimalSeparator
             });
         const rows = (0, csv_core_1.parseCsv)(str, options?.parserOptions);
         for (const row of rows) {
@@ -161,7 +161,7 @@ class CSV {
         const dateFormats = options?.dateFormats ?? DEFAULT_DATE_FORMATS;
         const map = options?.map ||
             createDefaultValueMapper(dateFormats, {
-                decimalSeparator: options?.valueMapperOptions?.decimalSeparator ?? options?.parserOptions?.decimalSeparator
+                decimalSeparator: options?.valueMapperOptions?.decimalSeparator
             });
         const parser = new csv_stream_1.CsvParserStream(options?.parserOptions);
         return new Promise((resolve, reject) => {
@@ -231,7 +231,7 @@ class CSV {
         const dateFormats = options?.dateFormats ?? DEFAULT_DATE_FORMATS;
         const map = options?.map ||
             createDefaultValueMapper(dateFormats, {
-                decimalSeparator: options?.valueMapperOptions?.decimalSeparator ?? options?.parserOptions?.decimalSeparator
+                decimalSeparator: options?.valueMapperOptions?.decimalSeparator
             });
         const parser = new csv_stream_1.CsvParserStream(options?.parserOptions);
         parser.on("data", (row) => worksheet.addRow(row.map(map)));

package/dist/cjs/modules/excel/column.js

@@ -41,7 +41,8 @@ class Column {
             width: this.width,
             style: this.style,
             hidden: this.hidden,
-            outlineLevel: this.outlineLevel
+            outlineLevel: this.outlineLevel,
+            bestFit: this.bestFit
         };
     }
     set defn(value) {
@@ -58,6 +59,7 @@ class Column {
             // headers must be set after style
             this.header = value.header;
             this._hidden = !!value.hidden;
+            this.bestFit = value.bestFit;
         }
         else {
             delete this._header;
@@ -65,6 +67,7 @@ class Column {
             delete this.width;
             this.style = {};
             this.outlineLevel = 0;
+            delete this.bestFit;
         }
     }
     /**
@@ -154,6 +157,7 @@ class Column {
         return (this.width === model.width &&
             this.hidden === model.hidden &&
             this.outlineLevel === model.outlineLevel &&
+            this.bestFit === model.bestFit &&
             (0, under_dash_1.isEqual)(this.style, model.style));
     }
     get isDefault() {
@@ -166,6 +170,9 @@ class Column {
         if (this.outlineLevel) {
             return false;
         }
+        if (this.bestFit) {
+            return false;
+        }
         const s = this.style;
         if (s && (s.font || s.numFmt || s.alignment || s.border || s.fill || s.protection)) {
             return false;
@@ -316,7 +323,8 @@ class Column {
                         isCustomWidth: column.isCustomWidth,
                         hidden: column.hidden,
                         outlineLevel: column.outlineLevel,
-                        collapsed: column.collapsed
+                        collapsed: column.collapsed,
+                        bestFit: column.bestFit
                     };
                     cols.push(col);
                 }

package/dist/cjs/modules/excel/row.js

@@ -391,7 +391,8 @@ class Row {
                 style: this.style,
                 hidden: this.hidden,
                 outlineLevel: this.outlineLevel,
-                collapsed: this.collapsed
+                collapsed: this.collapsed,
+                dyDescent: this.dyDescent
             }
             : null;
     }
@@ -438,6 +439,7 @@ class Row {
         }
         this.hidden = value.hidden;
         this.outlineLevel = value.outlineLevel || 0;
+        this.dyDescent = value.dyDescent;
         this.style = (value.style && JSON.parse(JSON.stringify(value.style))) || {};
     }
 }