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

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

@@ -1,259 +0,0 @@
-import { BaseXform } from "@excel/xlsx/xform/base-xform";
-import { CompositeXform } from "@excel/xlsx/xform/composite-xform";
-import { Range } from "@excel/range";
-import { DatabarXform } from "@excel/xlsx/xform/sheet/cf/databar-xform";
-import { ExtLstRefXform } from "@excel/xlsx/xform/sheet/cf/ext-lst-ref-xform";
-import { FormulaXform } from "@excel/xlsx/xform/sheet/cf/formula-xform";
-import { ColorScaleXform } from "@excel/xlsx/xform/sheet/cf/color-scale-xform";
-import { IconSetXform } from "@excel/xlsx/xform/sheet/cf/icon-set-xform";
-const extIcons = {
-    "3Triangles": true,
-    "3Stars": true,
-    "5Boxes": true
-};
-const getTextFormula = model => {
-    if (model.formulae && model.formulae[0]) {
-        return model.formulae[0];
-    }
-    const range = new Range(model.ref);
-    const { tl } = range;
-    switch (model.operator) {
-        case "containsText":
-            return `NOT(ISERROR(SEARCH("${model.text}",${tl})))`;
-        case "containsBlanks":
-            return `LEN(TRIM(${tl}))=0`;
-        case "notContainsBlanks":
-            return `LEN(TRIM(${tl}))>0`;
-        case "containsErrors":
-            return `ISERROR(${tl})`;
-        case "notContainsErrors":
-            return `NOT(ISERROR(${tl}))`;
-        default:
-            return undefined;
-    }
-};
-const getTimePeriodFormula = model => {
-    if (model.formulae && model.formulae[0]) {
-        return model.formulae[0];
-    }
-    const range = new Range(model.ref);
-    const { tl } = range;
-    switch (model.timePeriod) {
-        case "thisWeek":
-            return `AND(TODAY()-ROUNDDOWN(${tl},0)<=WEEKDAY(TODAY())-1,ROUNDDOWN(${tl},0)-TODAY()<=7-WEEKDAY(TODAY()))`;
-        case "lastWeek":
-            return `AND(TODAY()-ROUNDDOWN(${tl},0)>=(WEEKDAY(TODAY())),TODAY()-ROUNDDOWN(${tl},0)<(WEEKDAY(TODAY())+7))`;
-        case "nextWeek":
-            return `AND(ROUNDDOWN(${tl},0)-TODAY()>(7-WEEKDAY(TODAY())),ROUNDDOWN(${tl},0)-TODAY()<(15-WEEKDAY(TODAY())))`;
-        case "yesterday":
-            return `FLOOR(${tl},1)=TODAY()-1`;
-        case "today":
-            return `FLOOR(${tl},1)=TODAY()`;
-        case "tomorrow":
-            return `FLOOR(${tl},1)=TODAY()+1`;
-        case "last7Days":
-            return `AND(TODAY()-FLOOR(${tl},1)<=6,FLOOR(${tl},1)<=TODAY())`;
-        case "lastMonth":
-            return `AND(MONTH(${tl})=MONTH(EDATE(TODAY(),0-1)),YEAR(${tl})=YEAR(EDATE(TODAY(),0-1)))`;
-        case "thisMonth":
-            return `AND(MONTH(${tl})=MONTH(TODAY()),YEAR(${tl})=YEAR(TODAY()))`;
-        case "nextMonth":
-            return `AND(MONTH(${tl})=MONTH(EDATE(TODAY(),0+1)),YEAR(${tl})=YEAR(EDATE(TODAY(),0+1)))`;
-        default:
-            return undefined;
-    }
-};
-const opType = attributes => {
-    const { type, operator } = attributes;
-    switch (type) {
-        case "containsText":
-        case "containsBlanks":
-        case "notContainsBlanks":
-        case "containsErrors":
-        case "notContainsErrors":
-            return {
-                type: "containsText",
-                operator: type
-            };
-        default:
-            return { type, operator };
-    }
-};
-class CfRuleXform extends CompositeXform {
-    constructor() {
-        super();
-        this.map = {
-            dataBar: (this.databarXform = new DatabarXform()),
-            extLst: (this.extLstRefXform = new ExtLstRefXform()),
-            formula: (this.formulaXform = new FormulaXform()),
-            colorScale: (this.colorScaleXform = new ColorScaleXform()),
-            iconSet: (this.iconSetXform = new IconSetXform())
-        };
-    }
-    get tag() {
-        return "cfRule";
-    }
-    static isPrimitive(rule) {
-        // is this rule primitive?
-        if (rule.type === "iconSet") {
-            if (rule.custom || extIcons[rule.iconSet]) {
-                return false;
-            }
-        }
-        return true;
-    }
-    render(xmlStream, model) {
-        switch (model.type) {
-            case "expression":
-                this.renderExpression(xmlStream, model);
-                break;
-            case "cellIs":
-                this.renderCellIs(xmlStream, model);
-                break;
-            case "top10":
-                this.renderTop10(xmlStream, model);
-                break;
-            case "aboveAverage":
-                this.renderAboveAverage(xmlStream, model);
-                break;
-            case "dataBar":
-                this.renderDataBar(xmlStream, model);
-                break;
-            case "colorScale":
-                this.renderColorScale(xmlStream, model);
-                break;
-            case "iconSet":
-                this.renderIconSet(xmlStream, model);
-                break;
-            case "containsText":
-                this.renderText(xmlStream, model);
-                break;
-            case "timePeriod":
-                this.renderTimePeriod(xmlStream, model);
-                break;
-        }
-    }
-    renderExpression(xmlStream, model) {
-        xmlStream.openNode(this.tag, {
-            type: "expression",
-            dxfId: model.dxfId,
-            priority: model.priority
-        });
-        this.formulaXform.render(xmlStream, model.formulae[0]);
-        xmlStream.closeNode();
-    }
-    renderCellIs(xmlStream, model) {
-        xmlStream.openNode(this.tag, {
-            type: "cellIs",
-            dxfId: model.dxfId,
-            priority: model.priority,
-            operator: model.operator
-        });
-        model.formulae.forEach(formula => {
-            this.formulaXform.render(xmlStream, formula);
-        });
-        xmlStream.closeNode();
-    }
-    renderTop10(xmlStream, model) {
-        xmlStream.leafNode(this.tag, {
-            type: "top10",
-            dxfId: model.dxfId,
-            priority: model.priority,
-            percent: BaseXform.toBoolAttribute(model.percent, false),
-            bottom: BaseXform.toBoolAttribute(model.bottom, false),
-            rank: BaseXform.toIntValue(model.rank, 10)
-        });
-    }
-    renderAboveAverage(xmlStream, model) {
-        xmlStream.leafNode(this.tag, {
-            type: "aboveAverage",
-            dxfId: model.dxfId,
-            priority: model.priority,
-            aboveAverage: BaseXform.toBoolAttribute(model.aboveAverage, true)
-        });
-    }
-    renderDataBar(xmlStream, model) {
-        xmlStream.openNode(this.tag, {
-            type: "dataBar",
-            priority: model.priority
-        });
-        this.databarXform.render(xmlStream, model);
-        this.extLstRefXform.render(xmlStream, model);
-        xmlStream.closeNode();
-    }
-    renderColorScale(xmlStream, model) {
-        xmlStream.openNode(this.tag, {
-            type: "colorScale",
-            priority: model.priority
-        });
-        this.colorScaleXform.render(xmlStream, model);
-        xmlStream.closeNode();
-    }
-    renderIconSet(xmlStream, model) {
-        // iconset is all primitive or all extLst
-        if (!CfRuleXform.isPrimitive(model)) {
-            return;
-        }
-        xmlStream.openNode(this.tag, {
-            type: "iconSet",
-            priority: model.priority
-        });
-        this.iconSetXform.render(xmlStream, model);
-        xmlStream.closeNode();
-    }
-    renderText(xmlStream, model) {
-        xmlStream.openNode(this.tag, {
-            type: model.operator,
-            dxfId: model.dxfId,
-            priority: model.priority,
-            operator: BaseXform.toStringAttribute(model.operator, "containsText")
-        });
-        const formula = getTextFormula(model);
-        if (formula) {
-            this.formulaXform.render(xmlStream, formula);
-        }
-        xmlStream.closeNode();
-    }
-    renderTimePeriod(xmlStream, model) {
-        xmlStream.openNode(this.tag, {
-            type: "timePeriod",
-            dxfId: model.dxfId,
-            priority: model.priority,
-            timePeriod: model.timePeriod
-        });
-        const formula = getTimePeriodFormula(model);
-        if (formula) {
-            this.formulaXform.render(xmlStream, formula);
-        }
-        xmlStream.closeNode();
-    }
-    createNewModel({ attributes }) {
-        return {
-            ...opType(attributes),
-            dxfId: BaseXform.toIntValue(attributes.dxfId),
-            priority: BaseXform.toIntValue(attributes.priority),
-            timePeriod: attributes.timePeriod,
-            percent: BaseXform.toBoolValue(attributes.percent),
-            bottom: BaseXform.toBoolValue(attributes.bottom),
-            rank: BaseXform.toIntValue(attributes.rank),
-            aboveAverage: BaseXform.toBoolValue(attributes.aboveAverage)
-        };
-    }
-    onParserClose(name, parser) {
-        switch (name) {
-            case "dataBar":
-            case "extLst":
-            case "colorScale":
-            case "iconSet":
-                // merge parser model with ours
-                Object.assign(this.model, parser.model);
-                break;
-            case "formula":
-                // except - formula is a string and appends to formulae
-                this.model.formulae = this.model.formulae || [];
-                this.model.formulae.push(parser.model);
-                break;
-        }
-    }
-}
-export { CfRuleXform };

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

