@cj-tech-master/excelts 0.1.0-canary.20251025023400.dff1908

package/dist/esm/xlsx/xform/drawing/cell-position-xform.js

@@ -0,0 +1,68 @@
+import { BaseXform } from "../base-xform.js";
+import { IntegerXform } from "../simple/integer-xform.js";
+class CellPositionXform extends BaseXform {
+    constructor(options) {
+        super();
+        this.tag = options.tag;
+        this.map = {
+            "xdr:col": new IntegerXform({ tag: "xdr:col", zero: true }),
+            "xdr:colOff": new IntegerXform({ tag: "xdr:colOff", zero: true }),
+            "xdr:row": new IntegerXform({ tag: "xdr:row", zero: true }),
+            "xdr:rowOff": new IntegerXform({ tag: "xdr:rowOff", zero: true })
+        };
+        this.model = { nativeCol: 0, nativeColOff: 0, nativeRow: 0, nativeRowOff: 0 };
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag);
+        this.map["xdr:col"].render(xmlStream, model.nativeCol);
+        this.map["xdr:colOff"].render(xmlStream, model.nativeColOff);
+        this.map["xdr:row"].render(xmlStream, model.nativeRow);
+        this.map["xdr:rowOff"].render(xmlStream, model.nativeRowOff);
+        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(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                this.model = {
+                    nativeCol: this.map["xdr:col"].model,
+                    nativeColOff: this.map["xdr:colOff"].model,
+                    nativeRow: this.map["xdr:row"].model,
+                    nativeRowOff: this.map["xdr:rowOff"].model
+                };
+                return false;
+            default:
+                // not quite sure how we get here!
+                return true;
+        }
+    }
+}
+export { CellPositionXform };

package/dist/esm/xlsx/xform/drawing/drawing-xform.js

@@ -0,0 +1,96 @@
+import { colCache } from "../../../utils/col-cache.js";
+import { XmlStream } from "../../../utils/xml-stream.js";
+import { BaseXform } from "../base-xform.js";
+import { TwoCellAnchorXform } from "./two-cell-anchor-xform.js";
+import { OneCellAnchorXform } from "./one-cell-anchor-xform.js";
+function getAnchorType(model) {
+    const range = typeof model.range === "string" ? colCache.decode(model.range) : model.range;
+    return range.br ? "xdr:twoCellAnchor" : "xdr:oneCellAnchor";
+}
+class DrawingXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            "xdr:twoCellAnchor": new TwoCellAnchorXform(),
+            "xdr:oneCellAnchor": new OneCellAnchorXform()
+        };
+        this.model = { anchors: [] };
+    }
+    prepare(model) {
+        model.anchors.forEach((item, index) => {
+            item.anchorType = getAnchorType(item);
+            const anchor = this.map[item.anchorType];
+            anchor.prepare(item, { index });
+        });
+    }
+    get tag() {
+        return "xdr:wsDr";
+    }
+    render(xmlStream, model) {
+        const renderModel = model || this.model;
+        xmlStream.openXml(XmlStream.StdDocAttributes);
+        xmlStream.openNode(this.tag, DrawingXform.DRAWING_ATTRIBUTES);
+        renderModel.anchors.forEach(item => {
+            const anchor = this.map[item.anchorType];
+            anchor.render(xmlStream, item);
+        });
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case this.tag:
+                this.reset();
+                this.model = {
+                    anchors: []
+                };
+                break;
+            default:
+                this.parser = this.map[node.name];
+                if (this.parser) {
+                    this.parser.parseOpen(node);
+                }
+                break;
+        }
+        return true;
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.model.anchors.push(this.parser.model);
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                return false;
+            default:
+                // could be some unrecognised tags
+                return true;
+        }
+    }
+    reconcile(model, options) {
+        model.anchors.forEach(anchor => {
+            if (anchor.br) {
+                this.map["xdr:twoCellAnchor"].reconcile(anchor, options);
+            }
+            else {
+                this.map["xdr:oneCellAnchor"].reconcile(anchor, options);
+            }
+        });
+    }
+}
+DrawingXform.DRAWING_ATTRIBUTES = {
+    "xmlns:xdr": "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing",
+    "xmlns:a": "http://schemas.openxmlformats.org/drawingml/2006/main"
+};
+export { DrawingXform };

package/dist/esm/xlsx/xform/drawing/ext-lst-xform.js

@@ -0,0 +1,37 @@
+import { BaseXform } from "../base-xform.js";
+class ExtLstXform extends BaseXform {
+    get tag() {
+        return "a:extLst";
+    }
+    render(xmlStream) {
+        xmlStream.openNode(this.tag);
+        xmlStream.openNode("a:ext", {
+            uri: "{FF2B5EF4-FFF2-40B4-BE49-F238E27FC236}"
+        });
+        xmlStream.leafNode("a16:creationId", {
+            "xmlns:a16": "http://schemas.microsoft.com/office/drawing/2014/main",
+            id: "{00000000-0008-0000-0000-000002000000}"
+        });
+        xmlStream.closeNode();
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case this.tag:
+                return true;
+            default:
+                return true;
+        }
+    }
+    parseText() { }
+    parseClose(name) {
+        switch (name) {
+            case this.tag:
+                return false;
+            default:
+                // unprocessed internal nodes
+                return true;
+        }
+    }
+}
+export { ExtLstXform };

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

