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

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

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommentXform = void 0;
+const rich_text_xform_js_1 = require("../strings/rich-text-xform");
+const base_xform_js_1 = require("../base-xform");
+class CommentXform extends base_xform_js_1.BaseXform {
+    constructor(model) {
+        super();
+        this.model = model || { type: "note", note: { texts: [] }, ref: "" };
+    }
+    get tag() {
+        return "r";
+    }
+    get richTextXform() {
+        if (!this._richTextXform) {
+            this._richTextXform = new rich_text_xform_js_1.RichTextXform();
+        }
+        return this._richTextXform;
+    }
+    render(xmlStream, model) {
+        const renderModel = model || this.model;
+        xmlStream.openNode("comment", {
+            ref: renderModel.ref,
+            authorId: 0
+        });
+        xmlStream.openNode("text");
+        if (renderModel && renderModel.note && renderModel.note.texts) {
+            renderModel.note.texts.forEach(text => {
+                this.richTextXform.render(xmlStream, text);
+            });
+        }
+        xmlStream.closeNode();
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case "comment":
+                this.model = {
+                    type: "note",
+                    note: {
+                        texts: []
+                    },
+                    ...node.attributes
+                };
+                return true;
+            case "r":
+                this.parser = this.richTextXform;
+                this.parser.parseOpen(node);
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    parseClose(name) {
+        switch (name) {
+            case "comment":
+                return false;
+            case "r":
+                this.model.note.texts.push(this.parser.model);
+                this.parser = undefined;
+                return true;
+            default:
+                if (this.parser) {
+                    this.parser.parseClose(name);
+                }
+                return true;
+        }
+    }
+}
+exports.CommentXform = CommentXform;

package/dist/cjs/xlsx/xform/comment/comments-xform.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommentsXform = void 0;
+const xml_stream_js_1 = require("../../../utils/xml-stream");
+const base_xform_js_1 = require("../base-xform");
+const comment_xform_js_1 = require("./comment-xform");
+class CommentsXform extends base_xform_js_1.BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            comment: new comment_xform_js_1.CommentXform()
+        };
+        this.model = { comments: [] };
+    }
+    render(xmlStream, model) {
+        const renderModel = model || this.model;
+        xmlStream.openXml(xml_stream_js_1.XmlStream.StdDocAttributes);
+        xmlStream.openNode("comments", CommentsXform.COMMENTS_ATTRIBUTES);
+        // authors
+        // TODO: support authors properly
+        xmlStream.openNode("authors");
+        xmlStream.leafNode("author", null, "Author");
+        xmlStream.closeNode();
+        // comments
+        xmlStream.openNode("commentList");
+        renderModel.comments.forEach(comment => {
+            this.map.comment.render(xmlStream, comment);
+        });
+        xmlStream.closeNode();
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case "commentList":
+                this.model = {
+                    comments: []
+                };
+                return true;
+            case "comment":
+                this.parser = this.map.comment;
+                this.parser.parseOpen(node);
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    parseClose(name) {
+        switch (name) {
+            case "commentList":
+                return false;
+            case "comment":
+                this.model.comments.push(this.parser.model);
+                this.parser = undefined;
+                return true;
+            default:
+                if (this.parser) {
+                    this.parser.parseClose(name);
+                }
+                return true;
+        }
+    }
+}
+exports.CommentsXform = CommentsXform;
+CommentsXform.COMMENTS_ATTRIBUTES = {
+    xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+};