@@ -1,22 +0,0 @@
-import { BaseXform } from "@excel/xlsx/xform/base-xform";
-class CfvoXform extends BaseXform {
-    get tag() {
-        return "cfvo";
-    }
-    render(xmlStream, model) {
-        xmlStream.leafNode(this.tag, {
-            type: model.type,
-            val: model.value
-        });
-    }
-    parseOpen(node) {
-        this.model = {
-            type: node.attributes.type,
-            value: BaseXform.toFloatValue(node.attributes.val)
-        };
-    }
-    parseClose(name) {
-        return name !== this.tag;
-    }
-}
-export { CfvoXform };

package/dist/esm/modules/excel/xlsx/xform/sheet/cf/color-scale-xform.js

@@ -1,35 +0,0 @@
-import { CompositeXform } from "@excel/xlsx/xform/composite-xform";
-import { ColorXform } from "@excel/xlsx/xform/style/color-xform";
-import { CfvoXform } from "@excel/xlsx/xform/sheet/cf/cfvo-xform";
-class ColorScaleXform extends CompositeXform {
-    constructor() {
-        super();
-        this.map = {
-            cfvo: (this.cfvoXform = new CfvoXform()),
-            color: (this.colorXform = new ColorXform())
-        };
-    }
-    get tag() {
-        return "colorScale";
-    }
-    render(xmlStream, model) {
-        xmlStream.openNode(this.tag);
-        model.cfvo.forEach((cfvo) => {
-            this.cfvoXform.render(xmlStream, cfvo);
-        });
-        model.color.forEach((color) => {
-            this.colorXform.render(xmlStream, color);
-        });
-        xmlStream.closeNode();
-    }
-    createNewModel(node) {
-        return {
-            cfvo: [],
-            color: []
-        };
-    }
-    onParserClose(name, parser) {
-        this.model[name].push(parser.model);
-    }
-}
-export { ColorScaleXform };

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

