@cj-tech-master/excelts 3.1.0-canary.20260102041828.82ed571 → 3.1.0

package/dist/cjs/xlsx/xform/drawing/ext-xform.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtXform = void 0;
+const base_xform_1 = require("../base-xform");
+/** https://en.wikipedia.org/wiki/Office_Open_XML_file_formats#DrawingML */
+const EMU_PER_PIXEL_AT_96_DPI = 9525;
+class ExtXform extends base_xform_1.BaseXform {
+    constructor(options) {
+        super();
+        this.tag = options.tag;
+        this.map = {};
+        this.model = { width: 0, height: 0 };
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag);
+        const width = Math.floor(model.width * EMU_PER_PIXEL_AT_96_DPI);
+        const height = Math.floor(model.height * EMU_PER_PIXEL_AT_96_DPI);
+        xmlStream.addAttribute("cx", width);
+        xmlStream.addAttribute("cy", height);
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (node.name === this.tag) {
+            this.model = {
+                width: parseInt(node.attributes.cx || "0", 10) / EMU_PER_PIXEL_AT_96_DPI,
+                height: parseInt(node.attributes.cy || "0", 10) / EMU_PER_PIXEL_AT_96_DPI
+            };
+            return true;
+        }
+        return false;
+    }
+    parseText(_text) { }
+    parseClose(_name) {
+        return false;
+    }
+}
+exports.ExtXform = ExtXform;

package/dist/cjs/xlsx/xform/drawing/hlink-click-xform.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HLinkClickXform = void 0;
+const base_xform_1 = require("../base-xform");
+class HLinkClickXform extends base_xform_1.BaseXform {
+    constructor() {
+        super();
+        this.model = {};
+    }
+    get tag() {
+        return "a:hlinkClick";
+    }
+    render(xmlStream, model) {
+        if (!(model.hyperlinks && model.hyperlinks.rId)) {
+            return;
+        }
+        xmlStream.leafNode(this.tag, {
+            "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+            "r:id": model.hyperlinks.rId,
+            tooltip: model.hyperlinks.tooltip
+        });
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case this.tag:
+                this.model = {
+                    hyperlinks: {
+                        rId: node.attributes["r:id"],
+                        tooltip: node.attributes.tooltip
+                    }
+                };
+                return true;
+            default:
+                return true;
+        }
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+exports.HLinkClickXform = HLinkClickXform;

package/dist/cjs/xlsx/xform/drawing/nv-pic-pr-xform.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NvPicPrXform = void 0;
+const base_xform_1 = require("../base-xform");
+const c_nv_pr_xform_1 = require("./c-nv-pr-xform");
+const c_nv_pic_pr_xform_1 = require("./c-nv-pic-pr-xform");
+class NvPicPrXform extends base_xform_1.BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            "xdr:cNvPr": new c_nv_pr_xform_1.CNvPrXform(),
+            "xdr:cNvPicPr": new c_nv_pic_pr_xform_1.CNvPicPrXform()
+        };
+    }
+    get tag() {
+        return "xdr:nvPicPr";
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag);
+        this.map["xdr:cNvPr"].render(xmlStream, model);
+        this.map["xdr:cNvPicPr"].render(xmlStream, model);
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case this.tag:
+                this.reset();
+                break;
+            default:
+                this.parser = this.map[node.name];
+                if (this.parser) {
+                    this.parser.parseOpen(node);
+                }
+                break;
+        }
+        return true;
+    }
+    parseText() { }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                this.model = this.map["xdr:cNvPr"].model;
+                return false;
+            default:
+                return true;
+        }
+    }
+}
+exports.NvPicPrXform = NvPicPrXform;

