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

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

@@ -0,0 +1,10 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+declare class TextXform extends BaseXform {
+    private _text;
+    get tag(): string;
+    render(xmlStream: any, model: string): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(): boolean;
+}
+export { TextXform };

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

@@ -0,0 +1,18 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface AlignmentModel {
+    horizontal?: string;
+    vertical?: string;
+    wrapText?: boolean;
+    shrinkToFit?: boolean;
+    indent?: number;
+    textRotation?: number | "vertical";
+    readingOrder?: "ltr" | "rtl";
+}
+declare class AlignmentXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model: AlignmentModel): void;
+    parseOpen(node: any): void;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { AlignmentXform };

package/dist/browser/modules/excel/xlsx/xform/style/alignment-xform.js

@@ -0,0 +1,152 @@
+import { BaseXform } from "../base-xform.js";
+import { validInt, parseBoolean } from "../../../../../utils/utils.browser.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 };

package/dist/browser/modules/excel/xlsx/xform/style/border-xform.d.ts

@@ -0,0 +1,49 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import { ColorXform } from "@excel/xlsx/xform/style/color-xform";
+interface EdgeModel {
+    style?: string;
+    color?: any;
+}
+interface BorderModel {
+    top?: EdgeModel;
+    left?: EdgeModel;
+    bottom?: EdgeModel;
+    right?: EdgeModel;
+    diagonal?: EdgeModel & {
+        up?: boolean;
+        down?: boolean;
+    };
+    color?: any;
+}
+declare class EdgeXform extends BaseXform {
+    private name;
+    map: {
+        color: ColorXform;
+    };
+    private defaultColor;
+    parser: any;
+    constructor(name: string);
+    get tag(): string;
+    render(xmlStream: any, model?: EdgeModel, defaultColor?: any): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    validStyle(value: string): boolean;
+    static validStyleValues: {
+        [key: string]: boolean;
+    };
+}
+declare class BorderXform extends BaseXform {
+    map: {
+        [key: string]: EdgeXform;
+    };
+    parser: any;
+    private diagonalUp;
+    private diagonalDown;
+    constructor();
+    render(xmlStream: any, model: BorderModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+export { BorderXform };

package/dist/browser/modules/excel/xlsx/xform/style/border-xform.js

@@ -0,0 +1,188 @@
+import { BaseXform } from "../base-xform.js";
+import { parseBoolean } from "../../../../../utils/utils.browser.js";
+import { ColorXform } from "./color-xform.js";
+class EdgeXform extends BaseXform {
+    constructor(name) {
+        super();
+        this.name = name;
+        this.map = {
+            color: new ColorXform()
+        };
+    }
+    get tag() {
+        return this.name;
+    }
+    render(xmlStream, model, defaultColor) {
+        const color = (model && model.color) || defaultColor || this.defaultColor;
+        xmlStream.openNode(this.name);
+        if (model && model.style) {
+            xmlStream.addAttribute("style", model.style);
+            if (color) {
+                this.map.color.render(xmlStream, color);
+            }
+        }
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case this.name: {
+                const { style } = node.attributes;
+                if (style) {
+                    this.model = {
+                        style
+                    };
+                }
+                else {
+                    this.model = undefined;
+                }
+                return true;
+            }
+            case "color":
+                this.parser = this.map.color;
+                this.parser.parseOpen(node);
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.parser = undefined;
+            }
+            return true;
+        }
+        if (name === this.name) {
+            if (this.map.color.model) {
+                if (!this.model) {
+                    this.model = {};
+                }
+                this.model.color = this.map.color.model;
+            }
+        }
+        return false;
+    }
+    validStyle(value) {
+        return EdgeXform.validStyleValues[value];
+    }
+}
+EdgeXform.validStyleValues = [
+    "thin",
+    "dashed",
+    "dotted",
+    "dashDot",
+    "hair",
+    "dashDotDot",
+    "slantDashDot",
+    "mediumDashed",
+    "mediumDashDotDot",
+    "mediumDashDot",
+    "medium",
+    "double",
+    "thick"
+].reduce((p, v) => {
+    p[v] = true;
+    return p;
+}, {});
+// Border encapsulates translation from border model to/from xlsx
+class BorderXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            top: new EdgeXform("top"),
+            left: new EdgeXform("left"),
+            bottom: new EdgeXform("bottom"),
+            right: new EdgeXform("right"),
+            diagonal: new EdgeXform("diagonal")
+        };
+    }
+    render(xmlStream, model) {
+        const { color } = model;
+        xmlStream.openNode("border");
+        if (model.diagonal && model.diagonal.style) {
+            if (model.diagonal.up) {
+                xmlStream.addAttribute("diagonalUp", "1");
+            }
+            if (model.diagonal.down) {
+                xmlStream.addAttribute("diagonalDown", "1");
+            }
+        }
+        const add = (edgeModel, edgeXform) => {
+            let edge = edgeModel;
+            if (edge && !edge.color && model.color) {
+                // don't mess with incoming models
+                edge = {
+                    ...edge,
+                    color: model.color
+                };
+            }
+            edgeXform.render(xmlStream, edge, color);
+        };
+        add(model.left, this.map.left);
+        add(model.right, this.map.right);
+        add(model.top, this.map.top);
+        add(model.bottom, this.map.bottom);
+        add(model.diagonal, this.map.diagonal);
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case "border":
+                this.reset();
+                this.diagonalUp = parseBoolean(node.attributes.diagonalUp);
+                this.diagonalDown = parseBoolean(node.attributes.diagonalDown);
+                return true;
+            default:
+                this.parser = this.map[node.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)) {
+                this.parser = undefined;
+            }
+            return true;
+        }
+        if (name === "border") {
+            const model = (this.model = {});
+            const add = (key, edgeModel, extensions) => {
+                if (edgeModel) {
+                    if (extensions) {
+                        Object.assign(edgeModel, extensions);
+                    }
+                    model[key] = edgeModel;
+                }
+            };
+            add("left", this.map.left.model);
+            add("right", this.map.right.model);
+            add("top", this.map.top.model);
+            add("bottom", this.map.bottom.model);
+            add("diagonal", this.map.diagonal.model, { up: this.diagonalUp, down: this.diagonalDown });
+        }
+        return false;
+    }
+}
+export { BorderXform };

