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

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

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataValidationsXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+const range_js_1 = require("../../../doc/range");
+const utils_js_1 = require("../../../utils/utils");
+const col_cache_js_1 = require("../../../utils/col-cache");
+const under_dash_js_1 = require("../../../utils/under-dash");
+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] = (0, utils_js_1.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 [];
+    }
+    const dvList = Object.entries(model)
+        .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 = col_cache_js_1.colCache.encodeAddress(addr.row + i, col);
+            if (!model[otherAddress] || !(0, under_dash_js_1.isEqual)(model[addr.address], model[otherAddress])) {
+                return false;
+            }
+        }
+        return true;
+    };
+    return dvList
+        .map(dv => {
+        if (!dv.marked) {
+            const addr = col_cache_js_1.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 = col_cache_js_1.colCache.encodeAddress(addr.row + height, addr.col);
+            while (model[otherAddress] && (0, under_dash_js_1.isEqual)(dv.dataValidation, model[otherAddress])) {
+                height++;
+                otherAddress = col_cache_js_1.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 = col_cache_js_1.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}:${col_cache_js_1.colCache.encodeAddress(bottom, right)}`
+                };
+            }
+            return {
+                ...dv.dataValidation,
+                sqref: dv.address
+            };
+        }
+        return null;
+    })
+        .filter(Boolean);
+}
+class DataValidationsXform extends base_xform_js_1.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((0, utils_js_1.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_js_1.Range(addr);
+                        range.forEachAddress((address) => {
+                            this.model[address] = 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 = (0, utils_js_1.excelToDate)(parseFloat(formula));
+                        break;
+                    default:
+                        break;
+                }
+                this._dataValidation.formulae.push(formula);
+                this._formula = undefined;
+                return true;
+            }
+            default:
+                return true;
+        }
+    }
+}
+exports.DataValidationsXform = DataValidationsXform;

package/dist/cjs/xlsx/xform/sheet/dimension-xform.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DimensionXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+class DimensionXform extends base_xform_js_1.BaseXform {
+    get tag() {
+        return "dimension";
+    }
+    render(xmlStream, model) {
+        if (model) {
+            xmlStream.leafNode("dimension", { ref: model });
+        }
+    }
+    parseOpen(node) {
+        if (node.name === "dimension") {
+            this.model = node.attributes.ref;
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+exports.DimensionXform = DimensionXform;

package/dist/cjs/xlsx/xform/sheet/drawing-xform.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrawingXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+class DrawingXform extends base_xform_js_1.BaseXform {
+    get tag() {
+        return "drawing";
+    }
+    render(xmlStream, model) {
+        if (model) {
+            xmlStream.leafNode(this.tag, { "r:id": model.rId });
+        }
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case this.tag:
+                this.model = {
+                    rId: node.attributes["r:id"]
+                };
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+exports.DrawingXform = DrawingXform;

package/dist/cjs/xlsx/xform/sheet/ext-lst-xform.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtLstXform = void 0;
+const composite_xform_js_1 = require("../composite-xform");
+const conditional_formattings_ext_xform_js_1 = require("./cf-ext/conditional-formattings-ext-xform");
+class ExtXform extends composite_xform_js_1.CompositeXform {
+    constructor() {
+        super();
+        this.map = {
+            "x14:conditionalFormattings": (this.conditionalFormattings =
+                new conditional_formattings_ext_xform_js_1.ConditionalFormattingsExtXform())
+        };
+    }
+    get tag() {
+        return "ext";
+    }
+    hasContent(model) {
+        return this.conditionalFormattings.hasContent(model.conditionalFormattings);
+    }
+    prepare(model) {
+        this.conditionalFormattings.prepare(model.conditionalFormattings);
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode("ext", {
+            uri: "{78C0D931-6437-407d-A8EE-F0AAD7539E65}",
+            "xmlns:x14": "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"
+        });
+        this.conditionalFormattings.render(xmlStream, model.conditionalFormattings);
+        xmlStream.closeNode();
+    }
+    createNewModel() {
+        return {};
+    }
+    onParserClose(name, parser) {
+        this.model[name] = parser.model;
+    }
+}
+class ExtLstXform extends composite_xform_js_1.CompositeXform {
+    constructor() {
+        super();
+        this.map = {
+            ext: (this.ext = new ExtXform())
+        };
+    }
+    get tag() {
+        return "extLst";
+    }
+    prepare(model, _options) {
+        this.ext.prepare(model);
+    }
+    hasContent(model) {
+        return this.ext.hasContent(model);
+    }
+    render(xmlStream, model) {
+        if (!this.hasContent(model)) {
+            return;
+        }
+        xmlStream.openNode("extLst");
+        this.ext.render(xmlStream, model);
+        xmlStream.closeNode();
+    }
+    createNewModel() {
+        return {};
+    }
+    onParserClose(name, parser) {
+        this.model[name] = parser.model;
+    }
+}
+exports.ExtLstXform = ExtLstXform;

package/dist/cjs/xlsx/xform/sheet/header-footer-xform.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaderFooterXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+class HeaderFooterXform extends base_xform_js_1.BaseXform {
+    get tag() {
+        return "headerFooter";
+    }
+    render(xmlStream, model) {
+        if (model) {
+            xmlStream.addRollback();
+            let createTag = false;
+            xmlStream.openNode("headerFooter");
+            if (model.differentFirst) {
+                xmlStream.addAttribute("differentFirst", "1");
+                createTag = true;
+            }
+            if (model.differentOddEven) {
+                xmlStream.addAttribute("differentOddEven", "1");
+                createTag = true;
+            }
+            if (model.oddHeader && typeof model.oddHeader === "string") {
+                xmlStream.leafNode("oddHeader", null, model.oddHeader);
+                createTag = true;
+            }
+            if (model.oddFooter && typeof model.oddFooter === "string") {
+                xmlStream.leafNode("oddFooter", null, model.oddFooter);
+                createTag = true;
+            }
+            if (model.evenHeader && typeof model.evenHeader === "string") {
+                xmlStream.leafNode("evenHeader", null, model.evenHeader);
+                createTag = true;
+            }
+            if (model.evenFooter && typeof model.evenFooter === "string") {
+                xmlStream.leafNode("evenFooter", null, model.evenFooter);
+                createTag = true;
+            }
+            if (model.firstHeader && typeof model.firstHeader === "string") {
+                xmlStream.leafNode("firstHeader", null, model.firstHeader);
+                createTag = true;
+            }
+            if (model.firstFooter && typeof model.firstFooter === "string") {
+                xmlStream.leafNode("firstFooter", null, model.firstFooter);
+                createTag = true;
+            }
+            if (createTag) {
+                xmlStream.closeNode();
+                xmlStream.commit();
+            }
+            else {
+                xmlStream.rollback();
+            }
+        }
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case "headerFooter":
+                this.model = {};
+                if (node.attributes.differentFirst) {
+                    this.model.differentFirst = parseInt(node.attributes.differentFirst, 0) === 1;
+                }
+                if (node.attributes.differentOddEven) {
+                    this.model.differentOddEven = parseInt(node.attributes.differentOddEven, 0) === 1;
+                }
+                return true;
+            case "oddHeader":
+                this.currentNode = "oddHeader";
+                return true;
+            case "oddFooter":
+                this.currentNode = "oddFooter";
+                return true;
+            case "evenHeader":
+                this.currentNode = "evenHeader";
+                return true;
+            case "evenFooter":
+                this.currentNode = "evenFooter";
+                return true;
+            case "firstHeader":
+                this.currentNode = "firstHeader";
+                return true;
+            case "firstFooter":
+                this.currentNode = "firstFooter";
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText(text) {
+        switch (this.currentNode) {
+            case "oddHeader":
+                this.model.oddHeader = (this.model.oddHeader || "") + text;
+                break;
+            case "oddFooter":
+                this.model.oddFooter = (this.model.oddFooter || "") + text;
+                break;
+            case "evenHeader":
+                this.model.evenHeader = (this.model.evenHeader || "") + text;
+                break;
+            case "evenFooter":
+                this.model.evenFooter = (this.model.evenFooter || "") + text;
+                break;
+            case "firstHeader":
+                this.model.firstHeader = (this.model.firstHeader || "") + text;
+                break;
+            case "firstFooter":
+                this.model.firstFooter = (this.model.firstFooter || "") + text;
+                break;
+            default:
+                break;
+        }
+    }
+    parseClose() {
+        switch (this.currentNode) {
+            case "oddHeader":
+            case "oddFooter":
+            case "evenHeader":
+            case "evenFooter":
+            case "firstHeader":
+            case "firstFooter":
+                this.currentNode = undefined;
+                return true;
+            default:
+                return false;
+        }
+    }
+}
+exports.HeaderFooterXform = HeaderFooterXform;

package/dist/cjs/xlsx/xform/sheet/hyperlink-xform.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperlinkXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+class HyperlinkXform extends base_xform_js_1.BaseXform {
+    get tag() {
+        return "hyperlink";
+    }
+    render(xmlStream, model) {
+        if (this.isInternalLink(model)) {
+            xmlStream.leafNode("hyperlink", {
+                ref: model.address,
+                "r:id": model.rId,
+                tooltip: model.tooltip,
+                location: model.target
+            });
+        }
+        else {
+            xmlStream.leafNode("hyperlink", {
+                ref: model.address,
+                "r:id": model.rId,
+                tooltip: model.tooltip
+            });
+        }
+    }
+    parseOpen(node) {
+        if (node.name === "hyperlink") {
+            this.model = {
+                address: node.attributes.ref,
+                rId: node.attributes["r:id"],
+                tooltip: node.attributes.tooltip
+            };
+            // This is an internal link
+            if (node.attributes.location) {
+                this.model.target = node.attributes.location;
+            }
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+    isInternalLink(model) {
+        // @example: Sheet2!D3, return true
+        return !!(model.target && /^[^!]+![a-zA-Z]+[\d]+$/.test(model.target));
+    }
+}
+exports.HyperlinkXform = HyperlinkXform;

package/dist/cjs/xlsx/xform/sheet/merge-cell-xform.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergeCellXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+class MergeCellXform extends base_xform_js_1.BaseXform {
+    get tag() {
+        return "mergeCell";
+    }
+    render(xmlStream, model) {
+        xmlStream.leafNode("mergeCell", { ref: model });
+    }
+    parseOpen(node) {
+        if (node.name === "mergeCell") {
+            this.model = node.attributes.ref;
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+exports.MergeCellXform = MergeCellXform;

package/dist/cjs/xlsx/xform/sheet/merges.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Merges = void 0;
+const range_js_1 = require("../../../doc/range");
+const col_cache_js_1 = require("../../../utils/col-cache");
+const enums_js_1 = require("../../../doc/enums");
+class Merges {
+    constructor() {
+        // optional mergeCells is array of ranges (like the xml)
+        this.merges = {};
+    }
+    add(merge) {
+        // merge is {address, master}
+        if (this.merges[merge.master]) {
+            this.merges[merge.master].expandToAddress(merge.address);
+        }
+        else {
+            const range = `${merge.master}:${merge.address}`;
+            this.merges[merge.master] = new range_js_1.Range(range);
+        }
+    }
+    get mergeCells() {
+        return Object.values(this.merges).map((merge) => merge.range);
+    }
+    reconcile(mergeCells, rows) {
+        // reconcile merge list with merge cells
+        mergeCells.forEach((merge) => {
+            const dimensions = col_cache_js_1.colCache.decode(merge);
+            for (let i = dimensions.top; i <= dimensions.bottom; i++) {
+                const row = rows[i - 1];
+                for (let j = dimensions.left; j <= dimensions.right; j++) {
+                    const cell = row.cells[j - 1];
+                    if (!cell) {
+                        // nulls are not included in document - so if master cell has no value - add a null one here
+                        row.cells[j] = {
+                            type: enums_js_1.Enums.ValueType.Null,
+                            address: col_cache_js_1.colCache.encodeAddress(i, j)
+                        };
+                    }
+                    else if (cell.type === enums_js_1.Enums.ValueType.Merge) {
+                        cell.master = dimensions.tl;
+                    }
+                }
+            }
+        });
+    }
+    getMasterAddress(address) {
+        // if address has been merged, return its master's address. Assumes reconcile has been called
+        const range = this.hash[address];
+        return range && range.tl;
+    }
+}
+exports.Merges = Merges;

package/dist/cjs/xlsx/xform/sheet/outline-properties-xform.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutlinePropertiesXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+const isDefined = (attr) => typeof attr !== "undefined";
+class OutlinePropertiesXform extends base_xform_js_1.BaseXform {
+    get tag() {
+        return "outlinePr";
+    }
+    render(xmlStream, model) {
+        if (model && (isDefined(model.summaryBelow) || isDefined(model.summaryRight))) {
+            xmlStream.leafNode(this.tag, {
+                summaryBelow: isDefined(model.summaryBelow) ? Number(model.summaryBelow) : undefined,
+                summaryRight: isDefined(model.summaryRight) ? Number(model.summaryRight) : undefined
+            });
+            return true;
+        }
+        return false;
+    }
+    parseOpen(node) {
+        if (node.name === this.tag) {
+            this.model = {
+                summaryBelow: isDefined(node.attributes.summaryBelow)
+                    ? Boolean(Number(node.attributes.summaryBelow))
+                    : undefined,
+                summaryRight: isDefined(node.attributes.summaryRight)
+                    ? Boolean(Number(node.attributes.summaryRight))
+                    : undefined
+            };
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+exports.OutlinePropertiesXform = OutlinePropertiesXform;