@cj-tech-master/excelts 4.2.2 → 4.2.3-canary.20260122073152.a9bb6b0

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/core/app-xform.js

@@ -13,7 +13,7 @@ class AppXform extends base_xform_1.BaseXform {
             Company: new string_xform_1.StringXform({ tag: "Company" }),
             Manager: new string_xform_1.StringXform({ tag: "Manager" }),
             HeadingPairs: new app_heading_pairs_xform_1.AppHeadingPairsXform(),
-            TitleOfParts: new app_titles_of_parts_xform_1.AppTitlesOfPartsXform()
+            TitlesOfParts: new app_titles_of_parts_xform_1.AppTitlesOfPartsXform()
         };
     }
     render(xmlStream, model) {
@@ -23,7 +23,7 @@ class AppXform extends base_xform_1.BaseXform {
         xmlStream.leafNode("DocSecurity", undefined, "0");
         xmlStream.leafNode("ScaleCrop", undefined, "false");
         this.map.HeadingPairs.render(xmlStream, model.worksheets);
-        this.map.TitleOfParts.render(xmlStream, model.worksheets);
+        this.map.TitlesOfParts.render(xmlStream, model.worksheets);
         this.map.Company.render(xmlStream, model.company || "");
         this.map.Manager.render(xmlStream, model.manager);
         xmlStream.leafNode("LinksUpToDate", undefined, "false");
@@ -65,7 +65,7 @@ class AppXform extends base_xform_1.BaseXform {
         switch (name) {
             case "Properties":
                 this.model = {
-                    worksheets: this.map.TitleOfParts.model,
+                    worksheets: this.map.TitlesOfParts.model,
                     company: this.map.Company.model,
                     manager: this.map.Manager.model
                 };

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"

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

@@ -6,31 +6,50 @@ const base_xform_1 = require("../base-xform.js");
 const date_xform_1 = require("../simple/date-xform.js");
 const string_xform_1 = require("../simple/string-xform.js");
 const integer_xform_1 = require("../simple/integer-xform.js");
+// Rendering uses namespace prefixes, parsing uses unqualified names (SAX strips prefixes)
+const PROPS = {
+    creator: "dc:creator",
+    title: "dc:title",
+    subject: "dc:subject",
+    description: "dc:description",
+    identifier: "dc:identifier",
+    language: "dc:language",
+    keywords: "cp:keywords",
+    category: "cp:category",
+    lastModifiedBy: "cp:lastModifiedBy",
+    lastPrinted: "cp:lastPrinted",
+    revision: "cp:revision",
+    version: "cp:version",
+    contentStatus: "cp:contentStatus",
+    contentType: "cp:contentType",
+    created: "dcterms:created",
+    modified: "dcterms:modified"
+};
 class CoreXform extends base_xform_1.BaseXform {
     constructor() {
         super();
         this.map = {
-            "dc:creator": new string_xform_1.StringXform({ tag: "dc:creator" }),
-            "dc:title": new string_xform_1.StringXform({ tag: "dc:title" }),
-            "dc:subject": new string_xform_1.StringXform({ tag: "dc:subject" }),
-            "dc:description": new string_xform_1.StringXform({ tag: "dc:description" }),
-            "dc:identifier": new string_xform_1.StringXform({ tag: "dc:identifier" }),
-            "dc:language": new string_xform_1.StringXform({ tag: "dc:language" }),
-            "cp:keywords": new string_xform_1.StringXform({ tag: "cp:keywords" }),
-            "cp:category": new string_xform_1.StringXform({ tag: "cp:category" }),
-            "cp:lastModifiedBy": new string_xform_1.StringXform({ tag: "cp:lastModifiedBy" }),
-            "cp:lastPrinted": new date_xform_1.DateXform({ tag: "cp:lastPrinted", format: CoreXform.DateFormat }),
-            "cp:revision": new integer_xform_1.IntegerXform({ tag: "cp:revision" }),
-            "cp:version": new string_xform_1.StringXform({ tag: "cp:version" }),
-            "cp:contentStatus": new string_xform_1.StringXform({ tag: "cp:contentStatus" }),
-            "cp:contentType": new string_xform_1.StringXform({ tag: "cp:contentType" }),
-            "dcterms:created": new date_xform_1.DateXform({
-                tag: "dcterms:created",
+            creator: new string_xform_1.StringXform({ tag: PROPS.creator }),
+            title: new string_xform_1.StringXform({ tag: PROPS.title }),
+            subject: new string_xform_1.StringXform({ tag: PROPS.subject }),
+            description: new string_xform_1.StringXform({ tag: PROPS.description }),
+            identifier: new string_xform_1.StringXform({ tag: PROPS.identifier }),
+            language: new string_xform_1.StringXform({ tag: PROPS.language }),
+            keywords: new string_xform_1.StringXform({ tag: PROPS.keywords }),
+            category: new string_xform_1.StringXform({ tag: PROPS.category }),
+            lastModifiedBy: new string_xform_1.StringXform({ tag: PROPS.lastModifiedBy }),
+            lastPrinted: new date_xform_1.DateXform({ tag: PROPS.lastPrinted, format: CoreXform.DateFormat }),
+            revision: new integer_xform_1.IntegerXform({ tag: PROPS.revision }),
+            version: new string_xform_1.StringXform({ tag: PROPS.version }),
+            contentStatus: new string_xform_1.StringXform({ tag: PROPS.contentStatus }),
+            contentType: new string_xform_1.StringXform({ tag: PROPS.contentType }),
+            created: new date_xform_1.DateXform({
+                tag: PROPS.created,
                 attrs: CoreXform.DateAttrs,
                 format: CoreXform.DateFormat
             }),
-            "dcterms:modified": new date_xform_1.DateXform({
-                tag: "dcterms:modified",
+            modified: new date_xform_1.DateXform({
+                tag: PROPS.modified,
                 attrs: CoreXform.DateAttrs,
                 format: CoreXform.DateFormat
             })
@@ -39,22 +58,9 @@ class CoreXform extends base_xform_1.BaseXform {
     render(xmlStream, model) {
         xmlStream.openXml(xml_stream_1.XmlStream.StdDocAttributes);
         xmlStream.openNode("cp:coreProperties", CoreXform.CORE_PROPERTY_ATTRIBUTES);
-        this.map["dc:creator"].render(xmlStream, model.creator);
-        this.map["dc:title"].render(xmlStream, model.title);
-        this.map["dc:subject"].render(xmlStream, model.subject);
-        this.map["dc:description"].render(xmlStream, model.description);
-        this.map["dc:identifier"].render(xmlStream, model.identifier);
-        this.map["dc:language"].render(xmlStream, model.language);
-        this.map["cp:keywords"].render(xmlStream, model.keywords);
-        this.map["cp:category"].render(xmlStream, model.category);
-        this.map["cp:lastModifiedBy"].render(xmlStream, model.lastModifiedBy);
-        this.map["cp:lastPrinted"].render(xmlStream, model.lastPrinted);
-        this.map["cp:revision"].render(xmlStream, model.revision);
-        this.map["cp:version"].render(xmlStream, model.version);
-        this.map["cp:contentStatus"].render(xmlStream, model.contentStatus);
-        this.map["cp:contentType"].render(xmlStream, model.contentType);
-        this.map["dcterms:created"].render(xmlStream, model.created);
-        this.map["dcterms:modified"].render(xmlStream, model.modified);
+        for (const key of Object.keys(PROPS)) {
+            this.map[key].render(xmlStream, model[key]);
+        }
         xmlStream.closeNode();
     }
     parseOpen(node) {
@@ -62,18 +68,13 @@ class CoreXform extends base_xform_1.BaseXform {
             this.parser.parseOpen(node);
             return true;
         }
-        switch (node.name) {
-            case "cp:coreProperties":
-            case "coreProperties":
-                return true;
-            default:
-                this.parser = this.map[node.name];
-                if (this.parser) {
-                    this.parser.parseOpen(node);
-                    return true;
-                }
-                throw new Error(`Unexpected xml node in parseOpen: ${JSON.stringify(node)}`);
+        if (node.name !== "coreProperties") {
+            this.parser = this.map[node.name];
+            if (this.parser) {
+                this.parser.parseOpen(node);
+            }
         }
+        return true;
     }
     parseText(text) {
         if (this.parser) {
@@ -87,30 +88,17 @@ class CoreXform extends base_xform_1.BaseXform {
             }
             return true;
         }
-        switch (name) {
-            case "cp:coreProperties":
-            case "coreProperties":
-                this.model = {
-                    creator: this.map["dc:creator"].model,
-                    title: this.map["dc:title"].model,
-                    subject: this.map["dc:subject"].model,
-                    description: this.map["dc:description"].model,
-                    identifier: this.map["dc:identifier"].model,
-                    language: this.map["dc:language"].model,
-                    keywords: this.map["cp:keywords"].model,
-                    category: this.map["cp:category"].model,
-                    lastModifiedBy: this.map["cp:lastModifiedBy"].model,
-                    lastPrinted: this.map["cp:lastPrinted"].model,
-                    revision: this.map["cp:revision"].model,
-                    contentStatus: this.map["cp:contentStatus"].model,
-                    contentType: this.map["cp:contentType"].model,
-                    created: this.map["dcterms:created"].model,
-                    modified: this.map["dcterms:modified"].model
-                };
-                return false;
-            default:
-                throw new Error(`Unexpected xml node in parseClose: ${name}`);
+        if (name === "coreProperties") {
+            this.model = {};
+            for (const key of Object.keys(PROPS)) {
+                const val = this.map[key].model;
+                if (val !== undefined && val !== "") {
+                    this.model[key] = val;
+                }
+            }
+            return false;
         }
+        return true;
     }
 }
 exports.CoreXform = CoreXform;

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

@@ -44,17 +44,15 @@ class ListXform extends base_xform_1.BaseXform {
             this.parser.parseOpen(node);
             return true;
         }
-        switch (node.name) {
-            case this.tag:
-                this.model = [];
-                return true;
-            default:
-                if (this.childXform.parseOpen(node)) {
-                    this.parser = this.childXform;
-                    return true;
-                }
-                return false;
+        if (node.name === this.tag) {
+            this.model = [];
+            return true;
         }
+        if (this.childXform.parseOpen(node)) {
+            this.parser = this.childXform;
+            return true;
+        }
+        return false;
     }
     parseText(text) {
         if (this.parser) {