@@ -1,37 +0,0 @@
-import { CompositeXform } from "@excel/xlsx/xform/composite-xform";
-import { CfRuleXform } from "@excel/xlsx/xform/sheet/cf/cf-rule-xform";
-class ConditionalFormattingXform extends CompositeXform {
-    constructor() {
-        super();
-        this.map = {
-            cfRule: new CfRuleXform()
-        };
-    }
-    get tag() {
-        return "conditionalFormatting";
-    }
-    render(xmlStream, model) {
-        // if there are no primitive rules, exit now
-        if (!model.rules.some(CfRuleXform.isPrimitive)) {
-            return;
-        }
-        xmlStream.openNode(this.tag, { sqref: model.ref });
-        model.rules.forEach((rule) => {
-            if (CfRuleXform.isPrimitive(rule)) {
-                rule.ref = model.ref;
-                this.map.cfRule.render(xmlStream, rule);
-            }
-        });
-        xmlStream.closeNode();
-    }
-    createNewModel({ attributes }) {
-        return {
-            ref: attributes.sqref,
-            rules: []
-        };
-    }
-    onParserClose(name, parser) {
-        this.model.rules.push(parser.model);
-    }
-}
-export { ConditionalFormattingXform };

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

@@ -1,74 +0,0 @@
-import { BaseXform } from "@excel/xlsx/xform/base-xform";
-import { ConditionalFormattingXform } from "@excel/xlsx/xform/sheet/cf/conditional-formatting-xform";
-class ConditionalFormattingsXform extends BaseXform {
-    constructor() {
-        super();
-        this.cfXform = new ConditionalFormattingXform();
-    }
-    get tag() {
-        return "conditionalFormatting";
-    }
-    reset() {
-        this.model = [];
-    }
-    prepare(model, options) {
-        // ensure each rule has a priority value
-        let nextPriority = model.reduce((p, cf) => Math.max(p, ...cf.rules.map((rule) => rule.priority || 0)), 1);
-        model.forEach((cf) => {
-            cf.rules.forEach((rule) => {
-                if (!rule.priority) {
-                    rule.priority = nextPriority++;
-                }
-                if (rule.style) {
-                    rule.dxfId = options.styles.addDxfStyle(rule.style);
-                }
-            });
-        });
-    }
-    render(xmlStream, model) {
-        model.forEach((cf) => {
-            this.cfXform.render(xmlStream, cf);
-        });
-    }
-    parseOpen(node) {
-        if (this.parser) {
-            this.parser.parseOpen(node);
-            return true;
-        }
-        switch (node.name) {
-            case "conditionalFormatting":
-                this.parser = this.cfXform;
-                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.push(this.parser.model);
-                this.parser = undefined;
-                return false;
-            }
-            return true;
-        }
-        return false;
-    }
-    reconcile(model, options) {
-        model.forEach((cf) => {
-            cf.rules.forEach((rule) => {
-                if (rule.dxfId !== undefined) {
-                    rule.style = options.styles.getDxfStyle(rule.dxfId);
-                    delete rule.dxfId;
-                }
-            });
-        });
-    }
-}
-export { ConditionalFormattingsXform };

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

