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

package/dist/cjs/xlsx/xform/simple/integer-xform.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegerXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+class IntegerXform extends base_xform_js_1.BaseXform {
+    constructor(options) {
+        super();
+        this.tag = options.tag;
+        this.attr = options.attr;
+        this.attrs = options.attrs;
+        // option to render zero
+        this.zero = options.zero;
+        this.text = [];
+    }
+    render(xmlStream, model) {
+        // int is different to float in that zero is not rendered
+        if (model || this.zero) {
+            xmlStream.openNode(this.tag);
+            if (this.attrs) {
+                xmlStream.addAttributes(this.attrs);
+            }
+            if (this.attr) {
+                xmlStream.addAttribute(this.attr, model);
+            }
+            else {
+                xmlStream.writeText(model);
+            }
+            xmlStream.closeNode();
+        }
+    }
+    parseOpen(node) {
+        if (node.name === this.tag) {
+            if (this.attr) {
+                this.model = parseInt(node.attributes[this.attr], 10);
+            }
+            else {
+                this.text = [];
+            }
+            return true;
+        }
+        return false;
+    }
+    parseText(text) {
+        if (!this.attr) {
+            this.text.push(text);
+        }
+    }
+    parseClose() {
+        if (!this.attr) {
+            this.model = parseInt(this.text.join("") || "0", 10);
+        }
+        return false;
+    }
+}
+exports.IntegerXform = IntegerXform;

package/dist/cjs/xlsx/xform/simple/string-xform.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+class StringXform extends base_xform_js_1.BaseXform {
+    constructor(options) {
+        super();
+        this.tag = options.tag;
+        this.attr = options.attr;
+        this.attrs = options.attrs;
+        this.text = [];
+    }
+    render(xmlStream, model) {
+        if (model !== undefined) {
+            xmlStream.openNode(this.tag);
+            if (this.attrs) {
+                xmlStream.addAttributes(this.attrs);
+            }
+            if (this.attr) {
+                xmlStream.addAttribute(this.attr, model);
+            }
+            else {
+                xmlStream.writeText(model);
+            }
+            xmlStream.closeNode();
+        }
+    }
+    parseOpen(node) {
+        if (node.name === this.tag) {
+            if (this.attr) {
+                this.model = node.attributes[this.attr];
+            }
+            else {
+                this.text = [];
+            }
+        }
+    }
+    parseText(text) {
+        if (!this.attr) {
+            this.text.push(text);
+        }
+    }
+    parseClose() {
+        if (!this.attr) {
+            this.model = this.text.join("");
+        }
+        return false;
+    }
+}
+exports.StringXform = StringXform;

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticXform = void 0;
+const base_xform_js_1 = require("./base-xform");
+const xml_stream_js_1 = require("../../utils/xml-stream");
+// const model = {
+//   tag: 'name',
+//   $: {attr: 'value'},
+//   c: [
+//     { tag: 'child' }
+//   ],
+//   t: 'some text'
+// };
+function build(xmlStream, model) {
+    xmlStream.openNode(model.tag, model.$);
+    if (model.c) {
+        model.c.forEach(child => {
+            build(xmlStream, child);
+        });
+    }
+    if (model.t) {
+        xmlStream.writeText(model.t);
+    }
+    xmlStream.closeNode();
+}
+class StaticXform extends base_xform_js_1.BaseXform {
+    constructor(model) {
+        super();
+        // This class is an optimisation for static (unimportant and unchanging) xml
+        // It is stateless - apart from its static model and so can be used as a singleton
+        // Being stateless - it will only track entry to and exit from it's root xml tag during parsing and nothing else
+        // Known issues:
+        //    since stateless - parseOpen always returns true. Parent xform must know when to start using this xform
+        //    if the root tag is recursive, the parsing will behave unpredictably
+        this._model = model;
+    }
+    render(xmlStream) {
+        if (!this._xml) {
+            const stream = new xml_stream_js_1.XmlStream();
+            build(stream, this._model);
+            this._xml = stream.xml;
+        }
+        xmlStream.writeXml(this._xml);
+    }
+    parseOpen() {
+        return true;
+    }
+    parseText() { }
+    parseClose(name) {
+        switch (name) {
+            case this._model.tag:
+                return false;
+            default:
+                return true;
+        }
+    }
+}
+exports.StaticXform = StaticXform;

