@cj-tech-master/excelts 4.0.0 → 4.0.1-canary.20260104072032.0453bbe

package/dist/browser/modules/excel/xlsx/xform/sheet/cf/icon-set-xform.js

@@ -0,0 +1,37 @@
+import { BaseXform } from "../../base-xform.js";
+import { CompositeXform } from "../../composite-xform.js";
+import { CfvoXform } from "./cfvo-xform.js";
+class IconSetXform extends CompositeXform {
+    constructor() {
+        super();
+        this.map = {
+            cfvo: (this.cfvoXform = new CfvoXform())
+        };
+    }
+    get tag() {
+        return "iconSet";
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag, {
+            iconSet: BaseXform.toStringAttribute(model.iconSet, "3TrafficLights"),
+            reverse: BaseXform.toBoolAttribute(model.reverse, false),
+            showValue: BaseXform.toBoolAttribute(model.showValue, true)
+        });
+        model.cfvo.forEach((cfvo) => {
+            this.cfvoXform.render(xmlStream, cfvo);
+        });
+        xmlStream.closeNode();
+    }
+    createNewModel({ attributes }) {
+        return {
+            iconSet: BaseXform.toStringValue(attributes.iconSet, "3TrafficLights"),
+            reverse: BaseXform.toBoolValue(attributes.reverse),
+            showValue: BaseXform.toBoolValue(attributes.showValue),
+            cfvo: []
+        };
+    }
+    onParserClose(name, parser) {
+        this.model[name].push(parser.model);
+    }
+}
+export { IconSetXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/cf-icon-ext-xform.d.ts

@@ -0,0 +1,10 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+declare class CfIconExtXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model: any): void;
+    parseOpen({ attributes }: {
+        attributes: any;
+    }): void;
+    parseClose(name: any): boolean;
+}
+export { CfIconExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/cf-icon-ext-xform.js

@@ -0,0 +1,22 @@
+import { BaseXform } from "../../base-xform.js";
+class CfIconExtXform extends BaseXform {
+    get tag() {
+        return "x14:cfIcon";
+    }
+    render(xmlStream, model) {
+        xmlStream.leafNode(this.tag, {
+            iconSet: model.iconSet,
+            iconId: model.iconId
+        });
+    }
+    parseOpen({ attributes }) {
+        this.model = {
+            iconSet: attributes.iconSet,
+            iconId: BaseXform.toIntValue(attributes.iconId)
+        };
+    }
+    parseClose(name) {
+        return name !== this.tag;
+    }
+}
+export { CfIconExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/cf-rule-ext-xform.d.ts

@@ -0,0 +1,23 @@
+import { CompositeXform } from "@excel/xlsx/xform/composite-xform";
+import { DatabarExtXform } from "@excel/xlsx/xform/sheet/cf-ext/databar-ext-xform";
+import { IconSetExtXform } from "@excel/xlsx/xform/sheet/cf-ext/icon-set-ext-xform";
+declare class CfRuleExtXform extends CompositeXform {
+    databarXform: DatabarExtXform;
+    iconSetXform: IconSetExtXform;
+    constructor();
+    get tag(): string;
+    static isExt(rule: any): boolean;
+    prepare(model: any): void;
+    render(xmlStream: any, model: any): void;
+    renderDataBar(xmlStream: any, model: any): void;
+    renderIconSet(xmlStream: any, model: any): void;
+    createNewModel({ attributes }: {
+        attributes: any;
+    }): {
+        type: any;
+        x14Id: any;
+        priority: number;
+    };
+    onParserClose(name: any, parser: any): void;
+}
+export { CfRuleExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/cf-rule-ext-xform.js

@@ -0,0 +1,80 @@
+import { BaseXform } from "../../base-xform.js";
+import { CompositeXform } from "../../composite-xform.js";
+import { DatabarExtXform } from "./databar-ext-xform.js";
+import { IconSetExtXform } from "./icon-set-ext-xform.js";
+import { uuidV4 } from "../../../../../../utils/uuid.js";
+const extIcons = {
+    "3Triangles": true,
+    "3Stars": true,
+    "5Boxes": true
+};
+class CfRuleExtXform extends CompositeXform {
+    constructor() {
+        super();
+        this.map = {
+            "x14:dataBar": (this.databarXform = new DatabarExtXform()),
+            "x14:iconSet": (this.iconSetXform = new IconSetExtXform())
+        };
+    }
+    get tag() {
+        return "x14:cfRule";
+    }
+    static isExt(rule) {
+        // is this rule primitive?
+        if (rule.type === "dataBar") {
+            return DatabarExtXform.isExt(rule);
+        }
+        if (rule.type === "iconSet") {
+            if (rule.custom || extIcons[rule.iconSet]) {
+                return true;
+            }
+        }
+        return false;
+    }
+    prepare(model) {
+        if (CfRuleExtXform.isExt(model)) {
+            model.x14Id = `{${uuidV4()}}`.toUpperCase();
+        }
+    }
+    render(xmlStream, model) {
+        if (!CfRuleExtXform.isExt(model)) {
+            return;
+        }
+        switch (model.type) {
+            case "dataBar":
+                this.renderDataBar(xmlStream, model);
+                break;
+            case "iconSet":
+                this.renderIconSet(xmlStream, model);
+                break;
+        }
+    }
+    renderDataBar(xmlStream, model) {
+        xmlStream.openNode(this.tag, {
+            type: "dataBar",
+            id: model.x14Id
+        });
+        this.databarXform.render(xmlStream, model);
+        xmlStream.closeNode();
+    }
+    renderIconSet(xmlStream, model) {
+        xmlStream.openNode(this.tag, {
+            type: "iconSet",
+            priority: model.priority,
+            id: model.x14Id || `{${uuidV4()}}`
+        });
+        this.iconSetXform.render(xmlStream, model);
+        xmlStream.closeNode();
+    }
+    createNewModel({ attributes }) {
+        return {
+            type: attributes.type,
+            x14Id: attributes.id,
+            priority: BaseXform.toIntValue(attributes.priority)
+        };
+    }
+    onParserClose(name, parser) {
+        Object.assign(this.model, parser.model);
+    }
+}
+export { CfRuleExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/cfvo-ext-xform.d.ts

@@ -0,0 +1,13 @@
+import { CompositeXform } from "@excel/xlsx/xform/composite-xform";
+import { FExtXform } from "@excel/xlsx/xform/sheet/cf-ext/f-ext-xform";
+declare class CfvoExtXform extends CompositeXform {
+    fExtXform: FExtXform;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: any): void;
+    createNewModel(node: any): {
+        type: any;
+    };
+    onParserClose(name: any, parser: any): void;
+}
+export { CfvoExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/cfvo-ext-xform.js

@@ -0,0 +1,35 @@
+import { CompositeXform } from "../../composite-xform.js";
+import { FExtXform } from "./f-ext-xform.js";
+class CfvoExtXform extends CompositeXform {
+    constructor() {
+        super();
+        this.map = {
+            "xm:f": (this.fExtXform = new FExtXform())
+        };
+    }
+    get tag() {
+        return "x14:cfvo";
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag, {
+            type: model.type
+        });
+        if (model.value !== undefined) {
+            this.fExtXform.render(xmlStream, model.value);
+        }
+        xmlStream.closeNode();
+    }
+    createNewModel(node) {
+        return {
+            type: node.attributes.type
+        };
+    }
+    onParserClose(name, parser) {
+        switch (name) {
+            case "xm:f":
+                this.model.value = parser.model ? parseFloat(parser.model) : 0;
+                break;
+        }
+    }
+}
+export { CfvoExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/conditional-formatting-ext-xform.d.ts

@@ -0,0 +1,16 @@
+import { CompositeXform } from "@excel/xlsx/xform/composite-xform";
+import { SqrefExtXform } from "@excel/xlsx/xform/sheet/cf-ext/sqref-ext-xform";
+import { CfRuleExtXform } from "@excel/xlsx/xform/sheet/cf-ext/cf-rule-ext-xform";
+declare class ConditionalFormattingExtXform extends CompositeXform {
+    sqRef: SqrefExtXform;
+    cfRule: CfRuleExtXform;
+    constructor();
+    get tag(): string;
+    prepare(model: any): void;
+    render(xmlStream: any, model: any): void;
+    createNewModel(): {
+        rules: any[];
+    };
+    onParserClose(name: any, parser: any): void;
+}
+export { ConditionalFormattingExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/conditional-formatting-ext-xform.js

@@ -0,0 +1,48 @@
+import { CompositeXform } from "../../composite-xform.js";
+import { SqrefExtXform } from "./sqref-ext-xform.js";
+import { CfRuleExtXform } from "./cf-rule-ext-xform.js";
+class ConditionalFormattingExtXform extends CompositeXform {
+    constructor() {
+        super();
+        this.map = {
+            "xm:sqref": (this.sqRef = new SqrefExtXform()),
+            "x14:cfRule": (this.cfRule = new CfRuleExtXform())
+        };
+    }
+    get tag() {
+        return "x14:conditionalFormatting";
+    }
+    prepare(model) {
+        model.rules.forEach(rule => {
+            this.cfRule.prepare(rule);
+        });
+    }
+    render(xmlStream, model) {
+        if (!model.rules.some(CfRuleExtXform.isExt)) {
+            return;
+        }
+        xmlStream.openNode(this.tag, {
+            "xmlns:xm": "http://schemas.microsoft.com/office/excel/2006/main"
+        });
+        model.rules.filter(CfRuleExtXform.isExt).forEach(rule => this.cfRule.render(xmlStream, rule));
+        // for some odd reason, Excel needs the <xm:sqref> node to be after the rules
+        this.sqRef.render(xmlStream, model.ref);
+        xmlStream.closeNode();
+    }
+    createNewModel() {
+        return {
+            rules: []
+        };
+    }
+    onParserClose(name, parser) {
+        switch (name) {
+            case "xm:sqref":
+                this.model.ref = parser.model;
+                break;
+            case "x14:cfRule":
+                this.model.rules.push(parser.model);
+                break;
+        }
+    }
+}
+export { ConditionalFormattingExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/conditional-formattings-ext-xform.d.ts

@@ -0,0 +1,13 @@
+import { CompositeXform } from "@excel/xlsx/xform/composite-xform";
+import { ConditionalFormattingExtXform } from "@excel/xlsx/xform/sheet/cf-ext/conditional-formatting-ext-xform";
+declare class ConditionalFormattingsExtXform extends CompositeXform {
+    cfXform: ConditionalFormattingExtXform;
+    constructor();
+    get tag(): string;
+    hasContent(model: any): any;
+    prepare(model: any): void;
+    render(xmlStream: any, model: any): void;
+    createNewModel(): any[];
+    onParserClose(name: any, parser: any): void;
+}
+export { ConditionalFormattingsExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/conditional-formattings-ext-xform.js

@@ -0,0 +1,40 @@
+import { CompositeXform } from "../../composite-xform.js";
+import { CfRuleExtXform } from "./cf-rule-ext-xform.js";
+import { ConditionalFormattingExtXform } from "./conditional-formatting-ext-xform.js";
+class ConditionalFormattingsExtXform extends CompositeXform {
+    constructor() {
+        super();
+        this.map = {
+            "x14:conditionalFormatting": (this.cfXform = new ConditionalFormattingExtXform())
+        };
+    }
+    get tag() {
+        return "x14:conditionalFormattings";
+    }
+    hasContent(model) {
+        if (model.hasExtContent === undefined) {
+            model.hasExtContent = model.some(cf => cf.rules.some(CfRuleExtXform.isExt));
+        }
+        return model.hasExtContent;
+    }
+    prepare(model) {
+        model.forEach(cf => {
+            this.cfXform.prepare(cf);
+        });
+    }
+    render(xmlStream, model) {
+        if (this.hasContent(model)) {
+            xmlStream.openNode(this.tag);
+            model.forEach(cf => this.cfXform.render(xmlStream, cf));
+            xmlStream.closeNode();
+        }
+    }
+    createNewModel() {
+        return [];
+    }
+    onParserClose(name, parser) {
+        // model is array of conditional formatting objects
+        this.model.push(parser.model);
+    }
+}
+export { ConditionalFormattingsExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/databar-ext-xform.d.ts

@@ -0,0 +1,29 @@
+import { CompositeXform } from "@excel/xlsx/xform/composite-xform";
+import { ColorXform } from "@excel/xlsx/xform/style/color-xform";
+import { CfvoExtXform } from "@excel/xlsx/xform/sheet/cf-ext/cfvo-ext-xform";
+declare class DatabarExtXform extends CompositeXform {
+    cfvoXform: CfvoExtXform;
+    borderColorXform: ColorXform;
+    negativeBorderColorXform: ColorXform;
+    negativeFillColorXform: ColorXform;
+    axisColorXform: ColorXform;
+    constructor();
+    static isExt(rule: any): boolean;
+    get tag(): string;
+    render(xmlStream: any, model: any): void;
+    createNewModel({ attributes }: {
+        attributes: any;
+    }): {
+        cfvo: any[];
+        minLength: number;
+        maxLength: number;
+        border: boolean;
+        gradient: boolean;
+        negativeBarColorSameAsPositive: boolean;
+        negativeBarBorderColorSameAsPositive: boolean;
+        axisPosition: any;
+        direction: any;
+    };
+    onParserClose(name: any, parser: any): void;
+}
+export { DatabarExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/databar-ext-xform.js

@@ -0,0 +1,69 @@
+import { BaseXform } from "../../base-xform.js";
+import { CompositeXform } from "../../composite-xform.js";
+import { ColorXform } from "../../style/color-xform.js";
+import { CfvoExtXform } from "./cfvo-ext-xform.js";
+class DatabarExtXform extends CompositeXform {
+    constructor() {
+        super();
+        this.map = {
+            "x14:cfvo": (this.cfvoXform = new CfvoExtXform()),
+            "x14:borderColor": (this.borderColorXform = new ColorXform("x14:borderColor")),
+            "x14:negativeBorderColor": (this.negativeBorderColorXform = new ColorXform("x14:negativeBorderColor")),
+            "x14:negativeFillColor": (this.negativeFillColorXform = new ColorXform("x14:negativeFillColor")),
+            "x14:axisColor": (this.axisColorXform = new ColorXform("x14:axisColor"))
+        };
+    }
+    static isExt(rule) {
+        // not all databars need ext
+        // TODO: refine this
+        return !rule.gradient;
+    }
+    get tag() {
+        return "x14:dataBar";
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag, {
+            minLength: BaseXform.toIntAttribute(model.minLength, 0, true),
+            maxLength: BaseXform.toIntAttribute(model.maxLength, 100, true),
+            border: BaseXform.toBoolAttribute(model.border, false),
+            gradient: BaseXform.toBoolAttribute(model.gradient, true),
+            negativeBarColorSameAsPositive: BaseXform.toBoolAttribute(model.negativeBarColorSameAsPositive, true),
+            negativeBarBorderColorSameAsPositive: BaseXform.toBoolAttribute(model.negativeBarBorderColorSameAsPositive, true),
+            axisPosition: BaseXform.toAttribute(model.axisPosition, "auto"),
+            direction: BaseXform.toAttribute(model.direction, "leftToRight")
+        });
+        model.cfvo.forEach(cfvo => {
+            this.cfvoXform.render(xmlStream, cfvo);
+        });
+        this.borderColorXform.render(xmlStream, model.borderColor);
+        this.negativeBorderColorXform.render(xmlStream, model.negativeBorderColor);
+        this.negativeFillColorXform.render(xmlStream, model.negativeFillColor);
+        this.axisColorXform.render(xmlStream, model.axisColor);
+        xmlStream.closeNode();
+    }
+    createNewModel({ attributes }) {
+        return {
+            cfvo: [],
+            minLength: BaseXform.toIntValue(attributes.minLength, 0),
+            maxLength: BaseXform.toIntValue(attributes.maxLength, 100),
+            border: BaseXform.toBoolValue(attributes.border, false),
+            gradient: BaseXform.toBoolValue(attributes.gradient, true),
+            negativeBarColorSameAsPositive: BaseXform.toBoolValue(attributes.negativeBarColorSameAsPositive, true),
+            negativeBarBorderColorSameAsPositive: BaseXform.toBoolValue(attributes.negativeBarBorderColorSameAsPositive, true),
+            axisPosition: BaseXform.toStringValue(attributes.axisPosition, "auto"),
+            direction: BaseXform.toStringValue(attributes.direction, "leftToRight")
+        };
+    }
+    onParserClose(name, parser) {
+        const [, prop] = name.split(":");
+        switch (prop) {
+            case "cfvo":
+                this.model.cfvo.push(parser.model);
+                break;
+            default:
+                this.model[prop] = parser.model;
+                break;
+        }
+    }
+}
+export { DatabarExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/f-ext-xform.d.ts

@@ -0,0 +1,9 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+declare class FExtXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model: any): void;
+    parseOpen(): void;
+    parseText(text: any): void;
+    parseClose(name: any): boolean;
+}
+export { FExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/f-ext-xform.js

@@ -0,0 +1,19 @@
+import { BaseXform } from "../../base-xform.js";
+class FExtXform extends BaseXform {
+    get tag() {
+        return "xm:f";
+    }
+    render(xmlStream, model) {
+        xmlStream.leafNode(this.tag, null, model);
+    }
+    parseOpen() {
+        this.model = "";
+    }
+    parseText(text) {
+        this.model += text;
+    }
+    parseClose(name) {
+        return name !== this.tag;
+    }
+}
+export { FExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/icon-set-ext-xform.d.ts

@@ -0,0 +1,20 @@
+import { CompositeXform } from "@excel/xlsx/xform/composite-xform";
+import { CfvoExtXform } from "@excel/xlsx/xform/sheet/cf-ext/cfvo-ext-xform";
+import { CfIconExtXform } from "@excel/xlsx/xform/sheet/cf-ext/cf-icon-ext-xform";
+declare class IconSetExtXform extends CompositeXform {
+    cfvoXform: CfvoExtXform;
+    cfIconXform: CfIconExtXform;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: any): void;
+    createNewModel({ attributes }: {
+        attributes: any;
+    }): {
+        cfvo: any[];
+        iconSet: any;
+        reverse: boolean;
+        showValue: boolean;
+    };
+    onParserClose(name: any, parser: any): void;
+}
+export { IconSetExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/icon-set-ext-xform.js

@@ -0,0 +1,60 @@
+import { BaseXform } from "../../base-xform.js";
+import { CompositeXform } from "../../composite-xform.js";
+import { CfvoExtXform } from "./cfvo-ext-xform.js";
+import { CfIconExtXform } from "./cf-icon-ext-xform.js";
+class IconSetExtXform extends CompositeXform {
+    constructor() {
+        super();
+        this.map = {
+            "x14:cfvo": (this.cfvoXform = new CfvoExtXform()),
+            "x14:cfIcon": (this.cfIconXform = new CfIconExtXform())
+        };
+    }
+    get tag() {
+        return "x14:iconSet";
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag, {
+            iconSet: BaseXform.toStringAttribute(model.iconSet),
+            reverse: BaseXform.toBoolAttribute(model.reverse, false),
+            showValue: BaseXform.toBoolAttribute(model.showValue, true),
+            custom: BaseXform.toBoolAttribute(model.icons, false)
+        });
+        model.cfvo.forEach(cfvo => {
+            this.cfvoXform.render(xmlStream, cfvo);
+        });
+        if (model.icons) {
+            model.icons.forEach((icon, i) => {
+                icon.iconId = i;
+                this.cfIconXform.render(xmlStream, icon);
+            });
+        }
+        xmlStream.closeNode();
+    }
+    createNewModel({ attributes }) {
+        return {
+            cfvo: [],
+            iconSet: BaseXform.toStringValue(attributes.iconSet, "3TrafficLights"),
+            reverse: BaseXform.toBoolValue(attributes.reverse, false),
+            showValue: BaseXform.toBoolValue(attributes.showValue, true)
+        };
+    }
+    onParserClose(name, parser) {
+        const [, prop] = name.split(":");
+        switch (prop) {
+            case "cfvo":
+                this.model.cfvo.push(parser.model);
+                break;
+            case "cfIcon":
+                if (!this.model.icons) {
+                    this.model.icons = [];
+                }
+                this.model.icons.push(parser.model);
+                break;
+            default:
+                this.model[prop] = parser.model;
+                break;
+        }
+    }
+}
+export { IconSetExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/sqref-ext-xform.d.ts

@@ -0,0 +1,9 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+declare class SqrefExtXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model: any): void;
+    parseOpen(): void;
+    parseText(text: any): void;
+    parseClose(name: any): boolean;
+}
+export { SqrefExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/cf-ext/sqref-ext-xform.js

@@ -0,0 +1,19 @@
+import { BaseXform } from "../../base-xform.js";
+class SqrefExtXform extends BaseXform {
+    get tag() {
+        return "xm:sqref";
+    }
+    render(xmlStream, model) {
+        xmlStream.leafNode(this.tag, null, model);
+    }
+    parseOpen() {
+        this.model = "";
+    }
+    parseText(text) {
+        this.model += text;
+    }
+    parseClose(name) {
+        return name !== this.tag;
+    }
+}
+export { SqrefExtXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/col-breaks-xform.d.ts

@@ -0,0 +1,16 @@
+import { ListXform } from "@excel/xlsx/xform/list-xform";
+/**
+ * Xform for column page breaks (colBreaks element in worksheet XML)
+ * Used to define manual page breaks between columns when printing.
+ *
+ * XML structure:
+ * <colBreaks count="3" manualBreakCount="3">
+ *   <brk id="3" max="1048575" man="1"/>
+ *   <brk id="6" max="1048575" man="1"/>
+ * </colBreaks>
+ */
+declare class ColBreaksXform extends ListXform {
+    constructor();
+    render(xmlStream: any, model: any): void;
+}
+export { ColBreaksXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/col-breaks-xform.js

@@ -0,0 +1,35 @@
+import { PageBreaksXform } from "./page-breaks-xform.js";
+import { ListXform } from "../list-xform.js";
+/**
+ * Xform for column page breaks (colBreaks element in worksheet XML)
+ * Used to define manual page breaks between columns when printing.
+ *
+ * XML structure:
+ * <colBreaks count="3" manualBreakCount="3">
+ *   <brk id="3" max="1048575" man="1"/>
+ *   <brk id="6" max="1048575" man="1"/>
+ * </colBreaks>
+ */
+class ColBreaksXform extends ListXform {
+    constructor() {
+        super({
+            tag: "colBreaks",
+            count: true,
+            childXform: new PageBreaksXform()
+        });
+    }
+    // Override to add manualBreakCount attribute required by Excel
+    render(xmlStream, model) {
+        if (model && model.length) {
+            xmlStream.openNode(this.tag, this.$);
+            xmlStream.addAttribute(this.$count, model.length);
+            xmlStream.addAttribute("manualBreakCount", model.length);
+            const { childXform } = this;
+            for (const childModel of model) {
+                childXform.render(xmlStream, childModel);
+            }
+            xmlStream.closeNode();
+        }
+    }
+}
+export { ColBreaksXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/col-xform.d.ts

@@ -0,0 +1,22 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface ColModel {
+    min: number;
+    max: number;
+    width?: number;
+    styleId?: number;
+    hidden?: boolean;
+    bestFit?: boolean;
+    outlineLevel?: number;
+    collapsed?: boolean;
+    style?: any;
+}
+declare class ColXform extends BaseXform {
+    get tag(): string;
+    prepare(model: ColModel, options: any): void;
+    render(xmlStream: any, model: ColModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+    reconcile(model: ColModel, options: any): void;
+}
+export { ColXform };