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

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

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

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

@@ -0,0 +1,55 @@
+import { BaseXform } from "./base-xform.js";
+import { XmlStream } from "../../utils/xml-stream.js";
+// 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 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 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;
+        }
+    }
+}
+export { StaticXform };

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

@@ -0,0 +1,86 @@
+import { TextXform } from "./text-xform.js";
+import { RichTextXform } from "./rich-text-xform.js";
+import { BaseXform } from "../base-xform.js";
+class PhoneticTextXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            r: new RichTextXform(),
+            t: new 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;
+        }
+    }
+}
+export { PhoneticTextXform };

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

@@ -0,0 +1,77 @@
+import { TextXform } from "./text-xform.js";
+import { FontXform } from "../style/font-xform.js";
+import { BaseXform } from "../base-xform.js";
+class RichTextXform extends BaseXform {
+    constructor(model) {
+        super();
+        this.model = model;
+    }
+    get tag() {
+        return "r";
+    }
+    get textXform() {
+        return this._textXform || (this._textXform = new TextXform());
+    }
+    get fontXform() {
+        return this._fontXform || (this._fontXform = new 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;
+        }
+    }
+}
+RichTextXform.FONT_OPTIONS = {
+    tagName: "rPr",
+    fontNameTag: "rFont"
+};
+export { RichTextXform };

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

@@ -0,0 +1,90 @@
+import { TextXform } from "./text-xform.js";
+import { RichTextXform } from "./rich-text-xform.js";
+import { PhoneticTextXform } from "./phonetic-text-xform.js";
+import { BaseXform } from "../base-xform.js";
+class SharedStringXform extends BaseXform {
+    constructor(model) {
+        super();
+        this.model = model;
+        this.map = {
+            r: new RichTextXform(),
+            t: new TextXform(),
+            rPh: new 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;
+        }
+    }
+}
+export { SharedStringXform };

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

@@ -0,0 +1,109 @@
+import { XmlStream } from "../../../utils/xml-stream.js";
+import { BaseXform } from "../base-xform.js";
+import { SharedStringXform } from "./shared-string-xform.js";
+class SharedStringsXform extends 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 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(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}`);
+        }
+    }
+}
+export { SharedStringsXform };

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

@@ -0,0 +1,36 @@
+import { BaseXform } from "../base-xform.js";
+//   <t xml:space="preserve"> is </t>
+class TextXform extends 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;
+    }
+}
+export { TextXform };

package/dist/esm/xlsx/xform/style/alignment-xform.js

@@ -0,0 +1,152 @@
+import { BaseXform } from "../base-xform.js";
+import { validInt, parseBoolean } from "../../../utils/utils.js";
+const Enums = {
+    ReadingOrder: {
+        LeftToRight: 1,
+        RightToLeft: 2
+    }
+};
+const validation = {
+    horizontalValues: [
+        "left",
+        "center",
+        "right",
+        "fill",
+        "centerContinuous",
+        "distributed",
+        "justify"
+    ].reduce((p, v) => {
+        p[v] = true;
+        return p;
+    }, {}),
+    horizontal(value) {
+        return this.horizontalValues[value] ? value : undefined;
+    },
+    verticalValues: ["top", "middle", "bottom", "distributed", "justify"].reduce((p, v) => {
+        p[v] = true;
+        return p;
+    }, {}),
+    vertical(value) {
+        if (value === "middle") {
+            return "center";
+        }
+        return this.verticalValues[value] ? value : undefined;
+    },
+    wrapText(value) {
+        return value ? true : undefined;
+    },
+    shrinkToFit(value) {
+        return value ? true : undefined;
+    },
+    textRotation(value) {
+        switch (value) {
+            case "vertical":
+                return value;
+            default: {
+                const numValue = validInt(value);
+                return numValue !== undefined && numValue >= -90 && numValue <= 90 ? numValue : undefined;
+            }
+        }
+    },
+    indent(value) {
+        const numValue = validInt(value);
+        return Math.max(0, numValue);
+    },
+    readingOrder(value) {
+        switch (value) {
+            case "ltr":
+                return Enums.ReadingOrder.LeftToRight;
+            case "rtl":
+                return Enums.ReadingOrder.RightToLeft;
+            default:
+                return undefined;
+        }
+    }
+};
+const textRotationXform = {
+    toXml(textRotation) {
+        const validated = validation.textRotation(textRotation);
+        if (validated) {
+            if (validated === "vertical") {
+                return 255;
+            }
+            const tr = Math.round(validated);
+            if (tr >= 0 && tr <= 90) {
+                return tr;
+            }
+            if (tr < 0 && tr >= -90) {
+                return 90 - tr;
+            }
+        }
+        return undefined;
+    },
+    toModel(textRotation) {
+        const tr = validInt(textRotation);
+        if (tr !== undefined) {
+            if (tr === 255) {
+                return "vertical";
+            }
+            if (tr >= 0 && tr <= 90) {
+                return tr;
+            }
+            if (tr > 90 && tr <= 180) {
+                return 90 - tr;
+            }
+        }
+        return undefined;
+    }
+};
+// Alignment encapsulates translation from style.alignment model to/from xlsx
+class AlignmentXform extends BaseXform {
+    get tag() {
+        return "alignment";
+    }
+    render(xmlStream, model) {
+        xmlStream.addRollback();
+        xmlStream.openNode("alignment");
+        let isValid = false;
+        function add(name, value) {
+            if (value) {
+                xmlStream.addAttribute(name, value);
+                isValid = true;
+            }
+        }
+        add("horizontal", validation.horizontal(model.horizontal));
+        add("vertical", validation.vertical(model.vertical));
+        add("wrapText", validation.wrapText(model.wrapText) ? "1" : false);
+        add("shrinkToFit", validation.shrinkToFit(model.shrinkToFit) ? "1" : false);
+        add("indent", validation.indent(model.indent));
+        add("textRotation", textRotationXform.toXml(model.textRotation));
+        add("readingOrder", validation.readingOrder(model.readingOrder));
+        xmlStream.closeNode();
+        if (isValid) {
+            xmlStream.commit();
+        }
+        else {
+            xmlStream.rollback();
+        }
+    }
+    parseOpen(node) {
+        const model = {};
+        let valid = false;
+        function add(truthy, name, value) {
+            if (truthy) {
+                model[name] = value;
+                valid = true;
+            }
+        }
+        add(node.attributes.horizontal, "horizontal", node.attributes.horizontal);
+        add(node.attributes.vertical, "vertical", node.attributes.vertical === "center" ? "middle" : node.attributes.vertical);
+        add(node.attributes.wrapText, "wrapText", parseBoolean(node.attributes.wrapText));
+        add(node.attributes.shrinkToFit, "shrinkToFit", parseBoolean(node.attributes.shrinkToFit));
+        add(node.attributes.indent, "indent", parseInt(node.attributes.indent, 10));
+        add(node.attributes.textRotation, "textRotation", textRotationXform.toModel(node.attributes.textRotation));
+        add(node.attributes.readingOrder, "readingOrder", node.attributes.readingOrder === "2" ? "rtl" : "ltr");
+        this.model = valid ? model : null;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { AlignmentXform };