package/dist/cjs/xlsx/xform/comment/style/vml-position-xform.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VmlPositionXform = void 0;
+const base_xform_js_1 = require("../../base-xform");
+class VmlPositionXform extends base_xform_js_1.BaseXform {
+    constructor(model) {
+        super();
+        this._model = model || {};
+        this.model = {};
+    }
+    get tag() {
+        return (this._model && this._model.tag) || "";
+    }
+    render(xmlStream, model, type) {
+        if (type && model === type[2]) {
+            xmlStream.leafNode(this.tag);
+        }
+        else if (type && this.tag === "x:SizeWithCells" && model === type[1]) {
+            xmlStream.leafNode(this.tag);
+        }
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case this.tag:
+                this.model = {};
+                this.model[this.tag] = true;
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+exports.VmlPositionXform = VmlPositionXform;

package/dist/cjs/xlsx/xform/comment/style/vml-protection-xform.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VmlProtectionXform = void 0;
+const base_xform_js_1 = require("../../base-xform");
+class VmlProtectionXform extends base_xform_js_1.BaseXform {
+    constructor(model) {
+        super();
+        this._model = model || {};
+        this.text = "";
+    }
+    get tag() {
+        return (this._model && this._model.tag) || "";
+    }
+    render(xmlStream, model) {
+        xmlStream.leafNode(this.tag, null, model);
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case this.tag:
+                this.text = "";
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText(text) {
+        this.text = text;
+    }
+    parseClose() {
+        return false;
+    }
+}
+exports.VmlProtectionXform = VmlProtectionXform;

package/dist/cjs/xlsx/xform/comment/vml-anchor-xform.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VmlAnchorXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+// render the triangle in the cell for the comment
+class VmlAnchorXform extends base_xform_js_1.BaseXform {
+    constructor() {
+        super();
+        this.text = "";
+    }
+    get tag() {
+        return "x:Anchor";
+    }
+    getAnchorRect(anchor) {
+        const l = Math.floor(anchor.left);
+        const lf = Math.floor((anchor.left - l) * 68);
+        const t = Math.floor(anchor.top);
+        const tf = Math.floor((anchor.top - t) * 18);
+        const r = Math.floor(anchor.right);
+        const rf = Math.floor((anchor.right - r) * 68);
+        const b = Math.floor(anchor.bottom);
+        const bf = Math.floor((anchor.bottom - b) * 18);
+        return [l, lf, t, tf, r, rf, b, bf];
+    }
+    getDefaultRect(ref) {
+        const l = ref.col;
+        const lf = 6;
+        const t = Math.max(ref.row - 2, 0);
+        const tf = 14;
+        const r = l + 2;
+        const rf = 2;
+        const b = t + 4;
+        const bf = 16;
+        return [l, lf, t, tf, r, rf, b, bf];
+    }
+    render(xmlStream, model) {
+        const rect = model.anchor
+            ? this.getAnchorRect(model.anchor)
+            : this.getDefaultRect(model.refAddress);
+        xmlStream.leafNode("x:Anchor", null, rect.join(", "));
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case this.tag:
+                this.text = "";
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText(text) {
+        this.text = text;
+    }
+    parseClose() {
+        return false;
+    }
+}
+exports.VmlAnchorXform = VmlAnchorXform;

package/dist/cjs/xlsx/xform/comment/vml-client-data-xform.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VmlClientDataXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+const vml_anchor_xform_js_1 = require("./vml-anchor-xform");
+const vml_protection_xform_js_1 = require("./style/vml-protection-xform");
+const vml_position_xform_js_1 = require("./style/vml-position-xform");
+const POSITION_TYPE = ["twoCells", "oneCells", "absolute"];
+class VmlClientDataXform extends base_xform_js_1.BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            "x:Anchor": new vml_anchor_xform_js_1.VmlAnchorXform(),
+            "x:Locked": new vml_protection_xform_js_1.VmlProtectionXform({ tag: "x:Locked" }),
+            "x:LockText": new vml_protection_xform_js_1.VmlProtectionXform({ tag: "x:LockText" }),
+            "x:SizeWithCells": new vml_position_xform_js_1.VmlPositionXform({ tag: "x:SizeWithCells" }),
+            "x:MoveWithCells": new vml_position_xform_js_1.VmlPositionXform({ tag: "x:MoveWithCells" })
+        };
+        this.model = { anchor: [], protection: {}, editAs: "" };
+    }
+    get tag() {
+        return "x:ClientData";
+    }
+    render(xmlStream, model) {
+        const { protection, editAs } = model.note;
+        xmlStream.openNode(this.tag, { ObjectType: "Note" });
+        this.map["x:MoveWithCells"].render(xmlStream, editAs, POSITION_TYPE);
+        this.map["x:SizeWithCells"].render(xmlStream, editAs, POSITION_TYPE);
+        this.map["x:Anchor"].render(xmlStream, model);
+        this.map["x:Locked"].render(xmlStream, protection.locked);
+        xmlStream.leafNode("x:AutoFill", null, "False");
+        this.map["x:LockText"].render(xmlStream, protection.lockText);
+        xmlStream.leafNode("x:Row", null, model.refAddress.row - 1);
+        xmlStream.leafNode("x:Column", null, model.refAddress.col - 1);
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case this.tag:
+                this.reset();
+                this.model = {
+                    anchor: [],
+                    protection: {},
+                    editAs: ""
+                };
+                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.normalizeModel();
+                return false;
+            default:
+                return true;
+        }
+    }
+    normalizeModel() {
+        const position = Object.assign({}, this.map["x:MoveWithCells"].model, this.map["x:SizeWithCells"].model);
+        const len = Object.keys(position).length;
+        this.model.editAs = POSITION_TYPE[len];
+        this.model.anchor = this.map["x:Anchor"].text;
+        this.model.protection.locked = this.map["x:Locked"].text;
+        this.model.protection.lockText = this.map["x:LockText"].text;
+    }
+}
+exports.VmlClientDataXform = VmlClientDataXform;

