@cj-tech-master/excelts 3.0.1 → 3.1.0-canary.20260102043356.6791d4e

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

@@ -0,0 +1,135 @@
+import { parseSax } from "../../utils/parse-sax.js";
+import { XmlStream } from "../../utils/xml-stream.js";
+// Base class for Xforms
+class BaseXform {
+    // ============================================================
+    // Virtual Interface
+    prepare(_model, _options) {
+        // optional preparation (mutation) of model so it is ready for write
+    }
+    render(_xmlStream, _model) {
+        // convert model to xml
+    }
+    parseOpen(_node) {
+        // XML node opened
+    }
+    parseText(_text) {
+        // chunk of text encountered for current node
+    }
+    parseClose(_name) {
+        // XML node closed
+        return false;
+    }
+    reconcile(_model, _options) {
+        // optional post-parse step (opposite to prepare)
+    }
+    // ============================================================
+    reset() {
+        // to make sure parses don't bleed to next iteration
+        this.model = null;
+        // if we have a map - reset them too
+        if (this.map) {
+            Object.values(this.map).forEach(xform => {
+                if (xform instanceof BaseXform) {
+                    xform.reset();
+                }
+                else if (xform.xform) {
+                    xform.xform.reset();
+                }
+            });
+        }
+    }
+    mergeModel(obj) {
+        // set obj's props to this.model
+        this.model = Object.assign(this.model || {}, obj);
+    }
+    async parse(saxParser) {
+        // IMPORTANT:
+        // Do not return early once parsing is "done".
+        // In true streaming scenarios, `parseSax(stream)` is backed by a Node.js
+        // Readable async iterator. Returning early would close the iterator, which
+        // destroys the underlying stream and can surface as AbortError (ABORT_ERR).
+        let done = false;
+        let finalModel;
+        for await (const events of saxParser) {
+            if (done) {
+                continue;
+            }
+            for (const { eventType, value } of events) {
+                if (eventType === "opentag") {
+                    this.parseOpen(value);
+                }
+                else if (eventType === "text") {
+                    this.parseText(value);
+                }
+                else if (eventType === "closetag") {
+                    if (!this.parseClose(value.name)) {
+                        done = true;
+                        finalModel = this.model;
+                        break;
+                    }
+                }
+            }
+        }
+        return done ? finalModel : this.model;
+    }
+    async parseStream(stream) {
+        return this.parse(parseSax(stream));
+    }
+    get xml() {
+        // convenience function to get the xml of this.model
+        // useful for manager types that are built during the prepare phase
+        return this.toXml(this.model);
+    }
+    toXml(model) {
+        const xmlStream = new XmlStream();
+        this.render(xmlStream, model);
+        return xmlStream.xml;
+    }
+    // ============================================================
+    // Useful Utilities
+    static toAttribute(value, dflt, always = false) {
+        if (value === undefined) {
+            if (always) {
+                return dflt;
+            }
+        }
+        else if (always || value !== dflt) {
+            return value.toString();
+        }
+        return undefined;
+    }
+    static toStringAttribute(value, dflt, always = false) {
+        return BaseXform.toAttribute(value, dflt, always);
+    }
+    static toStringValue(attr, dflt) {
+        return attr === undefined ? dflt : attr;
+    }
+    static toBoolAttribute(value, dflt, always = false) {
+        if (value === undefined) {
+            if (always) {
+                return dflt;
+            }
+        }
+        else if (always || value !== dflt) {
+            return value ? "1" : "0";
+        }
+        return undefined;
+    }
+    static toBoolValue(attr, dflt) {
+        return attr === undefined ? dflt : attr === "1";
+    }
+    static toIntAttribute(value, dflt, always = false) {
+        return BaseXform.toAttribute(value, dflt, always);
+    }
+    static toIntValue(attr, dflt) {
+        return attr === undefined ? dflt : parseInt(attr, 10);
+    }
+    static toFloatAttribute(value, dflt, always = false) {
+        return BaseXform.toAttribute(value, dflt, always);
+    }
+    static toFloatValue(attr, dflt) {
+        return attr === undefined ? dflt : parseFloat(attr);
+    }
+}
+export { BaseXform };

package/dist/esm/modules/excel/xlsx/xform/book/sheet-xform.js