package/dist/cjs/xlsx/xform/drawing/one-cell-anchor-xform.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneCellAnchorXform = void 0;
+const base_cell_anchor_xform_1 = require("./base-cell-anchor-xform");
+const static_xform_1 = require("../static-xform");
+const cell_position_xform_1 = require("./cell-position-xform");
+const ext_xform_1 = require("./ext-xform");
+const pic_xform_1 = require("./pic-xform");
+class OneCellAnchorXform extends base_cell_anchor_xform_1.BaseCellAnchorXform {
+    constructor() {
+        super();
+        this.map = {
+            "xdr:from": new cell_position_xform_1.CellPositionXform({ tag: "xdr:from" }),
+            "xdr:ext": new ext_xform_1.ExtXform({ tag: "xdr:ext" }),
+            "xdr:pic": new pic_xform_1.PicXform(),
+            "xdr:clientData": new static_xform_1.StaticXform({ tag: "xdr:clientData" })
+        };
+    }
+    get tag() {
+        return "xdr:oneCellAnchor";
+    }
+    prepare(model, options) {
+        this.map["xdr:pic"].prepare(model.picture, options);
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag, { editAs: model.range.editAs || "oneCell" });
+        this.map["xdr:from"].render(xmlStream, model.range.tl);
+        this.map["xdr:ext"].render(xmlStream, model.range.ext);
+        this.map["xdr:pic"].render(xmlStream, model.picture);
+        this.map["xdr:clientData"].render(xmlStream, {});
+        xmlStream.closeNode();
+    }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                this.model.range.tl = this.map["xdr:from"].model;
+                this.model.range.ext = this.map["xdr:ext"].model;
+                this.model.picture = this.map["xdr:pic"].model;
+                return false;
+            default:
+                // could be some unrecognised tags
+                return true;
+        }
+    }
+    reconcile(model, options) {
+        model.medium = this.reconcilePicture(model.picture, options);
+    }
+}
+exports.OneCellAnchorXform = OneCellAnchorXform;

package/dist/cjs/xlsx/xform/drawing/pic-xform.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PicXform = void 0;
+const base_xform_1 = require("../base-xform");
+const static_xform_1 = require("../static-xform");
+const blip_fill_xform_1 = require("./blip-fill-xform");
+const nv_pic_pr_xform_1 = require("./nv-pic-pr-xform");
+const sp_pr_1 = require("./sp-pr");
+class PicXform extends base_xform_1.BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            "xdr:nvPicPr": new nv_pic_pr_xform_1.NvPicPrXform(),
+            "xdr:blipFill": new blip_fill_xform_1.BlipFillXform(),
+            "xdr:spPr": new static_xform_1.StaticXform(sp_pr_1.spPrJSON)
+        };
+    }
+    get tag() {
+        return "xdr:pic";
+    }
+    prepare(model, options) {
+        model.index = options.index + 1;
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag);
+        this.map["xdr:nvPicPr"].render(xmlStream, model);
+        this.map["xdr:blipFill"].render(xmlStream, model);
+        this.map["xdr:spPr"].render(xmlStream, model);
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case this.tag:
+                this.reset();
+                break;
+            default:
+                this.parser = this.map[node.name];
+                if (this.parser) {
+                    this.parser.parseOpen(node);
+                }
+                break;
+        }
+        return true;
+    }
+    parseText() { }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.mergeModel(this.parser.model);
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                return false;
+            default:
+                // not quite sure how we get here!
+                return true;
+        }
+    }
+}
+exports.PicXform = PicXform;