package/dist/cjs/xlsx/xform/comment/vml-notes-xform.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VmlNotesXform = void 0;
+const xml_stream_js_1 = require("../../../utils/xml-stream");
+const base_xform_js_1 = require("../base-xform");
+const vml_shape_xform_js_1 = require("./vml-shape-xform");
+// This class is (currently) single purposed to insert the triangle
+// drawing icons on commented cells
+class VmlNotesXform extends base_xform_js_1.BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            "v:shape": new vml_shape_xform_js_1.VmlShapeXform()
+        };
+        this.model = { comments: [] };
+    }
+    get tag() {
+        return "xml";
+    }
+    render(xmlStream, model) {
+        const renderModel = model || this.model;
+        xmlStream.openXml(xml_stream_js_1.XmlStream.StdDocAttributes);
+        xmlStream.openNode(this.tag, VmlNotesXform.DRAWING_ATTRIBUTES);
+        xmlStream.openNode("o:shapelayout", { "v:ext": "edit" });
+        xmlStream.leafNode("o:idmap", { "v:ext": "edit", data: 1 });
+        xmlStream.closeNode();
+        xmlStream.openNode("v:shapetype", {
+            id: "_x0000_t202",
+            coordsize: "21600,21600",
+            "o:spt": 202,
+            path: "m,l,21600r21600,l21600,xe"
+        });
+        xmlStream.leafNode("v:stroke", { joinstyle: "miter" });
+        xmlStream.leafNode("v:path", { gradientshapeok: "t", "o:connecttype": "rect" });
+        xmlStream.closeNode();
+        renderModel.comments.forEach((item, index) => {
+            this.map["v:shape"].render(xmlStream, item, index);
+        });
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case this.tag:
+                this.reset();
+                this.model = {
+                    comments: []
+                };
+                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.comments.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);
+            }
+        });
+    }
+}
+exports.VmlNotesXform = VmlNotesXform;
+VmlNotesXform.DRAWING_ATTRIBUTES = {
+    "xmlns:v": "urn:schemas-microsoft-com:vml",
+    "xmlns:o": "urn:schemas-microsoft-com:office:office",
+    "xmlns:x": "urn:schemas-microsoft-com:office:excel"
+};

