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

package/dist/cjs/modules/excel/utils/passthrough-manager.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * PassthroughManager - Manages passthrough files for round-trip preservation
+ *
+ * This module handles files that are not fully parsed by the library but need to be
+ * preserved during read/write cycles (e.g., charts, sparklines, slicers).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PassthroughManager = void 0;
+// Pre-compiled regex patterns for content type detection (performance optimization)
+const chartXmlRegex = /^xl\/charts\/chart\d+\.xml$/;
+const chartStyleXmlRegex = /^xl\/charts\/style\d+\.xml$/;
+const chartColorsXmlRegex = /^xl\/charts\/colors\d+\.xml$/;
+/**
+ * Content type definitions for passthrough files
+ */
+const PASSTHROUGH_CONTENT_TYPES = new Map([
+    [chartXmlRegex, "application/vnd.openxmlformats-officedocument.drawingml.chart+xml"],
+    [chartStyleXmlRegex, "application/vnd.ms-office.chartstyle+xml"],
+    [chartColorsXmlRegex, "application/vnd.ms-office.chartcolorstyle+xml"]
+]);
+/**
+ * Passthrough path prefixes that should be preserved
+ */
+const PASSTHROUGH_PREFIXES = ["xl/charts/"];
+/**
+ * PassthroughManager handles storage and retrieval of passthrough files
+ * that need to be preserved during Excel read/write cycles.
+ */
+class PassthroughManager {
+    constructor() {
+        this.files = new Map();
+    }
+    /**
+     * Check if a path should be treated as passthrough
+     */
+    static isPassthroughPath(path) {
+        return PASSTHROUGH_PREFIXES.some(prefix => path.startsWith(prefix));
+    }
+    /**
+     * Get the content type for a passthrough file path
+     * @returns Content type string or undefined if unknown
+     */
+    static getContentType(path) {
+        // Chart relationships are handled by Default extension="rels"
+        if (path.startsWith("xl/charts/_rels/")) {
+            return undefined;
+        }
+        for (const [regex, contentType] of PASSTHROUGH_CONTENT_TYPES) {
+            if (regex.test(path)) {
+                return contentType;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Add a file to passthrough storage
+     */
+    add(path, data) {
+        this.files.set(path, data);
+    }
+    /**
+     * Get a file from passthrough storage
+     */
+    get(path) {
+        return this.files.get(path);
+    }
+    /**
+     * Check if a file exists in passthrough storage
+     */
+    has(path) {
+        return this.files.has(path);
+    }
+    /**
+     * Get all stored paths
+     */
+    getPaths() {
+        return [...this.files.keys()];
+    }
+    /**
+     * Get all files as a record (for serialization)
+     */
+    toRecord() {
+        const record = {};
+        for (const [path, data] of this.files) {
+            record[path] = data;
+        }
+        return record;
+    }
+    /**
+     * Load files from a record (for deserialization)
+     */
+    fromRecord(record) {
+        this.files.clear();
+        for (const [path, data] of Object.entries(record)) {
+            this.files.set(path, data);
+        }
+    }
+    /**
+     * Get content types for all stored files that have known types
+     */
+    getContentTypes() {
+        const contentTypes = [];
+        for (const path of this.files.keys()) {
+            const contentType = PassthroughManager.getContentType(path);
+            if (contentType) {
+                contentTypes.push({ partName: path, contentType });
+            }
+        }
+        return contentTypes;
+    }
+    /**
+     * Write all passthrough files to a ZIP writer
+     */
+    writeToZip(zip) {
+        for (const [path, data] of this.files) {
+            zip.append(data, { name: path });
+        }
+    }
+    /**
+     * Clear all stored files
+     */
+    clear() {
+        this.files.clear();
+    }
+    /**
+     * Get the number of stored files
+     */
+    get size() {
+        return this.files.size;
+    }
+}
+exports.PassthroughManager = PassthroughManager;

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

@@ -41,6 +41,8 @@ class Workbook {
         this.views = [];
         this.media = [];
         this.pivotTables = [];
+        this._passthrough = {};
+        this._rawDrawings = {};
         this._definedNames = new defined_names_1.DefinedNames();
     }
     // ===========================================================================
@@ -254,7 +256,9 @@ class Workbook {
             themes: this._themes,
             media: this.media,
             pivotTables: this.pivotTables,
-            calcProperties: this.calcProperties
+            calcProperties: this.calcProperties,
+            passthrough: this._passthrough,
+            rawDrawings: this._rawDrawings
         };
     }
     set model(value) {
@@ -295,6 +299,10 @@ class Workbook {
         // Handle pivot tables - either newly created or loaded from file
         // Loaded pivot tables come from loadedPivotTables after reconciliation
         this.pivotTables = value.pivotTables || value.loadedPivotTables || [];
+        // Preserve passthrough files (charts, etc.) for round-trip preservation
+        this._passthrough = value.passthrough || {};
+        // Preserve raw drawing data for drawings with chart references
+        this._rawDrawings = value.rawDrawings || {};
     }
 }
 exports.Workbook = Workbook;

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

@@ -900,7 +900,8 @@ class Worksheet {
             tables: Object.values(this.tables).map(table => table.model),
             pivotTables: this.pivotTables,
             conditionalFormattings: this.conditionalFormattings,
-            formControls: this.formControls.map(fc => fc.model)
+            formControls: this.formControls.map(fc => fc.model),
+            drawing: this._drawing
         };
         // =================================================
         // columns
@@ -968,6 +969,8 @@ class Worksheet {
         this.conditionalFormattings = value.conditionalFormattings;
         // Form controls are currently write-only (not parsed from XLSX)
         this.formControls = [];
+        // Preserve loaded drawing data (charts, etc.)
+        this._drawing = value.drawing;
     }
 }
 exports.Worksheet = Worksheet;

package/dist/cjs/modules/excel/xlsx/xform/base-xform.js

@@ -3,6 +3,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseXform = void 0;
 const parse_sax_1 = require("../../utils/parse-sax.js");
 const xml_stream_1 = require("../../utils/xml-stream.js");
+// HAN CELL namespace prefix normalization
+// HAN CELL uses non-standard namespace prefixes (ep:, cp:, dc:, etc.)
+// See: https://github.com/exceljs/exceljs/issues/3014
+const HAN_CELL_PREFIXES = new Set(["ep", "cp", "dc", "dcterms", "dcmitype", "vt"]);
+const SPREADSHEETML_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+// Detect HAN CELL mode from first tag. Returns:
+// - undefined: normal file (no prefix handling needed)
+// - null: HAN CELL file without spreadsheetml prefix (uses static prefixes only)
+// - string: HAN CELL file with spreadsheetml prefix (e.g., "x")
+function detectHanCellPrefix(tagName, attrs) {
+    for (const key in attrs) {
+        if (key.length > 6 && key.startsWith("xmlns:")) {
+            const prefix = key.slice(6);
+            // Check for spreadsheetml namespace prefix
+            if (attrs[key] === SPREADSHEETML_NS) {
+                return prefix;
+            }
+            // Check if xmlns declares a known HAN CELL prefix (e.g., xmlns:dc, xmlns:dcterms)
+            if (HAN_CELL_PREFIXES.has(prefix)) {
+                return null;
+            }
+        }
+    }
+    // Check if tag name has a known static prefix
+    const i = tagName.indexOf(":");
+    return i !== -1 && HAN_CELL_PREFIXES.has(tagName.slice(0, i)) ? null : undefined;
+}
+// Strip known namespace prefix from element name
+function stripPrefix(name, nsPrefix) {
+    const i = name.indexOf(":");
+    if (i === -1) {
+        return name;
+    }
+    const p = name.slice(0, i);
+    return p === nsPrefix || HAN_CELL_PREFIXES.has(p) ? name.slice(i + 1) : name;
+}
 // Base class for Xforms
 class BaseXform {
     // ============================================================
@@ -54,19 +90,50 @@ class BaseXform {
         // destroys the underlying stream and can surface as AbortError (ABORT_ERR).
         let done = false;
         let finalModel;
+        // HAN CELL compatibility: 0 = not checked, 1 = normal file, 2 = HAN CELL file
+        let nsMode = 0;
+        let nsPrefix = null;
         for await (const events of saxParser) {
             if (done) {
                 continue;
             }
             for (const { eventType, value } of events) {
                 if (eventType === "opentag") {
+                    // Fast path for normal Excel files (majority case)
+                    if (nsMode === 1) {
+                        this.parseOpen(value);
+                        continue;
+                    }
+                    // First tag - detect mode
+                    if (nsMode === 0) {
+                        const prefix = detectHanCellPrefix(value.name, value.attributes);
+                        if (prefix === undefined) {
+                            nsMode = 1;
+                            this.parseOpen(value);
+                            continue;
+                        }
+                        nsMode = 2;
+                        nsPrefix = prefix;
+                    }
+                    // HAN CELL mode - strip prefix
+                    value.name = stripPrefix(value.name, nsPrefix);
                     this.parseOpen(value);
                 }
                 else if (eventType === "text") {
                     this.parseText(value);
                 }
                 else if (eventType === "closetag") {
-                    if (!this.parseClose(value.name)) {
+                    // Fast path for normal files
+                    if (nsMode === 1) {
+                        if (!this.parseClose(value.name)) {
+                            done = true;
+                            finalModel = this.model;
+                            break;
+                        }
+                        continue;
+                    }
+                    // HAN CELL mode - strip prefix
+                    if (!this.parseClose(stripPrefix(value.name, nsPrefix))) {
                         done = true;
                         finalModel = this.model;
                         break;

package/dist/cjs/modules/excel/xlsx/xform/core/content-types-xform.js

@@ -96,11 +96,16 @@ class ContentTypesXform extends base_xform_1.BaseXform {
                 });
             });
         }
-        if (model.commentRefs) {
+        // VML extension is needed for comments or form controls
+        const hasComments = model.commentRefs && model.commentRefs.length > 0;
+        const hasFormControls = model.formControlRefs && model.formControlRefs.length > 0;
+        if (hasComments || hasFormControls) {
             xmlStream.leafNode("Default", {
                 Extension: "vml",
                 ContentType: "application/vnd.openxmlformats-officedocument.vmlDrawing"
             });
+        }
+        if (hasComments) {
             model.commentRefs.forEach(({ commentName }) => {
                 xmlStream.leafNode("Override", {
                     PartName: (0, ooxml_paths_1.toContentTypesPartName)((0, ooxml_paths_1.commentsPathFromName)(commentName)),
@@ -108,15 +113,7 @@ class ContentTypesXform extends base_xform_1.BaseXform {
                 });
             });
         }
-        // Add form control (ctrlProps) content types
-        if (model.formControlRefs) {
-            // Ensure vml extension is declared (may already be declared for comments)
-            if (!model.commentRefs) {
-                xmlStream.leafNode("Default", {
-                    Extension: "vml",
-                    ContentType: "application/vnd.openxmlformats-officedocument.vmlDrawing"
-                });
-            }
+        if (hasFormControls) {
             for (const ctrlPropId of model.formControlRefs) {
                 xmlStream.leafNode("Override", {
                     PartName: (0, ooxml_paths_1.toContentTypesPartName)((0, ooxml_paths_1.ctrlPropPath)(ctrlPropId)),
@@ -124,6 +121,15 @@ class ContentTypesXform extends base_xform_1.BaseXform {
                 });
             }
         }
+        // Add passthrough content types (charts, etc.)
+        if (model.passthroughContentTypes) {
+            for (const { partName, contentType } of model.passthroughContentTypes) {
+                xmlStream.leafNode("Override", {
+                    PartName: (0, ooxml_paths_1.toContentTypesPartName)(partName),
+                    ContentType: contentType
+                });
+            }
+        }
         xmlStream.leafNode("Override", {
             PartName: (0, ooxml_paths_1.toContentTypesPartName)(ooxml_paths_1.OOXML_PATHS.docPropsCore),
             ContentType: "application/vnd.openxmlformats-package.core-properties+xml"