@cj-tech-master/excelts 4.0.0 → 4.0.1-canary.20260104072032.0453bbe

package/dist/browser/modules/excel/xlsx/xform/simple/date-xform.js

@@ -0,0 +1,65 @@
+import { BaseXform } from "../base-xform.js";
+class DateXform extends BaseXform {
+    constructor(options) {
+        super();
+        this.tag = options.tag;
+        this.attr = options.attr;
+        this.attrs = options.attrs;
+        this.text = [];
+        this._format =
+            options.format ||
+                function (dt) {
+                    try {
+                        if (Number.isNaN(dt.getTime())) {
+                            return "";
+                        }
+                        return dt.toISOString();
+                    }
+                    catch {
+                        return "";
+                    }
+                };
+        this._parse =
+            options.parse ||
+                function (str) {
+                    return new Date(str);
+                };
+    }
+    render(xmlStream, model) {
+        if (model) {
+            xmlStream.openNode(this.tag);
+            if (this.attrs) {
+                xmlStream.addAttributes(this.attrs);
+            }
+            if (this.attr) {
+                xmlStream.addAttribute(this.attr, this._format(model));
+            }
+            else {
+                xmlStream.writeText(this._format(model));
+            }
+            xmlStream.closeNode();
+        }
+    }
+    parseOpen(node) {
+        if (node.name === this.tag) {
+            if (this.attr) {
+                this.model = this._parse(node.attributes[this.attr]);
+            }
+            else {
+                this.text = [];
+            }
+        }
+    }
+    parseText(text) {
+        if (!this.attr) {
+            this.text.push(text);
+        }
+    }
+    parseClose() {
+        if (!this.attr) {
+            this.model = this._parse(this.text.join(""));
+        }
+        return false;
+    }
+}
+export { DateXform };

package/dist/browser/modules/excel/xlsx/xform/simple/float-xform.d.ts

@@ -0,0 +1,18 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface FloatXformOptions {
+    tag: string;
+    attr?: string;
+    attrs?: any;
+}
+declare class FloatXform extends BaseXform {
+    private tag;
+    private attr?;
+    private attrs?;
+    private text;
+    constructor(options: FloatXformOptions);
+    render(xmlStream: any, model?: number): void;
+    parseOpen(node: any): void;
+    parseText(text: string): void;
+    parseClose(): boolean;
+}
+export { FloatXform };

package/dist/browser/modules/excel/xlsx/xform/simple/float-xform.js

@@ -0,0 +1,47 @@
+import { BaseXform } from "../base-xform.js";
+class FloatXform 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 = parseFloat(node.attributes[this.attr]);
+            }
+            else {
+                this.text = [];
+            }
+        }
+    }
+    parseText(text) {
+        if (!this.attr) {
+            this.text.push(text);
+        }
+    }
+    parseClose() {
+        if (!this.attr) {
+            this.model = parseFloat(this.text.join(""));
+        }
+        return false;
+    }
+}
+export { FloatXform };

package/dist/browser/modules/excel/xlsx/xform/simple/integer-xform.d.ts

@@ -0,0 +1,20 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface IntegerXformOptions {
+    tag: string;
+    attr?: string;
+    attrs?: any;
+    zero?: boolean;
+}
+declare class IntegerXform extends BaseXform {
+    private tag;
+    private attr?;
+    private attrs?;
+    private zero?;
+    private text;
+    constructor(options: IntegerXformOptions);
+    render(xmlStream: any, model?: number): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(): boolean;
+}
+export { IntegerXform };

package/dist/browser/modules/excel/xlsx/xform/simple/integer-xform.js

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

package/dist/browser/modules/excel/xlsx/xform/simple/string-xform.d.ts

@@ -0,0 +1,18 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface StringXformOptions {
+    tag: string;
+    attr?: string;
+    attrs?: any;
+}
+declare class StringXform extends BaseXform {
+    private tag;
+    private attr?;
+    private attrs?;
+    private text;
+    constructor(options: StringXformOptions);
+    render(xmlStream: any, model?: string): void;
+    parseOpen(node: any): void;
+    parseText(text: string): void;
+    parseClose(): boolean;
+}
+export { StringXform };

package/dist/browser/modules/excel/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/browser/modules/excel/xlsx/xform/static-xform.d.ts

@@ -0,0 +1,17 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface StaticModel {
+    tag: string;
+    $?: any;
+    c?: StaticModel[];
+    t?: string;
+}
+declare class StaticXform extends BaseXform {
+    private _model;
+    private _xml?;
+    constructor(model: StaticModel);
+    render(xmlStream: any): void;
+    parseOpen(): boolean;
+    parseText(): void;
+    parseClose(name: string): boolean;
+}
+export { StaticXform };

package/dist/browser/modules/excel/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 limitations:
+        //    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/browser/modules/excel/xlsx/xform/strings/phonetic-text-xform.d.ts

@@ -0,0 +1,20 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface PhoneticTextModel {
+    sb: number;
+    eb: number;
+    text?: string;
+    richText?: any[];
+}
+declare class PhoneticTextXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser: any;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: PhoneticTextModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+export { PhoneticTextXform };

package/dist/browser/modules/excel/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/browser/modules/excel/xlsx/xform/strings/rich-text-xform.d.ts

@@ -0,0 +1,25 @@
+import { TextXform } from "@excel/xlsx/xform/strings/text-xform";
+import { FontXform } from "@excel/xlsx/xform/style/font-xform";
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface RichTextModel {
+    font?: any;
+    text: string;
+}
+declare class RichTextXform extends BaseXform {
+    private _textXform?;
+    private _fontXform?;
+    parser: any;
+    constructor(model?: RichTextModel);
+    get tag(): string;
+    get textXform(): TextXform;
+    get fontXform(): FontXform;
+    render(xmlStream: any, model?: RichTextModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    static FONT_OPTIONS: {
+        tagName: string;
+        fontNameTag: string;
+    };
+}
+export { RichTextXform };

package/dist/browser/modules/excel/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/browser/modules/excel/xlsx/xform/strings/shared-string-xform.d.ts

@@ -0,0 +1,17 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+type SharedStringModel = string | {
+    richText: any[];
+};
+declare class SharedStringXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser: any;
+    constructor(model?: SharedStringModel);
+    get tag(): string;
+    render(xmlStream: any, model?: SharedStringModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+export { SharedStringXform };

package/dist/browser/modules/excel/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/browser/modules/excel/xlsx/xform/strings/shared-strings-xform.d.ts

@@ -0,0 +1,27 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import { SharedStringXform } from "@excel/xlsx/xform/strings/shared-string-xform";
+interface SharedStringsModel {
+    values: any[];
+    count: number;
+}
+declare class SharedStringsXform extends BaseXform {
+    private hash;
+    private rich;
+    parser: any;
+    private _sharedStringXform?;
+    private _values?;
+    constructor(model?: SharedStringsModel);
+    get sharedStringXform(): SharedStringXform;
+    get values(): any[];
+    get uniqueCount(): number;
+    get count(): number;
+    getString(index: number): any;
+    add(value: any): number;
+    addText(value: string): number;
+    addRichText(value: any): number;
+    render(xmlStream: any, model?: SharedStringsModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+export { SharedStringsXform };