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

package/dist/esm/xlsx/xform/sheet/cf-ext/cfvo-ext-xform.js

@@ -1,35 +0,0 @@
-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/esm/xlsx/xform/sheet/cf-ext/conditional-formatting-ext-xform.js

@@ -1,48 +0,0 @@
-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/esm/xlsx/xform/sheet/cf-ext/conditional-formattings-ext-xform.js

@@ -1,40 +0,0 @@
-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/esm/xlsx/xform/sheet/cf-ext/databar-ext-xform.js

@@ -1,69 +0,0 @@
-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/esm/xlsx/xform/sheet/cf-ext/f-ext-xform.js

@@ -1,19 +0,0 @@
-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/esm/xlsx/xform/sheet/cf-ext/icon-set-ext-xform.js

@@ -1,60 +0,0 @@
-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/esm/xlsx/xform/sheet/cf-ext/sqref-ext-xform.js

@@ -1,19 +0,0 @@
-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/esm/xlsx/xform/sheet/col-breaks-xform.js

@@ -1,35 +0,0 @@
-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/esm/xlsx/xform/sheet/col-xform.js

@@ -1,75 +0,0 @@
-import { BaseXform } from "../base-xform.js";
-import { parseBoolean } from "../../../utils/utils.js";
-class ColXform extends BaseXform {
-    get tag() {
-        return "col";
-    }
-    prepare(model, options) {
-        const styleId = options.styles.addStyleModel(model.style || {});
-        if (styleId) {
-            model.styleId = styleId;
-        }
-    }
-    render(xmlStream, model) {
-        xmlStream.openNode("col");
-        xmlStream.addAttribute("min", model.min);
-        xmlStream.addAttribute("max", model.max);
-        if (model.width) {
-            xmlStream.addAttribute("width", model.width);
-        }
-        if (model.styleId) {
-            xmlStream.addAttribute("style", model.styleId);
-        }
-        if (model.hidden) {
-            xmlStream.addAttribute("hidden", "1");
-        }
-        if (model.bestFit) {
-            xmlStream.addAttribute("bestFit", "1");
-        }
-        if (model.outlineLevel) {
-            xmlStream.addAttribute("outlineLevel", model.outlineLevel);
-        }
-        if (model.collapsed) {
-            xmlStream.addAttribute("collapsed", "1");
-        }
-        xmlStream.addAttribute("customWidth", "1");
-        xmlStream.closeNode();
-    }
-    parseOpen(node) {
-        if (node.name === "col") {
-            const model = (this.model = {
-                min: parseInt(node.attributes.min || "0", 10),
-                max: parseInt(node.attributes.max || "0", 10),
-                width: node.attributes.width === undefined ? undefined : parseFloat(node.attributes.width || "0")
-            });
-            if (node.attributes.style) {
-                model.styleId = parseInt(node.attributes.style, 10);
-            }
-            if (parseBoolean(node.attributes.hidden)) {
-                model.hidden = true;
-            }
-            if (parseBoolean(node.attributes.bestFit)) {
-                model.bestFit = true;
-            }
-            if (node.attributes.outlineLevel) {
-                model.outlineLevel = parseInt(node.attributes.outlineLevel, 10);
-            }
-            if (parseBoolean(node.attributes.collapsed)) {
-                model.collapsed = true;
-            }
-            return true;
-        }
-        return false;
-    }
-    parseText() { }
-    parseClose() {
-        return false;
-    }
-    reconcile(model, options) {
-        // reconcile column styles
-        if (model.styleId) {
-            model.style = options.styles.getStyleModel(model.styleId);
-        }
-    }
-}
-export { ColXform };

package/dist/esm/xlsx/xform/sheet/data-validations-xform.js