package/dist/cjs/xlsx/xform/strings/phonetic-text-xform.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhoneticTextXform = void 0;
+const text_xform_js_1 = require("./text-xform");
+const rich_text_xform_js_1 = require("./rich-text-xform");
+const base_xform_js_1 = require("../base-xform");
+class PhoneticTextXform extends base_xform_js_1.BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            r: new rich_text_xform_js_1.RichTextXform(),
+            t: new text_xform_js_1.TextXform()
+        };
+    }
+    get tag() {
+        return "rPh";
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag, {
+            sb: model.sb || 0,
+            eb: model.eb || 0
+        });
+        if (model && Object.prototype.hasOwnProperty.call(model, "richText") && model.richText) {
+            const { r } = this.map;
+            model.richText.forEach(text => {
+                r.render(xmlStream, text);
+            });
+        }
+        else if (model) {
+            this.map.t.render(xmlStream, model.text);
+        }
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        const { name } = node;
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        if (name === this.tag) {
+            this.model = {
+                sb: parseInt(node.attributes.sb, 10),
+                eb: parseInt(node.attributes.eb, 10)
+            };
+            return true;
+        }
+        this.parser = this.map[name];
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        return false;
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                switch (name) {
+                    case "r": {
+                        let rt = this.model.richText;
+                        if (!rt) {
+                            rt = this.model.richText = [];
+                        }
+                        rt.push(this.parser.model);
+                        break;
+                    }
+                    case "t":
+                        this.model.text = this.parser.model;
+                        break;
+                    default:
+                        break;
+                }
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                return false;
+            default:
+                return true;
+        }
+    }
+}
+exports.PhoneticTextXform = PhoneticTextXform;

package/dist/cjs/xlsx/xform/strings/rich-text-xform.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RichTextXform = void 0;
+const text_xform_js_1 = require("./text-xform");
+const font_xform_js_1 = require("../style/font-xform");
+const base_xform_js_1 = require("../base-xform");
+class RichTextXform extends base_xform_js_1.BaseXform {
+    constructor(model) {
+        super();
+        this.model = model;
+    }
+    get tag() {
+        return "r";
+    }
+    get textXform() {
+        return this._textXform || (this._textXform = new text_xform_js_1.TextXform());
+    }
+    get fontXform() {
+        return this._fontXform || (this._fontXform = new font_xform_js_1.FontXform(RichTextXform.FONT_OPTIONS));
+    }
+    render(xmlStream, model) {
+        const renderModel = model || this.model;
+        xmlStream.openNode("r");
+        if (renderModel.font) {
+            this.fontXform.render(xmlStream, renderModel.font);
+        }
+        this.textXform.render(xmlStream, renderModel.text);
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case "r":
+                this.model = {};
+                return true;
+            case "t":
+                this.parser = this.textXform;
+                this.parser.parseOpen(node);
+                return true;
+            case "rPr":
+                this.parser = this.fontXform;
+                this.parser.parseOpen(node);
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    parseClose(name) {
+        switch (name) {
+            case "r":
+                return false;
+            case "t":
+                this.model.text = this.parser.model;
+                this.parser = undefined;
+                return true;
+            case "rPr":
+                this.model.font = this.parser.model;
+                this.parser = undefined;
+                return true;
+            default:
+                if (this.parser) {
+                    this.parser.parseClose(name);
+                }
+                return true;
+        }
+    }
+}
+exports.RichTextXform = RichTextXform;
+RichTextXform.FONT_OPTIONS = {
+    tagName: "rPr",
+    fontNameTag: "rFont"
+};

package/dist/cjs/xlsx/xform/strings/shared-string-xform.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedStringXform = void 0;
+const text_xform_js_1 = require("./text-xform");
+const rich_text_xform_js_1 = require("./rich-text-xform");
+const phonetic_text_xform_js_1 = require("./phonetic-text-xform");
+const base_xform_js_1 = require("../base-xform");
+class SharedStringXform extends base_xform_js_1.BaseXform {
+    constructor(model) {
+        super();
+        this.model = model;
+        this.map = {
+            r: new rich_text_xform_js_1.RichTextXform(),
+            t: new text_xform_js_1.TextXform(),
+            rPh: new phonetic_text_xform_js_1.PhoneticTextXform()
+        };
+    }
+    get tag() {
+        return "si";
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag);
+        if (model &&
+            typeof model === "object" &&
+            Object.prototype.hasOwnProperty.call(model, "richText") &&
+            model.richText) {
+            if (model.richText.length) {
+                model.richText.forEach(text => {
+                    this.map.r.render(xmlStream, text);
+                });
+            }
+            else {
+                this.map.t.render(xmlStream, "");
+            }
+        }
+        else if (model !== undefined && model !== null) {
+            this.map.t.render(xmlStream, model);
+        }
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        const { name } = node;
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        if (name === this.tag) {
+            this.model = {};
+            return true;
+        }
+        this.parser = this.map[name];
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        return false;
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                switch (name) {
+                    case "r": {
+                        let rt = this.model.richText;
+                        if (!rt) {
+                            rt = this.model.richText = [];
+                        }
+                        rt.push(this.parser.model);
+                        break;
+                    }
+                    case "t":
+                        this.model = this.parser.model;
+                        break;
+                    default:
+                        break;
+                }
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                return false;
+            default:
+                return true;
+        }
+    }
+}
+exports.SharedStringXform = SharedStringXform;