@@ -0,0 +1,30 @@
+import { xmlDecode } from "../../../../../utils/utils.js";
+import { BaseXform } from "../base-xform.js";
+class WorksheetXform extends BaseXform {
+    render(xmlStream, model) {
+        xmlStream.leafNode("sheet", {
+            name: model.name,
+            sheetId: model.id,
+            // Excel doesn't output state when it's 'visible' (default)
+            state: model.state === "visible" ? undefined : model.state,
+            "r:id": model.rId
+        });
+    }
+    parseOpen(node) {
+        if (node.name === "sheet") {
+            this.model = {
+                name: xmlDecode(node.attributes.name),
+                id: parseInt(node.attributes.sheetId, 10),
+                state: node.attributes.state,
+                rId: node.attributes["r:id"]
+            };
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { WorksheetXform };

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

@@ -0,0 +1,122 @@
+import { XmlStream } from "../../../utils/xml-stream.js";
+import { BaseXform } from "../base-xform.js";
+import { OOXML_PATHS, commentsPathFromName, drawingPath, pivotCacheDefinitionPath, pivotCacheRecordsPath, pivotTablePath, tablePath, toContentTypesPartName, worksheetPath } from "../../../utils/ooxml-paths.js";
+// used for rendering the [Content_Types].xml file
+// not used for parsing
+class ContentTypesXform extends BaseXform {
+    render(xmlStream, model) {
+        xmlStream.openXml(XmlStream.StdDocAttributes);
+        xmlStream.openNode("Types", ContentTypesXform.PROPERTY_ATTRIBUTES);
+        const mediaHash = {};
+        (model.media || []).forEach((medium) => {
+            if (medium.type === "image") {
+                const imageType = medium.extension;
+                if (!mediaHash[imageType]) {
+                    mediaHash[imageType] = true;
+                    xmlStream.leafNode("Default", {
+                        Extension: imageType,
+                        ContentType: `image/${imageType}`
+                    });
+                }
+            }
+        });
+        xmlStream.leafNode("Default", {
+            Extension: "rels",
+            ContentType: "application/vnd.openxmlformats-package.relationships+xml"
+        });
+        xmlStream.leafNode("Default", { Extension: "xml", ContentType: "application/xml" });
+        xmlStream.leafNode("Override", {
+            PartName: toContentTypesPartName(OOXML_PATHS.xlWorkbook),
+            ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"
+        });
+        model.worksheets.forEach((worksheet, index) => {
+            // Use fileIndex if set, otherwise use sequential index (1-based)
+            const fileIndex = worksheet.fileIndex || index + 1;
+            xmlStream.leafNode("Override", {
+                PartName: toContentTypesPartName(worksheetPath(fileIndex)),
+                ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"
+            });
+        });
+        if ((model.pivotTables || []).length) {
+            // Add content types for each pivot table
+            (model.pivotTables || []).forEach((pivotTable) => {
+                const n = pivotTable.tableNumber;
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(pivotCacheDefinitionPath(n)),
+                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml"
+                });
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(pivotCacheRecordsPath(n)),
+                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml"
+                });
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(pivotTablePath(n)),
+                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml"
+                });
+            });
+        }
+        xmlStream.leafNode("Override", {
+            PartName: toContentTypesPartName(OOXML_PATHS.xlTheme1),
+            ContentType: "application/vnd.openxmlformats-officedocument.theme+xml"
+        });
+        xmlStream.leafNode("Override", {
+            PartName: toContentTypesPartName(OOXML_PATHS.xlStyles),
+            ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"
+        });
+        const hasSharedStrings = model.sharedStrings && model.sharedStrings.count;
+        if (hasSharedStrings) {
+            xmlStream.leafNode("Override", {
+                PartName: toContentTypesPartName(OOXML_PATHS.xlSharedStrings),
+                ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml"
+            });
+        }
+        if (model.tables) {
+            model.tables.forEach((table) => {
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(tablePath(table.target)),
+                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml"
+                });
+            });
+        }
+        if (model.drawings) {
+            model.drawings.forEach((drawing) => {
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(drawingPath(drawing.name)),
+                    ContentType: "application/vnd.openxmlformats-officedocument.drawing+xml"
+                });
+            });
+        }
+        if (model.commentRefs) {
+            xmlStream.leafNode("Default", {
+                Extension: "vml",
+                ContentType: "application/vnd.openxmlformats-officedocument.vmlDrawing"
+            });
+            model.commentRefs.forEach(({ commentName }) => {
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(commentsPathFromName(commentName)),
+                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml"
+                });
+            });
+        }
+        xmlStream.leafNode("Override", {
+            PartName: toContentTypesPartName(OOXML_PATHS.docPropsCore),
+            ContentType: "application/vnd.openxmlformats-package.core-properties+xml"
+        });
+        xmlStream.leafNode("Override", {
+            PartName: toContentTypesPartName(OOXML_PATHS.docPropsApp),
+            ContentType: "application/vnd.openxmlformats-officedocument.extended-properties+xml"
+        });
+        xmlStream.closeNode();
+    }
+    parseOpen() {
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+ContentTypesXform.PROPERTY_ATTRIBUTES = {
+    xmlns: "http://schemas.openxmlformats.org/package/2006/content-types"
+};
+export { ContentTypesXform };

package/dist/esm/modules/excel/xlsx/xform/pivot-table/cache-field-xform.js

@@ -0,0 +1,128 @@
+import { BaseXform } from "../base-xform.js";
+import { xmlDecode } from "../../../../../utils/utils.js";
+/**
+ * Xform for parsing individual <cacheField> elements within a pivot cache definition.
+ *
+ * Example XML:
+ * ```xml
+ * <cacheField name="Category" numFmtId="0">
+ *   <sharedItems count="3">
+ *     <s v="A" />
+ *     <s v="B" />
+ *     <s v="C" />
+ *   </sharedItems>
+ * </cacheField>
+ *
+ * <cacheField name="Value" numFmtId="0">
+ *   <sharedItems containsSemiMixedTypes="0" containsString="0"
+ *                containsNumber="1" containsInteger="1" minValue="5" maxValue="45" />
+ * </cacheField>
+ * ```
+ */
+class CacheFieldXform extends BaseXform {
+    constructor() {
+        super();
+        this.model = null;
+        this.inSharedItems = false;
+    }
+    get tag() {
+        return "cacheField";
+    }
+    reset() {
+        this.model = null;
+        this.inSharedItems = false;
+    }
+    parseOpen(node) {
+        const { name, attributes } = node;
+        switch (name) {
+            case "cacheField":
+                // Initialize the model with field name
+                this.model = {
+                    name: xmlDecode(attributes.name || ""),
+                    sharedItems: null
+                };
+                break;
+            case "sharedItems":
+                this.inSharedItems = true;
+                // Store numeric field metadata
+                if (this.model) {
+                    this.model.containsNumber = attributes.containsNumber === "1";
+                    this.model.containsInteger = attributes.containsInteger === "1";
+                    if (attributes.minValue !== undefined) {
+                        this.model.minValue = parseFloat(attributes.minValue);
+                    }
+                    if (attributes.maxValue !== undefined) {
+                        this.model.maxValue = parseFloat(attributes.maxValue);
+                    }
+                    // Initialize sharedItems array if count > 0 (for both string and numeric fields)
+                    const count = parseInt(attributes.count || "0", 10);
+                    if (count > 0) {
+                        this.model.sharedItems = [];
+                    }
+                    else {
+                        // No count means no individual items (pure numeric field)
+                        this.model.sharedItems = null;
+                    }
+                }
+                break;
+            case "s":
+                // String value in sharedItems
+                if (this.inSharedItems && this.model?.sharedItems !== null) {
+                    // Decode XML entities in the value
+                    const value = xmlDecode(attributes.v || "");
+                    this.model.sharedItems.push(value);
+                }
+                break;
+            case "n":
+                // Numeric value in sharedItems (less common, but possible)
+                if (this.inSharedItems && this.model?.sharedItems !== null) {
+                    const value = parseFloat(attributes.v || "0");
+                    this.model.sharedItems.push(value);
+                }
+                break;
+            case "b":
+                // Boolean value in sharedItems
+                if (this.inSharedItems && this.model?.sharedItems !== null) {
+                    const value = attributes.v === "1";
+                    this.model.sharedItems.push(value);
+                }
+                break;
+            case "e":
+                // Error value in sharedItems
+                if (this.inSharedItems && this.model?.sharedItems !== null) {
+                    const value = `#${attributes.v || "ERROR!"}`;
+                    this.model.sharedItems.push(value);
+                }
+                break;
+            case "m":
+                // Missing/null value in sharedItems
+                if (this.inSharedItems && this.model?.sharedItems !== null) {
+                    this.model.sharedItems.push(null);
+                }
+                break;
+            case "d":
+                // Date value in sharedItems
+                if (this.inSharedItems && this.model?.sharedItems !== null) {
+                    const value = new Date(attributes.v || "");
+                    this.model.sharedItems.push(value);
+                }
+                break;
+        }
+        return true;
+    }
+    parseText(_text) {
+        // No text content in cacheField elements
+    }
+    parseClose(name) {
+        switch (name) {
+            case "cacheField":
+                // End of this cacheField element
+                return false;
+            case "sharedItems":
+                this.inSharedItems = false;
+                break;
+        }
+        return true;
+    }
+}
+export { CacheFieldXform };

package/dist/esm/modules/excel/xlsx/xform/pivot-table/cache-field.js

@@ -0,0 +1,78 @@
+import { xmlEncode } from "../../../../../utils/utils.js";
+class CacheField {
+    constructor({ name, sharedItems, minValue, maxValue }) {
+        // string type
+        //
+        // {
+        //   'name': 'A',
+        //   'sharedItems': ['a1', 'a2', 'a3']
+        // }
+        //
+        // or
+        //
+        // integer type (no sharedItems)
+        //
+        // {
+        //   'name': 'D',
+        //   'sharedItems': null,
+        //   'minValue': 5,
+        //   'maxValue': 45
+        // }
+        //
+        // or
+        //
+        // numeric type with shared items (used as both row/column and value field)
+        //
+        // {
+        //   'name': 'C',
+        //   'sharedItems': [5, 24, 35, 45]
+        // }
+        this.name = name;
+        this.sharedItems = sharedItems;
+        this.minValue = minValue;
+        this.maxValue = maxValue;
+    }
+    render() {
+        // PivotCache Field: http://www.datypic.com/sc/ooxml/e-ssml_cacheField-1.html
+        // Shared Items: http://www.datypic.com/sc/ooxml/e-ssml_sharedItems-1.html
+        // Escape XML special characters in name attribute
+        const escapedName = xmlEncode(this.name);
+        // No shared items - field not used for rows/columns
+        if (this.sharedItems === null) {
+            // If no minValue/maxValue, this is an unused field - use empty sharedItems like Excel does
+            if (this.minValue === undefined || this.maxValue === undefined) {
+                return `<cacheField name="${escapedName}" numFmtId="0">
+      <sharedItems />
+    </cacheField>`;
+            }
+            // Numeric field used only for values (not rows/columns) - include min/max
+            return `<cacheField name="${escapedName}" numFmtId="0">
+      <sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1" containsInteger="1" minValue="${this.minValue}" maxValue="${this.maxValue}" />
+    </cacheField>`;
+        }
+        // Shared items exist - check if all values are numeric
+        // Note: empty array returns true for every(), so check length first
+        const allNumeric = this.sharedItems.length > 0 &&
+            this.sharedItems.every(item => typeof item === "number" && Number.isFinite(item));
+        const allInteger = allNumeric && this.sharedItems.every(item => Number.isInteger(item));
+        if (allNumeric) {
+            // Numeric shared items - used when field is both a row/column field AND a value field
+            // This allows Excel to both group by unique values AND perform aggregation
+            const minValue = Math.min(...this.sharedItems);
+            const maxValue = Math.max(...this.sharedItems);
+            const integerAttr = allInteger ? ' containsInteger="1"' : "";
+            return `<cacheField name="${escapedName}" numFmtId="0">
+      <sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1"${integerAttr} minValue="${minValue}" maxValue="${maxValue}" count="${this.sharedItems.length}">
+        ${this.sharedItems.map(item => `<n v="${item}" />`).join("")}
+      </sharedItems>
+    </cacheField>`;
+        }
+        // String shared items - escape XML special characters in each value
+        return `<cacheField name="${escapedName}" numFmtId="0">
+      <sharedItems count="${this.sharedItems.length}">
+        ${this.sharedItems.map(item => `<s v="${xmlEncode(String(item))}" />`).join("")}
+      </sharedItems>
+    </cacheField>`;
+    }
+}
+export { CacheField };