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

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

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

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

@@ -1,100 +0,0 @@
-import { ColorXform } from "./color-xform.js";
-import { BooleanXform } from "../simple/boolean-xform.js";
-import { IntegerXform } from "../simple/integer-xform.js";
-import { StringXform } from "../simple/string-xform.js";
-import { UnderlineXform } from "./underline-xform.js";
-import { BaseXform } from "../base-xform.js";
-// 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/xlsx/xform/style/numfmt-xform.js

@@ -1,50 +0,0 @@
-import { defaultNumFormats } from "../../defaultnumformats.js";
-import { BaseXform } from "../base-xform.js";
-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/xlsx/xform/style/protection-xform.js

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

@@ -1,108 +0,0 @@
-import { BaseXform } from "../base-xform.js";
-import { AlignmentXform } from "./alignment-xform.js";
-import { ProtectionXform } from "./protection-xform.js";
-// 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 };