@@ -0,0 +1,34 @@
+import { BaseXform } from "../base-xform.js";
+/** https://en.wikipedia.org/wiki/Office_Open_XML_file_formats#DrawingML */
+const EMU_PER_PIXEL_AT_96_DPI = 9525;
+class ExtXform extends 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;
+    }
+}
+export { ExtXform };

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

@@ -0,0 +1,39 @@
+import { BaseXform } from "../base-xform.js";
+class HLinkClickXform extends 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;
+    }
+}
+export { HLinkClickXform };

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

@@ -0,0 +1,56 @@
+import { BaseXform } from "../base-xform.js";
+import { CNvPrXform } from "./c-nv-pr-xform.js";
+import { CNvPicPrXform } from "./c-nv-pic-pr-xform.js";
+class NvPicPrXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            "xdr:cNvPr": new CNvPrXform(),
+            "xdr:cNvPicPr": new 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;
+        }
+    }
+}
+export { NvPicPrXform };

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

@@ -0,0 +1,52 @@
+import { BaseCellAnchorXform } from "./base-cell-anchor-xform.js";
+import { StaticXform } from "../static-xform.js";
+import { CellPositionXform } from "./cell-position-xform.js";
+import { ExtXform } from "./ext-xform.js";
+import { PicXform } from "./pic-xform.js";
+class OneCellAnchorXform extends BaseCellAnchorXform {
+    constructor() {
+        super();
+        this.map = {
+            "xdr:from": new CellPositionXform({ tag: "xdr:from" }),
+            "xdr:ext": new ExtXform({ tag: "xdr:ext" }),
+            "xdr:pic": new PicXform(),
+            "xdr:clientData": new 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);
+    }
+}
+export { OneCellAnchorXform };

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

@@ -0,0 +1,64 @@
+import { BaseXform } from "../base-xform.js";
+import { StaticXform } from "../static-xform.js";
+import { BlipFillXform } from "./blip-fill-xform.js";
+import { NvPicPrXform } from "./nv-pic-pr-xform.js";
+import { spPrJSON } from "./sp-pr.js";
+class PicXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            "xdr:nvPicPr": new NvPicPrXform(),
+            "xdr:blipFill": new BlipFillXform(),
+            "xdr:spPr": new StaticXform(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;
+        }
+    }
+}
+export { PicXform };

package/dist/esm/xlsx/xform/drawing/sp-pr.js

@@ -0,0 +1,17 @@
+export const spPrJSON = {
+    tag: "xdr:spPr",
+    c: [
+        {
+            tag: "a:xfrm",
+            c: [
+                { tag: "a:off", $: { x: "0", y: "0" } },
+                { tag: "a:ext", $: { cx: "0", cy: "0" } }
+            ]
+        },
+        {
+            tag: "a:prstGeom",
+            $: { prst: "rect" },
+            c: [{ tag: "a:avLst" }]
+        }
+    ]
+};

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

@@ -0,0 +1,51 @@
+import { BaseCellAnchorXform } from "./base-cell-anchor-xform.js";
+import { StaticXform } from "../static-xform.js";
+import { CellPositionXform } from "./cell-position-xform.js";
+import { PicXform } from "./pic-xform.js";
+class TwoCellAnchorXform extends BaseCellAnchorXform {
+    constructor() {
+        super();
+        this.map = {
+            "xdr:from": new CellPositionXform({ tag: "xdr:from" }),
+            "xdr:to": new CellPositionXform({ tag: "xdr:to" }),
+            "xdr:pic": new PicXform(),
+            "xdr:clientData": new 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);
+    }
+}
+export { TwoCellAnchorXform };

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

@@ -0,0 +1,83 @@
+import { BaseXform } from "./base-xform.js";
+class ListXform extends 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);
+            });
+        }
+    }
+}
+export { ListXform };

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

@@ -0,0 +1,39 @@
+class CacheField {
+    constructor({ name, sharedItems }) {
+        // string type
+        //
+        // {
+        //   'name': 'A',
+        //   'sharedItems': ['a1', 'a2', 'a3']
+        // }
+        //
+        // or
+        //
+        // integer type
+        //
+        // {
+        //   'name': 'D',
+        //   'sharedItems': null
+        // }
+        this.name = name;
+        this.sharedItems = sharedItems;
+    }
+    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
+        // integer types
+        if (this.sharedItems === null) {
+            // TK(2023-07-18): left out attributes... minValue="5" maxValue="45"
+            return `<cacheField name="${this.name}" numFmtId="0">
+      <sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1" containsInteger="1" />
+    </cacheField>`;
+        }
+        // string types
+        return `<cacheField name="${this.name}" numFmtId="0">
+      <sharedItems count="${this.sharedItems.length}">
+        ${this.sharedItems.map(item => `<s v="${item}" />`).join("")}
+      </sharedItems>
+    </cacheField>`;
+    }
+}
+export { CacheField };