@cj-tech-master/excelts 3.1.0 → 4.0.0

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

@@ -1,50 +0,0 @@
-import { Range } from "../../../doc/range.js";
-import { colCache } from "../../../utils/col-cache.js";
-import { Enums } from "../../../doc/enums.js";
-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(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 = 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.ValueType.Null,
-                            address: colCache.encodeAddress(i, j)
-                        };
-                    }
-                    else if (cell.type === 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;
-    }
-}
-export { Merges };

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

@@ -1,152 +0,0 @@
-import { BaseXform } from "../base-xform.js";
-import { CellXform } from "./cell-xform.js";
-import { parseBoolean } from "../../../utils/utils.js";
-import { colCache } from "../../../utils/col-cache.js";
-class RowXform extends BaseXform {
-    constructor(options) {
-        super();
-        this.maxItems = options && options.maxItems;
-        this.map = {
-            c: new CellXform()
-        };
-    }
-    get tag() {
-        return "row";
-    }
-    reset() {
-        super.reset();
-        this.numRowsSeen = 0;
-        this.lastCellCol = 0;
-    }
-    prepare(model, options) {
-        const styleId = options.styles.addStyleModel(model.style);
-        if (styleId) {
-            model.styleId = styleId;
-        }
-        const cellXform = this.map.c;
-        model.cells.forEach((cellModel) => {
-            cellXform.prepare(cellModel, options);
-        });
-    }
-    render(xmlStream, model, options) {
-        if (!model) {
-            return;
-        }
-        xmlStream.openNode("row");
-        xmlStream.addAttribute("r", model.number);
-        if (model.height) {
-            xmlStream.addAttribute("ht", model.height);
-            xmlStream.addAttribute("customHeight", "1");
-        }
-        if (model.hidden) {
-            xmlStream.addAttribute("hidden", "1");
-        }
-        if (model.min > 0 && model.max > 0 && model.min <= model.max) {
-            xmlStream.addAttribute("spans", `${model.min}:${model.max}`);
-        }
-        if (model.styleId) {
-            xmlStream.addAttribute("s", model.styleId);
-            xmlStream.addAttribute("customFormat", "1");
-        }
-        // Note: dyDescent is MS extension, not output by default (Excel auto-calculates)
-        if (model.outlineLevel) {
-            xmlStream.addAttribute("outlineLevel", model.outlineLevel);
-        }
-        if (model.collapsed) {
-            xmlStream.addAttribute("collapsed", "1");
-        }
-        const cellXform = this.map.c;
-        model.cells.forEach((cellModel) => {
-            cellXform.render(xmlStream, cellModel, options);
-        });
-        xmlStream.closeNode();
-    }
-    parseOpen(node) {
-        if (this.parser) {
-            this.parser.parseOpen(node);
-            return true;
-        }
-        if (node.name === "row") {
-            this.numRowsSeen += 1;
-            // Reset lastCellCol for each new row
-            this.lastCellCol = 0;
-            const spans = node.attributes.spans
-                ? node.attributes.spans.split(":").map((span) => parseInt(span, 10))
-                : [undefined, undefined];
-            // If r attribute is missing, use numRowsSeen as the row number
-            const rowNumber = node.attributes.r ? parseInt(node.attributes.r, 10) : this.numRowsSeen;
-            const model = (this.model = {
-                number: rowNumber,
-                min: spans[0],
-                max: spans[1],
-                cells: []
-            });
-            if (node.attributes.s) {
-                model.styleId = parseInt(node.attributes.s, 10);
-            }
-            if (parseBoolean(node.attributes.hidden)) {
-                model.hidden = true;
-            }
-            if (parseBoolean(node.attributes.bestFit)) {
-                model.bestFit = true;
-            }
-            if (node.attributes.ht) {
-                model.height = parseFloat(node.attributes.ht);
-            }
-            if (node.attributes.outlineLevel) {
-                model.outlineLevel = parseInt(node.attributes.outlineLevel, 10);
-            }
-            if (parseBoolean(node.attributes.collapsed)) {
-                model.collapsed = true;
-            }
-            return true;
-        }
-        this.parser = this.map[node.name];
-        if (this.parser) {
-            this.parser.parseOpen(node);
-            return true;
-        }
-        return false;
-    }
-    parseText(text) {
-        if (this.parser) {
-            this.parser.parseText(text);
-        }
-    }
-    parseClose(name) {
-        if (this.parser) {
-            if (!this.parser.parseClose(name)) {
-                const cellModel = this.parser.model;
-                // If cell has address, extract column number from it
-                // Otherwise, calculate address based on position
-                if (cellModel.address) {
-                    const decoded = colCache.decodeAddress(cellModel.address);
-                    this.lastCellCol = decoded.col;
-                }
-                else {
-                    // No r attribute, calculate address from position
-                    this.lastCellCol += 1;
-                    cellModel.address = colCache.encodeAddress(this.model.number, this.lastCellCol);
-                }
-                this.model.cells.push(cellModel);
-                if (this.maxItems && this.model.cells.length > this.maxItems) {
-                    throw new Error(`Max column count (${this.maxItems}) exceeded`);
-                }
-                this.parser = undefined;
-            }
-            return true;
-        }
-        return false;
-    }
-    reconcile(model, options) {
-        model.style = model.styleId ? options.styles.getStyleModel(model.styleId) : {};
-        if (model.styleId !== undefined) {
-            model.styleId = undefined;
-        }
-        const cellXform = this.map.c;
-        model.cells.forEach((cellModel) => {
-            cellXform.reconcile(cellModel, options);
-        });
-    }
-}
-export { RowXform };