@cj-tech-master/excelts 3.0.1 → 3.1.0-canary.20260102043356.6791d4e

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

@@ -1,285 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataValidationsXform = void 0;
-const base_xform_1 = require("../base-xform");
-const range_1 = require("../../../doc/range");
-const utils_1 = require("../../../utils/utils");
-const col_cache_1 = require("../../../utils/col-cache");
-const under_dash_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_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 [];
-    }
-    // First, handle range: prefixed keys directly (large ranges stored during parsing)
-    const rangeValidations = [];
-    const regularModel = {};
-    for (const [key, value] of Object.entries(model)) {
-        // Skip undefined/null values (removed validations)
-        if (value === undefined || value === null) {
-            continue;
-        }
-        if (key.startsWith("range:")) {
-            // Large range stored during parsing - output directly
-            const rangeStr = key.slice(6); // Remove "range:" prefix
-            const { sqref: _sqref, ...rest } = value;
-            rangeValidations.push({
-                ...rest,
-                sqref: rangeStr
-            });
-        }
-        else {
-            regularModel[key] = value;
-        }
-    }
-    // If no regular entries, just return range validations
-    if (Object.keys(regularModel).length === 0) {
-        return rangeValidations;
-    }
-    const dvList = Object.entries(regularModel)
-        .map(([address, dataValidation]) => ({
-        address,
-        dataValidation,
-        marked: false
-    }))
-        .sort((a, b) => a.address.localeCompare(b.address));
-    const dvMap = Object.fromEntries(dvList.map(dv => [dv.address, dv]));
-    const matchCol = (addr, height, col) => {
-        for (let i = 0; i < height; i++) {
-            const otherAddress = col_cache_1.colCache.encodeAddress(addr.row + i, col);
-            if (!regularModel[otherAddress] ||
-                !(0, under_dash_1.isEqual)(regularModel[addr.address], regularModel[otherAddress])) {
-                return false;
-            }
-        }
-        return true;
-    };
-    const optimized = dvList
-        .map(dv => {
-        if (!dv.marked) {
-            const addr = col_cache_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_1.colCache.encodeAddress(addr.row + height, addr.col);
-            while (regularModel[otherAddress] &&
-                (0, under_dash_1.isEqual)(dv.dataValidation, regularModel[otherAddress])) {
-                height++;
-                otherAddress = col_cache_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_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_1.colCache.encodeAddress(bottom, right)}`
-                };
-            }
-            return {
-                ...dv.dataValidation,
-                sqref: dv.address
-            };
-        }
-        return null;
-    })
-        .filter(Boolean);
-    return [...rangeValidations, ...optimized];
-}
-class DataValidationsXform extends base_xform_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_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_1.Range(addr);
-                        // Only expand small ranges to avoid performance issues with large ranges
-                        // like B2:B1048576 (entire column validations)
-                        const rangeSize = (range.bottom - range.top + 1) * (range.right - range.left + 1);
-                        if (rangeSize <= 1000) {
-                            // Small range: expand to individual cells for backward compatibility
-                            range.forEachAddress((address) => {
-                                this.model[address] = this._dataValidation;
-                            });
-                        }
-                        else {
-                            // Large range: store as range string with special marker
-                            // The key format "range:A1:Z100" allows DataValidations.find() to detect it
-                            this.model[`range:${addr}`] = this._dataValidation;
-                        }
-                    }
-                    else {
-                        this.model[addr] = this._dataValidation;
-                    }
-                });
-                return true;
-            }
-            case "formula1":
-            case "formula2": {
-                let formula = this._formula.join("");
-                switch (this._dataValidation.type) {
-                    case "whole":
-                    case "textLength":
-                        formula = parseInt(formula, 10);
-                        break;
-                    case "decimal":
-                        formula = parseFloat(formula);
-                        break;
-                    case "date":
-                        formula = (0, utils_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

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DimensionXform = void 0;
-const base_xform_1 = require("../base-xform");
-class DimensionXform extends base_xform_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

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DrawingXform = void 0;
-const base_xform_1 = require("../base-xform");
-class DrawingXform extends base_xform_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

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExtLstXform = void 0;
-const composite_xform_1 = require("../composite-xform");
-const conditional_formattings_ext_xform_1 = require("./cf-ext/conditional-formattings-ext-xform");
-class ExtXform extends composite_xform_1.CompositeXform {
-    constructor() {
-        super();
-        this.map = {
-            "x14:conditionalFormattings": (this.conditionalFormattings =
-                new conditional_formattings_ext_xform_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_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

@@ -1,127 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HeaderFooterXform = void 0;
-const base_xform_1 = require("../base-xform");
-class HeaderFooterXform extends base_xform_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

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HyperlinkXform = void 0;
-const base_xform_1 = require("../base-xform");
-class HyperlinkXform extends base_xform_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

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MergeCellXform = void 0;
-const base_xform_1 = require("../base-xform");
-class MergeCellXform extends base_xform_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

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Merges = void 0;
-const range_1 = require("../../../doc/range");
-const col_cache_1 = require("../../../utils/col-cache");
-const enums_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_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_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_1.Enums.ValueType.Null,
-                            address: col_cache_1.colCache.encodeAddress(i, j)
-                        };
-                    }
-                    else if (cell.type === enums_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;