package/dist/cjs/xlsx/xform/strings/shared-strings-xform.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedStringsXform = void 0;
+const xml_stream_js_1 = require("../../../utils/xml-stream");
+const base_xform_js_1 = require("../base-xform");
+const shared_string_xform_js_1 = require("./shared-string-xform");
+class SharedStringsXform extends base_xform_js_1.BaseXform {
+    constructor(model) {
+        super();
+        this.model = model || {
+            values: [],
+            count: 0
+        };
+        this.hash = Object.create(null);
+        this.rich = Object.create(null);
+    }
+    get sharedStringXform() {
+        return this._sharedStringXform || (this._sharedStringXform = new shared_string_xform_js_1.SharedStringXform());
+    }
+    get values() {
+        return this.model.values;
+    }
+    get uniqueCount() {
+        return this.model.values.length;
+    }
+    get count() {
+        return this.model.count;
+    }
+    getString(index) {
+        return this.model.values[index];
+    }
+    add(value) {
+        return value.richText ? this.addRichText(value) : this.addText(value);
+    }
+    addText(value) {
+        let index = this.hash[value];
+        if (index === undefined) {
+            index = this.hash[value] = this.model.values.length;
+            this.model.values.push(value);
+        }
+        this.model.count++;
+        return index;
+    }
+    addRichText(value) {
+        // TODO: add WeakMap here
+        const xml = this.sharedStringXform.toXml(value);
+        let index = this.rich[xml];
+        if (index === undefined) {
+            index = this.rich[xml] = this.model.values.length;
+            this.model.values.push(value);
+        }
+        this.model.count++;
+        return index;
+    }
+    // <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+    // <sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="<%=totalRefs%>" uniqueCount="<%=count%>">
+    //   <si><t><%=text%></t></si>
+    //   <si><r><rPr></rPr><t></t></r></si>
+    // </sst>
+    render(xmlStream, model) {
+        const renderModel = model || this._values;
+        xmlStream.openXml(xml_stream_js_1.XmlStream.StdDocAttributes);
+        xmlStream.openNode("sst", {
+            xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
+            count: renderModel.count,
+            uniqueCount: renderModel.values.length
+        });
+        const sx = this.sharedStringXform;
+        renderModel.values.forEach(sharedString => {
+            sx.render(xmlStream, sharedString);
+        });
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case "sst":
+                return true;
+            case "si":
+                this.parser = this.sharedStringXform;
+                this.parser.parseOpen(node);
+                return true;
+            default:
+                throw new Error(`Unexpected xml node in parseOpen: ${JSON.stringify(node)}`);
+        }
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.model.values.push(this.parser.model);
+                this.model.count++;
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case "sst":
+                return false;
+            default:
+                throw new Error(`Unexpected xml node in parseClose: ${name}`);
+        }
+    }
+}
+exports.SharedStringsXform = SharedStringsXform;

package/dist/cjs/xlsx/xform/strings/text-xform.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+//   <t xml:space="preserve"> is </t>
+class TextXform extends base_xform_js_1.BaseXform {
+    get tag() {
+        return "t";
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode("t");
+        if (/^\s|\n|\s$/.test(model)) {
+            xmlStream.addAttribute("xml:space", "preserve");
+        }
+        xmlStream.writeText(model);
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case "t":
+                this._text = [];
+                this.model = ""; // Initialize model to empty string
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText(text) {
+        this._text.push(text);
+        // Update model immediately after receiving text
+        this.model = this._text
+            .join("")
+            .replace(/_x([0-9A-F]{4})_/g, ($0, $1) => String.fromCharCode(parseInt($1, 16)));
+    }
+    parseClose() {
+        return false;
+    }
+}
+exports.TextXform = TextXform;