@cj-tech-master/excelts 3.0.1-canary.20251230173853.c3c79fa → 3.1.0-canary.20260102041828.82ed571

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

@@ -1,152 +0,0 @@
-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 };

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

@@ -1,188 +0,0 @@
-import { BaseXform } from "../base-xform.js";
-import { parseBoolean } from "../../../utils/utils.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/esm/xlsx/xform/style/color-xform.js

@@ -1,61 +0,0 @@
-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/esm/xlsx/xform/style/dxf-xform.js

@@ -1,92 +0,0 @@
-import { BaseXform } from "../base-xform.js";
-import { AlignmentXform } from "./alignment-xform.js";
-import { BorderXform } from "./border-xform.js";
-import { FillXform } from "./fill-xform.js";
-import { FontXform } from "./font-xform.js";
-import { NumFmtXform } from "./numfmt-xform.js";
-import { ProtectionXform } from "./protection-xform.js";
-// Style assists translation from style model to/from xlsx
-class DxfXform extends BaseXform {
-    constructor() {
-        super();
-        this.map = {
-            alignment: new AlignmentXform(),
-            border: new BorderXform(),
-            fill: new FillXform(),
-            font: new FontXform(),
-            numFmt: new NumFmtXform(),
-            protection: new 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;
-    }
-}
-export { DxfXform };