@cj-tech-master/excelts 0.1.0-canary.20251025023400.dff1908

package/dist/esm/xlsx/xform/sheet/cell-xform.js

@@ -0,0 +1,449 @@
+import { dateToExcel, xmlDecode, isDateFmt, excelToDate } from "../../../utils/utils.js";
+import { BaseXform } from "../base-xform.js";
+import { Range } from "../../../doc/range.js";
+import { Enums } from "../../../doc/enums.js";
+import { RichTextXform } from "../strings/rich-text-xform.js";
+function getValueType(v) {
+    if (v === null || v === undefined) {
+        return Enums.ValueType.Null;
+    }
+    if (v instanceof String || typeof v === "string") {
+        return Enums.ValueType.String;
+    }
+    if (typeof v === "number") {
+        return Enums.ValueType.Number;
+    }
+    if (typeof v === "boolean") {
+        return Enums.ValueType.Boolean;
+    }
+    if (v instanceof Date) {
+        return Enums.ValueType.Date;
+    }
+    if (v.text && v.hyperlink) {
+        return Enums.ValueType.Hyperlink;
+    }
+    if (v.formula) {
+        return Enums.ValueType.Formula;
+    }
+    if (v.error) {
+        return Enums.ValueType.Error;
+    }
+    throw new Error("I could not understand type of value");
+}
+function getEffectiveCellType(cell) {
+    switch (cell.type) {
+        case Enums.ValueType.Formula:
+            return getValueType(cell.result);
+        default:
+            return cell.type;
+    }
+}
+class CellXform extends BaseXform {
+    constructor() {
+        super();
+        this.richTextXform = new RichTextXform();
+    }
+    get tag() {
+        return "c";
+    }
+    prepare(model, options) {
+        const styleId = options.styles.addStyleModel(model.style || {}, getEffectiveCellType(model));
+        if (styleId) {
+            model.styleId = styleId;
+        }
+        if (model.comment) {
+            options.comments.push({ ...model.comment, ref: model.address });
+        }
+        switch (model.type) {
+            case Enums.ValueType.String:
+            case Enums.ValueType.RichText:
+                if (options.sharedStrings) {
+                    model.ssId = options.sharedStrings.add(model.value);
+                }
+                break;
+            case Enums.ValueType.Date:
+                if (options.date1904) {
+                    model.date1904 = true;
+                }
+                break;
+            case Enums.ValueType.Hyperlink:
+                if (options.sharedStrings && model.text !== undefined && model.text !== null) {
+                    model.ssId = options.sharedStrings.add(model.text);
+                }
+                options.hyperlinks.push({
+                    address: model.address,
+                    target: model.hyperlink,
+                    tooltip: model.tooltip
+                });
+                break;
+            case Enums.ValueType.Merge:
+                options.merges.add(model);
+                break;
+            case Enums.ValueType.Formula:
+                if (options.date1904) {
+                    // in case valueType is date
+                    model.date1904 = true;
+                }
+                if (model.shareType === "shared") {
+                    model.si = options.siFormulae++;
+                }
+                if (model.formula) {
+                    options.formulae[model.address] = model;
+                }
+                else if (model.sharedFormula) {
+                    const master = options.formulae[model.sharedFormula];
+                    if (!master) {
+                        throw new Error(`Shared Formula master must exist above and or left of clone for cell ${model.address}`);
+                    }
+                    if (master.si === undefined) {
+                        master.shareType = "shared";
+                        master.si = options.siFormulae++;
+                        master.range = new Range(master.address, model.address);
+                    }
+                    else if (master.range) {
+                        master.range.expandToAddress(model.address);
+                    }
+                    model.si = master.si;
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    renderFormula(xmlStream, model) {
+        let attrs = null;
+        switch (model.shareType) {
+            case "shared":
+                attrs = {
+                    t: "shared",
+                    ref: model.ref || model.range.range,
+                    si: model.si
+                };
+                break;
+            case "array":
+                attrs = {
+                    t: "array",
+                    ref: model.ref
+                };
+                break;
+            default:
+                if (model.si !== undefined) {
+                    attrs = {
+                        t: "shared",
+                        si: model.si
+                    };
+                }
+                break;
+        }
+        switch (getValueType(model.result)) {
+            case Enums.ValueType.Null: // ?
+                xmlStream.leafNode("f", attrs, model.formula);
+                break;
+            case Enums.ValueType.String:
+                // oddly, formula results don't ever use shared strings
+                xmlStream.addAttribute("t", "str");
+                xmlStream.leafNode("f", attrs, model.formula);
+                xmlStream.leafNode("v", null, model.result);
+                break;
+            case Enums.ValueType.Number:
+                xmlStream.leafNode("f", attrs, model.formula);
+                xmlStream.leafNode("v", null, model.result);
+                break;
+            case Enums.ValueType.Boolean:
+                xmlStream.addAttribute("t", "b");
+                xmlStream.leafNode("f", attrs, model.formula);
+                xmlStream.leafNode("v", null, model.result ? 1 : 0);
+                break;
+            case Enums.ValueType.Error:
+                xmlStream.addAttribute("t", "e");
+                xmlStream.leafNode("f", attrs, model.formula);
+                xmlStream.leafNode("v", null, model.result.error);
+                break;
+            case Enums.ValueType.Date:
+                xmlStream.leafNode("f", attrs, model.formula);
+                xmlStream.leafNode("v", null, dateToExcel(model.result, model.date1904));
+                break;
+            // case Enums.ValueType.Hyperlink: // ??
+            // case Enums.ValueType.Formula:
+            default:
+                throw new Error("I could not understand type of value");
+        }
+    }
+    render(xmlStream, model) {
+        if (model.type === Enums.ValueType.Null && !model.styleId) {
+            // if null and no style, exit
+            return;
+        }
+        xmlStream.openNode("c");
+        xmlStream.addAttribute("r", model.address);
+        if (model.styleId) {
+            xmlStream.addAttribute("s", model.styleId);
+        }
+        switch (model.type) {
+            case Enums.ValueType.Null:
+                break;
+            case Enums.ValueType.Number:
+                xmlStream.leafNode("v", null, model.value);
+                break;
+            case Enums.ValueType.Boolean:
+                xmlStream.addAttribute("t", "b");
+                xmlStream.leafNode("v", null, model.value ? "1" : "0");
+                break;
+            case Enums.ValueType.Error:
+                xmlStream.addAttribute("t", "e");
+                xmlStream.leafNode("v", null, model.value.error);
+                break;
+            case Enums.ValueType.String:
+            case Enums.ValueType.RichText:
+                if (model.ssId !== undefined) {
+                    xmlStream.addAttribute("t", "s");
+                    xmlStream.leafNode("v", null, model.ssId);
+                }
+                else if (model.value && model.value.richText) {
+                    xmlStream.addAttribute("t", "inlineStr");
+                    xmlStream.openNode("is");
+                    model.value.richText.forEach(text => {
+                        this.richTextXform.render(xmlStream, text);
+                    });
+                    xmlStream.closeNode("is");
+                }
+                else {
+                    xmlStream.addAttribute("t", "str");
+                    xmlStream.leafNode("v", null, model.value);
+                }
+                break;
+            case Enums.ValueType.Date:
+                xmlStream.leafNode("v", null, dateToExcel(model.value, model.date1904));
+                break;
+            case Enums.ValueType.Hyperlink:
+                if (model.ssId !== undefined) {
+                    xmlStream.addAttribute("t", "s");
+                    xmlStream.leafNode("v", null, model.ssId);
+                }
+                else {
+                    xmlStream.addAttribute("t", "str");
+                    xmlStream.leafNode("v", null, model.text);
+                }
+                break;
+            case Enums.ValueType.Formula:
+                this.renderFormula(xmlStream, model);
+                break;
+            case Enums.ValueType.Merge:
+                // nothing to add
+                break;
+            default:
+                break;
+        }
+        xmlStream.closeNode(); // </c>
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case "c":
+                // const address = colCache.decodeAddress(node.attributes.r);
+                this.model = {
+                    address: node.attributes.r
+                };
+                this.t = node.attributes.t;
+                if (node.attributes.s) {
+                    this.model.styleId = parseInt(node.attributes.s, 10);
+                }
+                return true;
+            case "f":
+                this.currentNode = "f";
+                this.model.si = node.attributes.si;
+                this.model.shareType = node.attributes.t;
+                this.model.ref = node.attributes.ref;
+                return true;
+            case "v":
+                this.currentNode = "v";
+                return true;
+            case "t":
+                this.currentNode = "t";
+                return true;
+            case "r":
+                this.parser = this.richTextXform;
+                this.parser.parseOpen(node);
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+            return;
+        }
+        switch (this.currentNode) {
+            case "f":
+                this.model.formula = this.model.formula ? this.model.formula + text : text;
+                break;
+            case "v":
+            case "t":
+                if (this.model.value && this.model.value.richText) {
+                    this.model.value.richText.text = this.model.value.richText.text
+                        ? this.model.value.richText.text + text
+                        : text;
+                }
+                else {
+                    this.model.value = this.model.value ? this.model.value + text : text;
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    parseClose(name) {
+        switch (name) {
+            case "c": {
+                const { model } = this;
+                // first guess on cell type
+                if (model.formula || model.shareType) {
+                    model.type = Enums.ValueType.Formula;
+                    if (model.value) {
+                        if (this.t === "str") {
+                            model.result = xmlDecode(model.value);
+                        }
+                        else if (this.t === "b") {
+                            model.result = parseInt(model.value, 10) !== 0;
+                        }
+                        else if (this.t === "e") {
+                            model.result = { error: model.value };
+                        }
+                        else {
+                            model.result = parseFloat(model.value);
+                        }
+                        model.value = undefined;
+                    }
+                }
+                else if (model.value !== undefined) {
+                    switch (this.t) {
+                        case "s":
+                            model.type = Enums.ValueType.String;
+                            model.value = parseInt(model.value, 10);
+                            break;
+                        case "str":
+                            model.type = Enums.ValueType.String;
+                            model.value = xmlDecode(model.value);
+                            break;
+                        case "inlineStr":
+                            model.type = Enums.ValueType.String;
+                            break;
+                        case "b":
+                            model.type = Enums.ValueType.Boolean;
+                            model.value = parseInt(model.value, 10) !== 0;
+                            break;
+                        case "e":
+                            model.type = Enums.ValueType.Error;
+                            model.value = { error: model.value };
+                            break;
+                        default:
+                            model.type = Enums.ValueType.Number;
+                            model.value = parseFloat(model.value);
+                            break;
+                    }
+                }
+                else if (model.styleId) {
+                    model.type = Enums.ValueType.Null;
+                }
+                else {
+                    model.type = Enums.ValueType.Merge;
+                }
+                return false;
+            }
+            case "f":
+            case "v":
+            case "is":
+                this.currentNode = undefined;
+                return true;
+            case "t":
+                if (this.parser) {
+                    this.parser.parseClose(name);
+                    return true;
+                }
+                this.currentNode = undefined;
+                return true;
+            case "r":
+                this.model.value = this.model.value || {};
+                this.model.value.richText = this.model.value.richText || [];
+                this.model.value.richText.push(this.parser.model);
+                this.parser = undefined;
+                this.currentNode = undefined;
+                return true;
+            default:
+                if (this.parser) {
+                    this.parser.parseClose(name);
+                    return true;
+                }
+                return false;
+        }
+    }
+    reconcile(model, options) {
+        const style = model.styleId && options.styles && options.styles.getStyleModel(model.styleId);
+        if (style) {
+            model.style = style;
+        }
+        if (model.styleId !== undefined) {
+            model.styleId = undefined;
+        }
+        switch (model.type) {
+            case Enums.ValueType.String:
+                if (typeof model.value === "number") {
+                    if (options.sharedStrings) {
+                        model.value = options.sharedStrings.getString(model.value);
+                    }
+                }
+                if (model.value.richText) {
+                    model.type = Enums.ValueType.RichText;
+                }
+                break;
+            case Enums.ValueType.Number:
+                if (style && isDateFmt(style.numFmt)) {
+                    model.type = Enums.ValueType.Date;
+                    model.value = excelToDate(model.value, options.date1904);
+                }
+                break;
+            case Enums.ValueType.Formula:
+                if (model.result !== undefined && style && isDateFmt(style.numFmt)) {
+                    model.result = excelToDate(model.result, options.date1904);
+                }
+                if (model.shareType === "shared") {
+                    if (model.ref) {
+                        // master
+                        options.formulae[model.si] = model.address;
+                    }
+                    else {
+                        // slave
+                        model.sharedFormula = options.formulae[model.si];
+                        delete model.shareType;
+                    }
+                    delete model.si;
+                }
+                break;
+            default:
+                break;
+        }
+        // look for hyperlink
+        const hyperlink = options.hyperlinkMap[model.address];
+        if (hyperlink) {
+            if (model.type === Enums.ValueType.Formula) {
+                model.text = model.result;
+                model.result = undefined;
+            }
+            else {
+                model.text = model.value;
+                model.value = undefined;
+            }
+            model.type = Enums.ValueType.Hyperlink;
+            model.hyperlink = hyperlink;
+        }
+        const comment = options.commentsMap && options.commentsMap[model.address];
+        if (comment) {
+            model.comment = comment;
+        }
+    }
+}
+export { CellXform };

package/dist/esm/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 "../../../../doc/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 };