package/dist/cjs/xlsx/xform/comment/vml-shape-xform.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VmlShapeXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+const vml_textbox_xform_js_1 = require("./vml-textbox-xform");
+const vml_client_data_xform_js_1 = require("./vml-client-data-xform");
+class VmlShapeXform extends base_xform_js_1.BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            "v:textbox": new vml_textbox_xform_js_1.VmlTextboxXform(),
+            "x:ClientData": new vml_client_data_xform_js_1.VmlClientDataXform()
+        };
+    }
+    get tag() {
+        return "v:shape";
+    }
+    render(xmlStream, model, index) {
+        xmlStream.openNode("v:shape", VmlShapeXform.V_SHAPE_ATTRIBUTES(model, index || 0));
+        xmlStream.leafNode("v:fill", { color2: "infoBackground [80]" });
+        xmlStream.leafNode("v:shadow", { color: "none [81]", obscured: "t" });
+        xmlStream.leafNode("v:path", { "o:connecttype": "none" });
+        this.map["v:textbox"].render(xmlStream, model);
+        this.map["x:ClientData"].render(xmlStream, model);
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case this.tag:
+                this.reset();
+                this.model = {
+                    margins: {
+                        insetmode: node.attributes["o:insetmode"]
+                    },
+                    anchor: "",
+                    editAs: "",
+                    protection: {}
+                };
+                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.margins.inset = this.map["v:textbox"].model && this.map["v:textbox"].model.inset;
+                this.model.protection =
+                    this.map["x:ClientData"].model && this.map["x:ClientData"].model.protection;
+                this.model.anchor = this.map["x:ClientData"].model && this.map["x:ClientData"].model.anchor;
+                this.model.editAs = this.map["x:ClientData"].model && this.map["x:ClientData"].model.editAs;
+                return false;
+            default:
+                return true;
+        }
+    }
+}
+exports.VmlShapeXform = VmlShapeXform;
+VmlShapeXform.V_SHAPE_ATTRIBUTES = (model, index) => ({
+    id: `_x0000_s${1025 + index}`,
+    type: "#_x0000_t202",
+    style: "position:absolute; margin-left:105.3pt;margin-top:10.5pt;width:97.8pt;height:59.1pt;z-index:1;visibility:hidden",
+    fillcolor: "infoBackground [80]",
+    strokecolor: "none [81]",
+    "o:insetmode": model.note.margins && model.note.margins.insetmode
+});

package/dist/cjs/xlsx/xform/comment/vml-textbox-xform.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VmlTextboxXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+class VmlTextboxXform extends base_xform_js_1.BaseXform {
+    constructor() {
+        super();
+        this.model = {};
+    }
+    get tag() {
+        return "v:textbox";
+    }
+    conversionUnit(value, multiple, unit) {
+        return `${(parseFloat(value.toString()) * multiple).toFixed(2)}${unit}`;
+    }
+    reverseConversionUnit(inset) {
+        return (inset || "").split(",").map(margin => {
+            return Number(parseFloat(this.conversionUnit(parseFloat(margin), 0.1, "")).toFixed(2));
+        });
+    }
+    render(xmlStream, model) {
+        const attributes = {
+            style: "mso-direction-alt:auto"
+        };
+        if (model && model.note) {
+            let { inset } = (model.note && model.note.margins) || {};
+            if (Array.isArray(inset)) {
+                inset = inset
+                    .map(margin => {
+                    return this.conversionUnit(margin, 10, "mm");
+                })
+                    .join(",");
+            }
+            if (inset) {
+                attributes.inset = inset;
+            }
+        }
+        xmlStream.openNode("v:textbox", attributes);
+        xmlStream.leafNode("div", { style: "text-align:left" });
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case this.tag:
+                this.model = {
+                    inset: this.reverseConversionUnit(node.attributes.inset)
+                };
+                return true;
+            default:
+                return true;
+        }
+    }
+    parseText() { }
+    parseClose(name) {
+        switch (name) {
+            case this.tag:
+                return false;
+            default:
+                return true;
+        }
+    }
+}
+exports.VmlTextboxXform = VmlTextboxXform;

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeXform = void 0;
+const base_xform_js_1 = require("./base-xform");
+/* 'virtual' methods used as a form of documentation */
+// base class for xforms that are composed of other xforms
+// offers some default implementations
+class CompositeXform extends base_xform_js_1.BaseXform {
+    createNewModel(_node) {
+        return {};
+    }
+    parseOpen(node) {
+        // Typical pattern for composite xform
+        this.parser = this.parser || this.map[node.name];
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        if (node.name === this.tag) {
+            this.model = this.createNewModel(node);
+            return true;
+        }
+        return false;
+    }
+    parseText(text) {
+        // Default implementation. Send text to child parser
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    onParserClose(name, parser) {
+        // parseClose has seen a child parser close
+        // now need to incorporate into this.model somehow
+        this.model[name] = parser.model;
+    }
+    parseClose(name) {
+        // Default implementation
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.onParserClose(name, this.parser);
+                this.parser = undefined;
+            }
+            return true;
+        }
+        return name !== this.tag;
+    }
+    get tag() {
+        return "";
+    }
+}
+exports.CompositeXform = CompositeXform;