package/dist/browser/modules/excel/xlsx/xform/style/color-xform.d.ts

@@ -0,0 +1,17 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface ColorModel {
+    argb?: string;
+    theme?: number;
+    tint?: number;
+    indexed?: number;
+}
+declare class ColorXform extends BaseXform {
+    private name;
+    constructor(name?: string);
+    get tag(): string;
+    render(xmlStream: any, model?: ColorModel): boolean;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { ColorXform };

package/dist/browser/modules/excel/xlsx/xform/style/color-xform.js

@@ -0,0 +1,61 @@
+import { BaseXform } from "../base-xform.js";
+// Color encapsulates translation from color model to/from xlsx
+class ColorXform extends BaseXform {
+    constructor(name) {
+        super();
+        // this.name controls the xm node name
+        this.name = name || "color";
+    }
+    get tag() {
+        return this.name;
+    }
+    render(xmlStream, model) {
+        if (model) {
+            xmlStream.openNode(this.name);
+            if (model.argb) {
+                xmlStream.addAttribute("rgb", model.argb);
+            }
+            else if (model.theme !== undefined) {
+                xmlStream.addAttribute("theme", model.theme);
+                if (model.tint !== undefined) {
+                    xmlStream.addAttribute("tint", model.tint);
+                }
+            }
+            else if (model.indexed !== undefined) {
+                xmlStream.addAttribute("indexed", model.indexed);
+            }
+            else {
+                xmlStream.addAttribute("auto", "1");
+            }
+            xmlStream.closeNode();
+            return true;
+        }
+        return false;
+    }
+    parseOpen(node) {
+        if (node.name === this.name) {
+            if (node.attributes.rgb) {
+                this.model = { argb: node.attributes.rgb };
+            }
+            else if (node.attributes.theme) {
+                this.model = { theme: parseInt(node.attributes.theme, 10) };
+                if (node.attributes.tint) {
+                    this.model.tint = parseFloat(node.attributes.tint);
+                }
+            }
+            else if (node.attributes.indexed) {
+                this.model = { indexed: parseInt(node.attributes.indexed, 10) };
+            }
+            else {
+                this.model = undefined;
+            }
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { ColorXform };

package/dist/browser/modules/excel/xlsx/xform/style/dxf-xform.d.ts

@@ -0,0 +1,23 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface DxfModel {
+    alignment?: any;
+    border?: any;
+    fill?: any;
+    font?: any;
+    numFmt?: string;
+    numFmtId?: number;
+    protection?: any;
+}
+declare class DxfXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser: any;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: DxfModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+export { DxfXform };