@cj-tech-master/excelts 3.1.0-canary.20260102071304.d80b29d → 4.0.0-canary.20260103013222.0e5d37f

package/dist/browser/modules/excel/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/browser/modules/excel/xlsx/xform/style/fill-xform.d.ts

@@ -0,0 +1,85 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import { ColorXform } from "@excel/xlsx/xform/style/color-xform";
+interface StopModel {
+    position: number;
+    color: any;
+}
+interface PatternFillModel {
+    type: "pattern";
+    pattern: string;
+    fgColor?: any;
+    bgColor?: any;
+}
+interface GradientFillModel {
+    type: "gradient";
+    gradient: "angle" | "path";
+    degree?: number;
+    center?: {
+        left: number;
+        top: number;
+        right?: number;
+        bottom?: number;
+    };
+    stops: StopModel[];
+}
+type FillModel = PatternFillModel | GradientFillModel;
+declare class StopXform extends BaseXform {
+    map: {
+        color: ColorXform;
+    };
+    parser: any;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: StopModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(name: string): boolean;
+}
+declare class PatternFillXform extends BaseXform {
+    map: {
+        fgColor: ColorXform;
+        bgColor: ColorXform;
+    };
+    parser: any;
+    constructor();
+    get name(): string;
+    get tag(): string;
+    render(xmlStream: any, model: PatternFillModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+declare class GradientFillXform extends BaseXform {
+    map: {
+        stop: StopXform;
+    };
+    parser: any;
+    constructor();
+    get name(): string;
+    get tag(): string;
+    render(xmlStream: any, model: GradientFillModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+declare class FillXform extends BaseXform {
+    map: {
+        patternFill: PatternFillXform;
+        gradientFill: GradientFillXform;
+    };
+    parser: any;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: FillModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    validStyle(value: string): boolean;
+    static validPatternValues: {
+        [key: string]: boolean;
+    };
+    static StopXform: typeof StopXform;
+    static PatternFillXform: typeof PatternFillXform;
+    static GradientFillXform: typeof GradientFillXform;
+}
+export { FillXform };

package/dist/browser/modules/excel/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 };

package/dist/browser/modules/excel/xlsx/xform/style/font-xform.d.ts

@@ -0,0 +1,35 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface FontModel {
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean | string;
+    charset?: number;
+    color?: any;
+    condense?: boolean;
+    extend?: boolean;
+    family?: number;
+    outline?: boolean;
+    vertAlign?: string;
+    scheme?: string;
+    shadow?: boolean;
+    strike?: boolean;
+    size?: number;
+    name?: string;
+}
+interface FontOptions {
+    tagName: string;
+    fontNameTag: string;
+}
+declare class FontXform extends BaseXform {
+    private options;
+    parser: any;
+    private renderOrder;
+    constructor(options?: FontOptions);
+    get tag(): string;
+    render(xmlStream: any, model: FontModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    static OPTIONS: FontOptions;
+}
+export { FontXform };

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

@@ -0,0 +1,100 @@
+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/browser/modules/excel/xlsx/xform/style/numfmt-xform.d.ts

@@ -0,0 +1,18 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface NumFmtModel {
+    id: number;
+    formatCode: string;
+}
+declare class NumFmtXform extends BaseXform {
+    private id?;
+    private formatCode?;
+    constructor(id?: number, formatCode?: string);
+    get tag(): string;
+    render(xmlStream: any, model: NumFmtModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+    static getDefaultFmtId(formatCode: string): number | undefined;
+    static getDefaultFmtCode(numFmtId: number): string | undefined;
+}
+export { NumFmtXform };

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

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