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

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

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlignmentXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+const utils_js_1 = require("../../../utils/utils");
+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 = (0, utils_js_1.validInt)(value);
+                return numValue !== undefined && numValue >= -90 && numValue <= 90 ? numValue : undefined;
+            }
+        }
+    },
+    indent(value) {
+        const numValue = (0, utils_js_1.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 = (0, utils_js_1.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 base_xform_js_1.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", (0, utils_js_1.parseBoolean)(node.attributes.wrapText));
+        add(node.attributes.shrinkToFit, "shrinkToFit", (0, utils_js_1.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;
+    }
+}
+exports.AlignmentXform = AlignmentXform;

package/dist/cjs/xlsx/xform/style/border-xform.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BorderXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+const utils_js_1 = require("../../../utils/utils");
+const color_xform_js_1 = require("./color-xform");
+class EdgeXform extends base_xform_js_1.BaseXform {
+    constructor(name) {
+        super();
+        this.name = name;
+        this.map = {
+            color: new color_xform_js_1.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 base_xform_js_1.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 = (0, utils_js_1.parseBoolean)(node.attributes.diagonalUp);
+                this.diagonalDown = (0, utils_js_1.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;
+    }
+}
+exports.BorderXform = BorderXform;

package/dist/cjs/xlsx/xform/style/color-xform.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+// Color encapsulates translation from color model to/from xlsx
+class ColorXform extends base_xform_js_1.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;
+    }
+}
+exports.ColorXform = ColorXform;

package/dist/cjs/xlsx/xform/style/dxf-xform.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DxfXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+const alignment_xform_js_1 = require("./alignment-xform");
+const border_xform_js_1 = require("./border-xform");
+const fill_xform_js_1 = require("./fill-xform");
+const font_xform_js_1 = require("./font-xform");
+const numfmt_xform_js_1 = require("./numfmt-xform");
+const protection_xform_js_1 = require("./protection-xform");
+// Style assists translation from style model to/from xlsx
+class DxfXform extends base_xform_js_1.BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            alignment: new alignment_xform_js_1.AlignmentXform(),
+            border: new border_xform_js_1.BorderXform(),
+            fill: new fill_xform_js_1.FillXform(),
+            font: new font_xform_js_1.FontXform(),
+            numFmt: new numfmt_xform_js_1.NumFmtXform(),
+            protection: new protection_xform_js_1.ProtectionXform()
+        };
+    }
+    get tag() {
+        return "dxf";
+    }
+    // how do we generate dxfid?
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag);
+        if (model.font) {
+            this.map.font.render(xmlStream, model.font);
+        }
+        if (model.numFmt && model.numFmtId) {
+            const numFmtModel = { id: model.numFmtId, formatCode: model.numFmt };
+            this.map.numFmt.render(xmlStream, numFmtModel);
+        }
+        if (model.fill) {
+            this.map.fill.render(xmlStream, model.fill);
+        }
+        if (model.alignment) {
+            this.map.alignment.render(xmlStream, model.alignment);
+        }
+        if (model.border) {
+            this.map.border.render(xmlStream, model.border);
+        }
+        if (model.protection) {
+            this.map.protection.render(xmlStream, model.protection);
+        }
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case this.tag:
+                // this node is often repeated. Need to reset children
+                this.reset();
+                return true;
+            default:
+                this.parser = this.map[node.name];
+                if (this.parser) {
+                    this.parser.parseOpen(node);
+                }
+                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;
+        }
+        if (name === this.tag) {
+            this.model = {
+                alignment: this.map.alignment.model,
+                border: this.map.border.model,
+                fill: this.map.fill.model,
+                font: this.map.font.model,
+                numFmt: this.map.numFmt.model,
+                protection: this.map.protection.model
+            };
+            return false;
+        }
+        return true;
+    }
+}
+exports.DxfXform = DxfXform;