package/dist/cjs/xlsx/xform/drawing/two-cell-anchor-xform.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwoCellAnchorXform = void 0;
+const base_cell_anchor_xform_1 = require("./base-cell-anchor-xform");
+const static_xform_1 = require("../static-xform");
+const cell_position_xform_1 = require("./cell-position-xform");
+const pic_xform_1 = require("./pic-xform");
+class TwoCellAnchorXform extends base_cell_anchor_xform_1.BaseCellAnchorXform {
+    constructor() {
+        super();
+        this.map = {
+            "xdr:from": new cell_position_xform_1.CellPositionXform({ tag: "xdr:from" }),
+            "xdr:to": new cell_position_xform_1.CellPositionXform({ tag: "xdr:to" }),
+            "xdr:pic": new pic_xform_1.PicXform(),
+            "xdr:clientData": new static_xform_1.StaticXform({ tag: "xdr:clientData" })
+        };
+    }
+    get tag() {
+        return "xdr:twoCellAnchor";
+    }
+    prepare(model, options) {
+        this.map["xdr:pic"].prepare(model.picture, options);
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag, { editAs: model.range.editAs || "oneCell" });
+        this.map["xdr:from"].render(xmlStream, model.range.tl);
+        this.map["xdr:to"].render(xmlStream, model.range.br);
+        this.map["xdr:pic"].render(xmlStream, model.picture);
+        this.map["xdr:clientData"].render(xmlStream, {});
+        xmlStream.closeNode();
+    }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                this.model.range.tl = this.map["xdr:from"].model;
+                this.model.range.br = this.map["xdr:to"].model;
+                this.model.picture = this.map["xdr:pic"].model;
+                return false;
+            default:
+                // could be some unrecognised tags
+                return true;
+        }
+    }
+    reconcile(model, options) {
+        model.medium = this.reconcilePicture(model.picture, options);
+    }
+}
+exports.TwoCellAnchorXform = TwoCellAnchorXform;

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListXform = void 0;
+const base_xform_1 = require("./base-xform");
+class ListXform extends base_xform_1.BaseXform {
+    constructor(options) {
+        super();
+        this.tag = options.tag;
+        this.always = !!options.always;
+        this.count = options.count;
+        this.empty = options.empty;
+        this.$count = options.$count || "count";
+        this.$ = options.$;
+        this.childXform = options.childXform;
+        this.maxItems = options.maxItems;
+    }
+    prepare(model, options) {
+        const { childXform } = this;
+        if (model) {
+            model.forEach((childModel, index) => {
+                options.index = index;
+                childXform.prepare(childModel, options);
+            });
+        }
+    }
+    render(xmlStream, model) {
+        if (this.always || (model && model.length)) {
+            xmlStream.openNode(this.tag, this.$);
+            if (this.count) {
+                xmlStream.addAttribute(this.$count, (model && model.length) || 0);
+            }
+            const { childXform } = this;
+            (model || []).forEach((childModel, index) => {
+                childXform.render(xmlStream, childModel, index);
+            });
+            xmlStream.closeNode();
+        }
+        else if (this.empty) {
+            xmlStream.leafNode(this.tag);
+        }
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            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;
+        }
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.model.push(this.parser.model);
+                this.parser = undefined;
+                if (this.maxItems && this.model.length > this.maxItems) {
+                    throw new Error(`Max ${this.childXform.tag} count (${this.maxItems}) exceeded`);
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    reconcile(model, options) {
+        if (model) {
+            const { childXform } = this;
+            model.forEach((childModel) => {
+                childXform.reconcile(childModel, options);
+            });
+        }
+    }
+    reset() {
+        super.reset();
+        if (this.childXform) {
+            this.childXform.reset();
+        }
+    }
+}
+exports.ListXform = ListXform;

package/dist/cjs/xlsx/xform/pivot-table/cache-field-xform.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheFieldXform = void 0;
+const base_xform_1 = require("../base-xform");
+const utils_1 = require("../../../utils/utils");
+/**
+ * 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 base_xform_1.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: (0, utils_1.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 = (0, utils_1.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;
+    }
+}
+exports.CacheFieldXform = CacheFieldXform;

package/dist/cjs/xlsx/xform/pivot-table/cache-field.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheField = void 0;
+const utils_1 = require("../../../utils/utils");
+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 = (0, utils_1.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="${(0, utils_1.xmlEncode)(String(item))}" />`).join("")}
+      </sharedItems>
+    </cacheField>`;
+    }
+}
+exports.CacheField = CacheField;