@@ -1,39 +0,0 @@
-import { CompositeXform } from "@excel/xlsx/xform/composite-xform";
-import { ColorXform } from "@excel/xlsx/xform/style/color-xform";
-import { CfvoXform } from "@excel/xlsx/xform/sheet/cf/cfvo-xform";
-class DatabarXform extends CompositeXform {
-    constructor() {
-        super();
-        this.map = {
-            cfvo: (this.cfvoXform = new CfvoXform()),
-            color: (this.colorXform = new ColorXform())
-        };
-    }
-    get tag() {
-        return "dataBar";
-    }
-    render(xmlStream, model) {
-        xmlStream.openNode(this.tag);
-        model.cfvo.forEach((cfvo) => {
-            this.cfvoXform.render(xmlStream, cfvo);
-        });
-        this.colorXform.render(xmlStream, model.color);
-        xmlStream.closeNode();
-    }
-    createNewModel() {
-        return {
-            cfvo: []
-        };
-    }
-    onParserClose(name, parser) {
-        switch (name) {
-            case "cfvo":
-                this.model.cfvo.push(parser.model);
-                break;
-            case "color":
-                this.model.color = parser.model;
-                break;
-        }
-    }
-}
-export { DatabarXform };

package/dist/esm/modules/excel/xlsx/xform/sheet/cf/ext-lst-ref-xform.js

@@ -1,67 +0,0 @@
-import { BaseXform } from "@excel/xlsx/xform/base-xform";
-import { CompositeXform } from "@excel/xlsx/xform/composite-xform";
-class X14IdXform extends BaseXform {
-    get tag() {
-        return "x14:id";
-    }
-    render(xmlStream, model) {
-        xmlStream.leafNode(this.tag, null, model);
-    }
-    parseOpen() {
-        this.model = "";
-    }
-    parseText(text) {
-        this.model += text;
-    }
-    parseClose(name) {
-        return name !== this.tag;
-    }
-}
-class ExtXform extends CompositeXform {
-    constructor() {
-        super();
-        this.map = {
-            "x14:id": (this.idXform = new X14IdXform())
-        };
-    }
-    get tag() {
-        return "ext";
-    }
-    render(xmlStream, model) {
-        xmlStream.openNode(this.tag, {
-            uri: "{B025F937-C7B1-47D3-B67F-A62EFF666E3E}",
-            "xmlns:x14": "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"
-        });
-        this.idXform.render(xmlStream, model.x14Id);
-        xmlStream.closeNode();
-    }
-    createNewModel() {
-        return {};
-    }
-    onParserClose(name, parser) {
-        this.model.x14Id = parser.model;
-    }
-}
-class ExtLstRefXform extends CompositeXform {
-    constructor() {
-        super();
-        this.map = {
-            ext: new ExtXform()
-        };
-    }
-    get tag() {
-        return "extLst";
-    }
-    render(xmlStream, model) {
-        xmlStream.openNode(this.tag);
-        this.map.ext.render(xmlStream, model);
-        xmlStream.closeNode();
-    }
-    createNewModel() {
-        return {};
-    }
-    onParserClose(name, parser) {
-        Object.assign(this.model, parser.model);
-    }
-}
-export { ExtLstRefXform };

package/dist/esm/modules/excel/xlsx/xform/sheet/cf/formula-xform.js

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

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

@@ -1,37 +0,0 @@
-import { BaseXform } from "@excel/xlsx/xform/base-xform";
-import { CompositeXform } from "@excel/xlsx/xform/composite-xform";
-import { CfvoXform } from "@excel/xlsx/xform/sheet/cf/cfvo-xform";
-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/esm/modules/excel/xlsx/xform/sheet/cf-ext/cf-icon-ext-xform.js

@@ -1,22 +0,0 @@
-import { BaseXform } from "@excel/xlsx/xform/base-xform";
-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/esm/modules/excel/xlsx/xform/sheet/cf-ext/cf-rule-ext-xform.js

@@ -1,80 +0,0 @@
-import { BaseXform } from "@excel/xlsx/xform/base-xform";
-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";
-import { uuidV4 } from "@utils/uuid";
-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 };