@cj-tech-master/excelts 4.0.0 → 4.0.1

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

@@ -0,0 +1,259 @@
+import { BaseXform } from "../../base-xform.js";
+import { CompositeXform } from "../../composite-xform.js";
+import { Range } from "../../../../range.js";
+import { DatabarXform } from "./databar-xform.js";
+import { ExtLstRefXform } from "./ext-lst-ref-xform.js";
+import { FormulaXform } from "./formula-xform.js";
+import { ColorScaleXform } from "./color-scale-xform.js";
+import { IconSetXform } from "./icon-set-xform.js";
+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/browser/modules/excel/xlsx/xform/sheet/cf/cfvo-xform.d.ts

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

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

@@ -0,0 +1,22 @@
+import { BaseXform } from "../../base-xform.js";
+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/browser/modules/excel/xlsx/xform/sheet/cf/color-scale-xform.d.ts

@@ -0,0 +1,13 @@
+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";
+declare class ColorScaleXform extends CompositeXform {
+    cfvoXform: CfvoXform;
+    colorXform: ColorXform;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: any): void;
+    createNewModel(node: any): any;
+    onParserClose(name: string, parser: any): void;
+}
+export { ColorScaleXform };

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

@@ -0,0 +1,35 @@
+import { CompositeXform } from "../../composite-xform.js";
+import { ColorXform } from "../../style/color-xform.js";
+import { CfvoXform } from "./cfvo-xform.js";
+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/browser/modules/excel/xlsx/xform/sheet/cf/conditional-formatting-xform.d.ts

@@ -0,0 +1,9 @@
+import { CompositeXform } from "@excel/xlsx/xform/composite-xform";
+declare class ConditionalFormattingXform extends CompositeXform {
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: any): void;
+    createNewModel({ attributes }: any): any;
+    onParserClose(name: string, parser: any): void;
+}
+export { ConditionalFormattingXform };

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

@@ -0,0 +1,37 @@
+import { CompositeXform } from "../../composite-xform.js";
+import { CfRuleXform } from "./cf-rule-xform.js";
+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/browser/modules/excel/xlsx/xform/sheet/cf/conditional-formattings-xform.d.ts

@@ -0,0 +1,16 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import { ConditionalFormattingXform } from "@excel/xlsx/xform/sheet/cf/conditional-formatting-xform";
+declare class ConditionalFormattingsXform extends BaseXform {
+    cfXform: ConditionalFormattingXform;
+    parser: any;
+    constructor();
+    get tag(): string;
+    reset(): void;
+    prepare(model: any, options: any): void;
+    render(xmlStream: any, model: any): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    reconcile(model: any, options: any): void;
+}
+export { ConditionalFormattingsXform };

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

@@ -0,0 +1,74 @@
+import { BaseXform } from "../../base-xform.js";
+import { ConditionalFormattingXform } from "./conditional-formatting-xform.js";
+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/browser/modules/excel/xlsx/xform/sheet/cf/databar-xform.d.ts

@@ -0,0 +1,13 @@
+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";
+declare class DatabarXform extends CompositeXform {
+    cfvoXform: CfvoXform;
+    colorXform: ColorXform;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: any): void;
+    createNewModel(): any;
+    onParserClose(name: string, parser: any): void;
+}
+export { DatabarXform };

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

@@ -0,0 +1,39 @@
+import { CompositeXform } from "../../composite-xform.js";
+import { ColorXform } from "../../style/color-xform.js";
+import { CfvoXform } from "./cfvo-xform.js";
+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/browser/modules/excel/xlsx/xform/sheet/cf/ext-lst-ref-xform.d.ts

@@ -0,0 +1,9 @@
+import { CompositeXform } from "@excel/xlsx/xform/composite-xform";
+declare class ExtLstRefXform extends CompositeXform {
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: any): void;
+    createNewModel(): any;
+    onParserClose(name: string, parser: any): void;
+}
+export { ExtLstRefXform };

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

@@ -0,0 +1,67 @@
+import { BaseXform } from "../../base-xform.js";
+import { CompositeXform } from "../../composite-xform.js";
+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/browser/modules/excel/xlsx/xform/sheet/cf/formula-xform.d.ts

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

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

@@ -0,0 +1,19 @@
+import { BaseXform } from "../../base-xform.js";
+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/browser/modules/excel/xlsx/xform/sheet/cf/icon-set-xform.d.ts

@@ -0,0 +1,11 @@
+import { CompositeXform } from "@excel/xlsx/xform/composite-xform";
+import { CfvoXform } from "@excel/xlsx/xform/sheet/cf/cfvo-xform";
+declare class IconSetXform extends CompositeXform {
+    cfvoXform: CfvoXform;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: any): void;
+    createNewModel({ attributes }: any): any;
+    onParserClose(name: string, parser: any): void;
+}
+export { IconSetXform };