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

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

@@ -0,0 +1,312 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import { ColorXform } from "@excel/xlsx/xform/style/color-xform";
+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 };

package/dist/esm/modules/excel/xlsx/xform/style/font-xform.js

@@ -0,0 +1,100 @@
+import { ColorXform } from "@excel/xlsx/xform/style/color-xform";
+import { BooleanXform } from "@excel/xlsx/xform/simple/boolean-xform";
+import { IntegerXform } from "@excel/xlsx/xform/simple/integer-xform";
+import { StringXform } from "@excel/xlsx/xform/simple/string-xform";
+import { UnderlineXform } from "@excel/xlsx/xform/style/underline-xform";
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+// Font encapsulates translation from font model to xlsx
+class FontXform extends BaseXform {
+    constructor(options) {
+        super();
+        this.options = options || FontXform.OPTIONS;
+        // Define properties in render order (Excel's expected order)
+        const fontProperties = [
+            { tag: "b", prop: "bold", xform: new BooleanXform({ tag: "b", attr: "val" }) },
+            { tag: "i", prop: "italic", xform: new BooleanXform({ tag: "i", attr: "val" }) },
+            { tag: "u", prop: "underline", xform: new UnderlineXform() },
+            { tag: "strike", prop: "strike", xform: new BooleanXform({ tag: "strike", attr: "val" }) },
+            {
+                tag: "condense",
+                prop: "condense",
+                xform: new BooleanXform({ tag: "condense", attr: "val" })
+            },
+            { tag: "extend", prop: "extend", xform: new BooleanXform({ tag: "extend", attr: "val" }) },
+            { tag: "outline", prop: "outline", xform: new BooleanXform({ tag: "outline", attr: "val" }) },
+            { tag: "shadow", prop: "shadow", xform: new BooleanXform({ tag: "shadow", attr: "val" }) },
+            { tag: "sz", prop: "size", xform: new IntegerXform({ tag: "sz", attr: "val" }) },
+            { tag: "color", prop: "color", xform: new ColorXform() },
+            {
+                tag: this.options.fontNameTag,
+                prop: "name",
+                xform: new StringXform({ tag: this.options.fontNameTag, attr: "val" })
+            },
+            { tag: "family", prop: "family", xform: new IntegerXform({ tag: "family", attr: "val" }) },
+            { tag: "scheme", prop: "scheme", xform: new StringXform({ tag: "scheme", attr: "val" }) },
+            { tag: "charset", prop: "charset", xform: new IntegerXform({ tag: "charset", attr: "val" }) },
+            {
+                tag: "vertAlign",
+                prop: "vertAlign",
+                xform: new StringXform({ tag: "vertAlign", attr: "val" })
+            }
+        ];
+        // Build map and renderOrder from single source of truth
+        this.map = Object.fromEntries(fontProperties.map(p => [p.tag, { prop: p.prop, xform: p.xform }]));
+        this.renderOrder = fontProperties.map(p => p.tag);
+    }
+    get tag() {
+        return this.options.tagName;
+    }
+    render(xmlStream, model) {
+        const { map, renderOrder } = this;
+        xmlStream.openNode(this.options.tagName);
+        renderOrder.forEach(tag => {
+            map[tag].xform.render(xmlStream, model[map[tag].prop]);
+        });
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        if (this.map[node.name]) {
+            this.parser = this.map[node.name].xform;
+            return this.parser.parseOpen(node);
+        }
+        switch (node.name) {
+            case this.options.tagName:
+                this.model = {};
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    parseClose(name) {
+        if (this.parser && !this.parser.parseClose(name)) {
+            const item = this.map[name];
+            if (this.parser.model) {
+                this.model[item.prop] = this.parser.model;
+            }
+            this.parser = undefined;
+            return true;
+        }
+        switch (name) {
+            case this.options.tagName:
+                return false;
+            default:
+                return true;
+        }
+    }
+}
+FontXform.OPTIONS = {
+    tagName: "font",
+    fontNameTag: "name"
+};
+export { FontXform };

package/dist/esm/modules/excel/xlsx/xform/style/numfmt-xform.js

@@ -0,0 +1,50 @@
+import { defaultNumFormats } from "@excel/xlsx/defaultnumformats";
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+function hashDefaultFormats() {
+    const hash = {};
+    Object.entries(defaultNumFormats).forEach(([id, dnf]) => {
+        if (dnf.f) {
+            hash[dnf.f] = parseInt(id, 10);
+        }
+        // at some point, add the other cultures here...
+    });
+    return hash;
+}
+const defaultFmtHash = hashDefaultFormats();
+// NumFmt encapsulates translation between number format and xlsx
+class NumFmtXform extends BaseXform {
+    constructor(id, formatCode) {
+        super();
+        this.id = id;
+        this.formatCode = formatCode;
+    }
+    get tag() {
+        return "numFmt";
+    }
+    render(xmlStream, model) {
+        xmlStream.leafNode("numFmt", { numFmtId: model.id, formatCode: model.formatCode });
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case "numFmt":
+                this.model = {
+                    id: parseInt(node.attributes.numFmtId, 10),
+                    formatCode: node.attributes.formatCode.replace(/[\\](.)/g, "$1")
+                };
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+    static getDefaultFmtId(formatCode) {
+        return defaultFmtHash[formatCode];
+    }
+    static getDefaultFmtCode(numFmtId) {
+        return defaultNumFormats[numFmtId] && defaultNumFormats[numFmtId].f;
+    }
+}
+export { NumFmtXform };

package/dist/esm/modules/excel/xlsx/xform/style/protection-xform.js

@@ -0,0 +1,49 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+const validation = {
+    boolean(value, dflt) {
+        if (value === undefined) {
+            return dflt;
+        }
+        return value;
+    }
+};
+// Protection encapsulates translation from style.protection model to/from xlsx
+class ProtectionXform extends BaseXform {
+    get tag() {
+        return "protection";
+    }
+    render(xmlStream, model) {
+        xmlStream.addRollback();
+        xmlStream.openNode("protection");
+        let isValid = false;
+        function add(name, value) {
+            if (value !== undefined) {
+                xmlStream.addAttribute(name, value);
+                isValid = true;
+            }
+        }
+        add("locked", validation.boolean(model.locked, true) ? undefined : "0");
+        add("hidden", validation.boolean(model.hidden, false) ? "1" : undefined);
+        xmlStream.closeNode();
+        if (isValid) {
+            xmlStream.commit();
+        }
+        else {
+            xmlStream.rollback();
+        }
+    }
+    parseOpen(node) {
+        const model = {
+            locked: !(node.attributes.locked === "0"),
+            hidden: node.attributes.hidden === "1"
+        };
+        // only want to record models that differ from defaults
+        const isSignificant = !model.locked || model.hidden;
+        this.model = isSignificant ? model : null;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { ProtectionXform };

package/dist/esm/modules/excel/xlsx/xform/style/style-xform.js

@@ -0,0 +1,108 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import { AlignmentXform } from "@excel/xlsx/xform/style/alignment-xform";
+import { ProtectionXform } from "@excel/xlsx/xform/style/protection-xform";
+// Style assists translation from style model to/from xlsx
+class StyleXform extends BaseXform {
+    constructor(options) {
+        super();
+        this.xfId = !!(options && options.xfId);
+        this.map = {
+            alignment: new AlignmentXform(),
+            protection: new ProtectionXform()
+        };
+    }
+    get tag() {
+        return "xf";
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode("xf", {
+            numFmtId: model.numFmtId || 0,
+            fontId: model.fontId || 0,
+            fillId: model.fillId || 0,
+            borderId: model.borderId || 0
+        });
+        if (this.xfId) {
+            xmlStream.addAttribute("xfId", model.xfId || 0);
+        }
+        if (model.numFmtId) {
+            xmlStream.addAttribute("applyNumberFormat", "1");
+        }
+        if (model.fontId) {
+            xmlStream.addAttribute("applyFont", "1");
+        }
+        if (model.fillId) {
+            xmlStream.addAttribute("applyFill", "1");
+        }
+        if (model.borderId) {
+            xmlStream.addAttribute("applyBorder", "1");
+        }
+        if (model.alignment) {
+            xmlStream.addAttribute("applyAlignment", "1");
+        }
+        if (model.protection) {
+            xmlStream.addAttribute("applyProtection", "1");
+        }
+        /**
+         * Rendering tags causes close of XML stream.
+         * Therefore adding attributes must be done before rendering tags.
+         */
+        if (model.alignment) {
+            this.map.alignment.render(xmlStream, model.alignment);
+        }
+        if (model.protection) {
+            this.map.protection.render(xmlStream, model.protection);
+        }
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        // used during sax parsing of xml to build font object
+        switch (node.name) {
+            case "xf":
+                this.model = {
+                    numFmtId: parseInt(node.attributes.numFmtId, 10),
+                    fontId: parseInt(node.attributes.fontId, 10),
+                    fillId: parseInt(node.attributes.fillId, 10),
+                    borderId: parseInt(node.attributes.borderId, 10)
+                };
+                if (this.xfId) {
+                    this.model.xfId = parseInt(node.attributes.xfId, 10);
+                }
+                return true;
+            case "alignment":
+                this.parser = this.map.alignment;
+                this.parser.parseOpen(node);
+                return true;
+            case "protection":
+                this.parser = this.map.protection;
+                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)) {
+                if (this.map.protection === this.parser) {
+                    this.model.protection = this.parser.model;
+                }
+                else {
+                    this.model.alignment = this.parser.model;
+                }
+                this.parser = undefined;
+            }
+            return true;
+        }
+        return name !== "xf";
+    }
+}
+export { StyleXform };