@@ -1,282 +0,0 @@
-import { BaseXform } from "../base-xform.js";
-import { Range } from "../../../doc/range.js";
-import { parseBoolean, dateToExcel, excelToDate } from "../../../utils/utils.js";
-import { colCache } from "../../../utils/col-cache.js";
-import { isEqual } from "../../../utils/under-dash.js";
-function assign(definedName, attributes, name, defaultValue) {
-    const value = attributes[name];
-    if (value !== undefined) {
-        definedName[name] = value;
-    }
-    else if (defaultValue !== undefined) {
-        definedName[name] = defaultValue;
-    }
-}
-function assignBool(definedName, attributes, name, defaultValue) {
-    const value = attributes[name];
-    if (value !== undefined) {
-        definedName[name] = parseBoolean(value);
-    }
-    else if (defaultValue !== undefined) {
-        definedName[name] = defaultValue;
-    }
-}
-function optimiseDataValidations(model) {
-    // Squeeze alike data validations together into rectangular ranges
-    // to reduce file size and speed up Excel load time
-    if (!model) {
-        return [];
-    }
-    // First, handle range: prefixed keys directly (large ranges stored during parsing)
-    const rangeValidations = [];
-    const regularModel = {};
-    for (const [key, value] of Object.entries(model)) {
-        // Skip undefined/null values (removed validations)
-        if (value === undefined || value === null) {
-            continue;
-        }
-        if (key.startsWith("range:")) {
-            // Large range stored during parsing - output directly
-            const rangeStr = key.slice(6); // Remove "range:" prefix
-            const { sqref: _sqref, ...rest } = value;
-            rangeValidations.push({
-                ...rest,
-                sqref: rangeStr
-            });
-        }
-        else {
-            regularModel[key] = value;
-        }
-    }
-    // If no regular entries, just return range validations
-    if (Object.keys(regularModel).length === 0) {
-        return rangeValidations;
-    }
-    const dvList = Object.entries(regularModel)
-        .map(([address, dataValidation]) => ({
-        address,
-        dataValidation,
-        marked: false
-    }))
-        .sort((a, b) => a.address.localeCompare(b.address));
-    const dvMap = Object.fromEntries(dvList.map(dv => [dv.address, dv]));
-    const matchCol = (addr, height, col) => {
-        for (let i = 0; i < height; i++) {
-            const otherAddress = colCache.encodeAddress(addr.row + i, col);
-            if (!regularModel[otherAddress] ||
-                !isEqual(regularModel[addr.address], regularModel[otherAddress])) {
-                return false;
-            }
-        }
-        return true;
-    };
-    const optimized = dvList
-        .map(dv => {
-        if (!dv.marked) {
-            const addr = colCache.decodeEx(dv.address);
-            if (addr.dimensions) {
-                dvMap[addr.dimensions].marked = true;
-                return {
-                    ...dv.dataValidation,
-                    sqref: dv.address
-                };
-            }
-            // iterate downwards - finding matching cells
-            let height = 1;
-            let otherAddress = colCache.encodeAddress(addr.row + height, addr.col);
-            while (regularModel[otherAddress] &&
-                isEqual(dv.dataValidation, regularModel[otherAddress])) {
-                height++;
-                otherAddress = colCache.encodeAddress(addr.row + height, addr.col);
-            }
-            // iterate rightwards...
-            let width = 1;
-            while (matchCol(addr, height, addr.col + width)) {
-                width++;
-            }
-            // mark all included addresses
-            for (let i = 0; i < height; i++) {
-                for (let j = 0; j < width; j++) {
-                    otherAddress = colCache.encodeAddress(addr.row + i, addr.col + j);
-                    dvMap[otherAddress].marked = true;
-                }
-            }
-            if (height > 1 || width > 1) {
-                const bottom = addr.row + (height - 1);
-                const right = addr.col + (width - 1);
-                return {
-                    ...dv.dataValidation,
-                    sqref: `${dv.address}:${colCache.encodeAddress(bottom, right)}`
-                };
-            }
-            return {
-                ...dv.dataValidation,
-                sqref: dv.address
-            };
-        }
-        return null;
-    })
-        .filter(Boolean);
-    return [...rangeValidations, ...optimized];
-}
-class DataValidationsXform extends BaseXform {
-    get tag() {
-        return "dataValidations";
-    }
-    render(xmlStream, model) {
-        const optimizedModel = optimiseDataValidations(model);
-        if (optimizedModel.length) {
-            xmlStream.openNode("dataValidations", { count: optimizedModel.length });
-            optimizedModel.forEach((value) => {
-                xmlStream.openNode("dataValidation");
-                if (value.type !== "any") {
-                    xmlStream.addAttribute("type", value.type);
-                    if (value.operator && value.type !== "list" && value.operator !== "between") {
-                        xmlStream.addAttribute("operator", value.operator);
-                    }
-                    if (value.allowBlank) {
-                        xmlStream.addAttribute("allowBlank", "1");
-                    }
-                }
-                if (value.showInputMessage) {
-                    xmlStream.addAttribute("showInputMessage", "1");
-                }
-                if (value.promptTitle) {
-                    xmlStream.addAttribute("promptTitle", value.promptTitle);
-                }
-                if (value.prompt) {
-                    xmlStream.addAttribute("prompt", value.prompt);
-                }
-                if (value.showErrorMessage) {
-                    xmlStream.addAttribute("showErrorMessage", "1");
-                }
-                if (value.errorStyle) {
-                    xmlStream.addAttribute("errorStyle", value.errorStyle);
-                }
-                if (value.errorTitle) {
-                    xmlStream.addAttribute("errorTitle", value.errorTitle);
-                }
-                if (value.error) {
-                    xmlStream.addAttribute("error", value.error);
-                }
-                xmlStream.addAttribute("sqref", value.sqref);
-                (value.formulae || []).forEach((formula, index) => {
-                    xmlStream.openNode(`formula${index + 1}`);
-                    if (value.type === "date") {
-                        xmlStream.writeText(dateToExcel(new Date(formula)));
-                    }
-                    else {
-                        xmlStream.writeText(formula);
-                    }
-                    xmlStream.closeNode();
-                });
-                xmlStream.closeNode();
-            });
-            xmlStream.closeNode();
-        }
-    }
-    parseOpen(node) {
-        switch (node.name) {
-            case "dataValidations":
-                this.model = {};
-                return true;
-            case "dataValidation": {
-                this._address = node.attributes.sqref;
-                const dataValidation = { type: node.attributes.type || "any", formulae: [] };
-                if (node.attributes.type) {
-                    assignBool(dataValidation, node.attributes, "allowBlank");
-                }
-                assignBool(dataValidation, node.attributes, "showInputMessage");
-                assignBool(dataValidation, node.attributes, "showErrorMessage");
-                switch (dataValidation.type) {
-                    case "any":
-                    case "list":
-                    case "custom":
-                        break;
-                    default:
-                        assign(dataValidation, node.attributes, "operator", "between");
-                        break;
-                }
-                assign(dataValidation, node.attributes, "promptTitle");
-                assign(dataValidation, node.attributes, "prompt");
-                assign(dataValidation, node.attributes, "errorStyle");
-                assign(dataValidation, node.attributes, "errorTitle");
-                assign(dataValidation, node.attributes, "error");
-                this._dataValidation = dataValidation;
-                return true;
-            }
-            case "formula1":
-            case "formula2":
-                this._formula = [];
-                return true;
-            default:
-                return false;
-        }
-    }
-    parseText(text) {
-        if (this._formula) {
-            this._formula.push(text);
-        }
-    }
-    parseClose(name) {
-        switch (name) {
-            case "dataValidations":
-                return false;
-            case "dataValidation": {
-                if (!this._dataValidation.formulae || !this._dataValidation.formulae.length) {
-                    delete this._dataValidation.formulae;
-                    delete this._dataValidation.operator;
-                }
-                // The four known cases: 1. E4:L9 N4:U9  2.E4 L9  3. N4:U9  4. E4
-                const list = this._address.split(/\s+/g) || [];
-                list.forEach((addr) => {
-                    if (addr.includes(":")) {
-                        const range = new Range(addr);
-                        // Only expand small ranges to avoid performance issues with large ranges
-                        // like B2:B1048576 (entire column validations)
-                        const rangeSize = (range.bottom - range.top + 1) * (range.right - range.left + 1);
-                        if (rangeSize <= 1000) {
-                            // Small range: expand to individual cells for backward compatibility
-                            range.forEachAddress((address) => {
-                                this.model[address] = this._dataValidation;
-                            });
-                        }
-                        else {
-                            // Large range: store as range string with special marker
-                            // The key format "range:A1:Z100" allows DataValidations.find() to detect it
-                            this.model[`range:${addr}`] = this._dataValidation;
-                        }
-                    }
-                    else {
-                        this.model[addr] = this._dataValidation;
-                    }
-                });
-                return true;
-            }
-            case "formula1":
-            case "formula2": {
-                let formula = this._formula.join("");
-                switch (this._dataValidation.type) {
-                    case "whole":
-                    case "textLength":
-                        formula = parseInt(formula, 10);
-                        break;
-                    case "decimal":
-                        formula = parseFloat(formula);
-                        break;
-                    case "date":
-                        formula = excelToDate(parseFloat(formula));
-                        break;
-                    default:
-                        break;
-                }
-                this._dataValidation.formulae.push(formula);
-                this._formula = undefined;
-                return true;
-            }
-            default:
-                return true;
-        }
-    }
-}
-export { DataValidationsXform };