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

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

@@ -0,0 +1,188 @@
+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

@@ -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/esm/xlsx/xform/style/dxf-xform.js

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

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

@@ -0,0 +1,312 @@
+import { BaseXform } from "../base-xform.js";
+import { ColorXform } from "./color-xform.js";
+class StopXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            color: new ColorXform()
+        };
+    }
+    get tag() {
+        return "stop";
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode("stop");
+        xmlStream.addAttribute("position", model.position);
+        this.map.color.render(xmlStream, model.color);
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case "stop":
+                this.model = {
+                    position: parseFloat(node.attributes.position)
+                };
+                return true;
+            case "color":
+                this.parser = this.map.color;
+                this.parser.parseOpen(node);
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText() { }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.model.color = this.parser.model;
+                this.parser = undefined;
+            }
+            return true;
+        }
+        return false;
+    }
+}
+class PatternFillXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            fgColor: new ColorXform("fgColor"),
+            bgColor: new ColorXform("bgColor")
+        };
+    }
+    get name() {
+        return "pattern";
+    }
+    get tag() {
+        return "patternFill";
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode("patternFill");
+        xmlStream.addAttribute("patternType", model.pattern);
+        if (model.fgColor) {
+            this.map.fgColor.render(xmlStream, model.fgColor);
+        }
+        if (model.bgColor) {
+            this.map.bgColor.render(xmlStream, model.bgColor);
+        }
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case "patternFill":
+                this.model = {
+                    type: "pattern",
+                    pattern: node.attributes.patternType
+                };
+                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)) {
+                if (this.parser.model) {
+                    this.model[name] = this.parser.model;
+                }
+                this.parser = undefined;
+            }
+            return true;
+        }
+        return false;
+    }
+}
+class GradientFillXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            stop: new StopXform()
+        };
+    }
+    get name() {
+        return "gradient";
+    }
+    get tag() {
+        return "gradientFill";
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode("gradientFill");
+        switch (model.gradient) {
+            case "angle":
+                xmlStream.addAttribute("degree", model.degree);
+                break;
+            case "path":
+                xmlStream.addAttribute("type", "path");
+                if (model.center.left) {
+                    xmlStream.addAttribute("left", model.center.left);
+                    if (model.center.right === undefined) {
+                        xmlStream.addAttribute("right", model.center.left);
+                    }
+                }
+                if (model.center.right) {
+                    xmlStream.addAttribute("right", model.center.right);
+                }
+                if (model.center.top) {
+                    xmlStream.addAttribute("top", model.center.top);
+                    if (model.center.bottom === undefined) {
+                        xmlStream.addAttribute("bottom", model.center.top);
+                    }
+                }
+                if (model.center.bottom) {
+                    xmlStream.addAttribute("bottom", model.center.bottom);
+                }
+                break;
+            default:
+                break;
+        }
+        const stopXform = this.map.stop;
+        model.stops.forEach(stopModel => {
+            stopXform.render(xmlStream, stopModel);
+        });
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case "gradientFill": {
+                const model = (this.model = {
+                    stops: []
+                });
+                if (node.attributes.degree) {
+                    model.gradient = "angle";
+                    model.degree = parseInt(node.attributes.degree, 10);
+                }
+                else if (node.attributes.type === "path") {
+                    model.gradient = "path";
+                    model.center = {
+                        left: node.attributes.left ? parseFloat(node.attributes.left) : 0,
+                        top: node.attributes.top ? parseFloat(node.attributes.top) : 0
+                    };
+                    if (node.attributes.right !== node.attributes.left) {
+                        model.center.right = node.attributes.right ? parseFloat(node.attributes.right) : 0;
+                    }
+                    if (node.attributes.bottom !== node.attributes.top) {
+                        model.center.bottom = node.attributes.bottom ? parseFloat(node.attributes.bottom) : 0;
+                    }
+                }
+                return true;
+            }
+            case "stop":
+                this.parser = this.map.stop;
+                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.model.stops.push(this.parser.model);
+                this.parser = undefined;
+            }
+            return true;
+        }
+        return false;
+    }
+}
+// Fill encapsulates translation from fill model to/from xlsx
+class FillXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            patternFill: new PatternFillXform(),
+            gradientFill: new GradientFillXform()
+        };
+    }
+    get tag() {
+        return "fill";
+    }
+    render(xmlStream, model) {
+        xmlStream.addRollback();
+        xmlStream.openNode("fill");
+        switch (model.type) {
+            case "pattern":
+                this.map.patternFill.render(xmlStream, model);
+                break;
+            case "gradient":
+                this.map.gradientFill.render(xmlStream, model);
+                break;
+            default:
+                xmlStream.rollback();
+                return;
+        }
+        xmlStream.closeNode();
+        xmlStream.commit();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case "fill":
+                this.model = {};
+                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.model = this.parser.model;
+                this.model.type = this.parser.name;
+                this.parser = undefined;
+            }
+            return true;
+        }
+        return false;
+    }
+    validStyle(value) {
+        return FillXform.validPatternValues[value];
+    }
+}
+FillXform.validPatternValues = [
+    "none",
+    "solid",
+    "darkVertical",
+    "darkGray",
+    "mediumGray",
+    "lightGray",
+    "gray125",
+    "gray0625",
+    "darkHorizontal",
+    "darkVertical",
+    "darkDown",
+    "darkUp",
+    "darkGrid",
+    "darkTrellis",
+    "lightHorizontal",
+    "lightVertical",
+    "lightDown",
+    "lightUp",
+    "lightGrid",
+    "lightTrellis",
+    "lightGrid"
+].reduce((p, v) => {
+    p[v] = true;
+    return p;
+}, {});
+FillXform.StopXform = StopXform;
+FillXform.PatternFillXform = PatternFillXform;
+FillXform.GradientFillXform = GradientFillXform;
+export { FillXform };