@cj-tech-master/excelts 3.1.0 → 4.0.0

package/dist/esm/modules/excel/row.js

@@ -0,0 +1,441 @@
+import { Enums } from "./enums.js";
+import { colCache } from "./utils/col-cache.js";
+import { Cell } from "./cell.js";
+class Row {
+    constructor(worksheet, number) {
+        this._worksheet = worksheet;
+        this._number = number;
+        this._cells = [];
+        this.style = {};
+        this.outlineLevel = 0;
+    }
+    /**
+     * The row number
+     */
+    get number() {
+        return this._number;
+    }
+    /**
+     * The worksheet that contains this row
+     */
+    get worksheet() {
+        return this._worksheet;
+    }
+    /**
+     * Commit a completed row to stream.
+     * Inform Streaming Writer that this row (and all rows before it) are complete
+     * and ready to write. Has no effect on Worksheet document.
+     */
+    commit() {
+        this._worksheet._commitRow(this);
+    }
+    /**
+     * Helps GC by breaking cyclic references
+     */
+    destroy() {
+        delete this._worksheet;
+        delete this._cells;
+        delete this.style;
+    }
+    findCell(colNumber) {
+        return this._cells[colNumber - 1];
+    }
+    // given {address, row, col}, find or create new cell
+    getCellEx(address) {
+        let cell = this._cells[address.col - 1];
+        if (!cell) {
+            const column = this._worksheet.getColumn(address.col);
+            cell = new Cell(this, column, address.address);
+            this._cells[address.col - 1] = cell;
+        }
+        return cell;
+    }
+    /**
+     * Get cell by number, column letter or column key
+     */
+    getCell(col) {
+        let colNum;
+        if (typeof col === "string") {
+            // is it a key?
+            const column = this._worksheet.getColumnKey(col);
+            if (column) {
+                colNum = column.number;
+            }
+            else {
+                colNum = colCache.l2n(col);
+            }
+        }
+        else {
+            colNum = col;
+        }
+        return (this._cells[colNum - 1] ||
+            this.getCellEx({
+                address: colCache.encodeAddress(this._number, colNum),
+                row: this._number,
+                col: colNum
+            }));
+    }
+    /**
+     * Cut one or more cells (cells to the right are shifted left)
+     *
+     * Note: this operation will not affect other rows
+     */
+    splice(start, count, ...inserts) {
+        const nKeep = start + count;
+        const nExpand = inserts.length - count;
+        const nEnd = this._cells.length;
+        let i;
+        let cSrc;
+        let cDst;
+        if (nExpand < 0) {
+            // remove cells
+            for (i = start + inserts.length; i <= nEnd; i++) {
+                cDst = this._cells[i - 1];
+                cSrc = this._cells[i - nExpand - 1];
+                if (cSrc) {
+                    cDst = this.getCell(i);
+                    cDst.value = cSrc.value;
+                    cDst.style = cSrc.style;
+                    cDst.comment = cSrc.comment;
+                }
+                else if (cDst) {
+                    cDst.value = null;
+                    cDst.style = {};
+                    cDst.comment = undefined;
+                }
+            }
+        }
+        else if (nExpand > 0) {
+            // insert new cells
+            for (i = nEnd; i >= nKeep; i--) {
+                cSrc = this._cells[i - 1];
+                if (cSrc) {
+                    cDst = this.getCell(i + nExpand);
+                    cDst.value = cSrc.value;
+                    cDst.style = cSrc.style;
+                    cDst.comment = cSrc.comment;
+                }
+                else {
+                    this._cells[i + nExpand - 1] = undefined;
+                }
+            }
+        }
+        // now add the new values
+        for (i = 0; i < inserts.length; i++) {
+            cDst = this.getCell(start + i);
+            cDst.value = inserts[i];
+            cDst.style = {};
+            cDst.comment = undefined;
+        }
+    }
+    eachCell(optOrCallback, maybeCallback) {
+        let options = null;
+        let callback;
+        if (typeof optOrCallback === "function") {
+            callback = optOrCallback;
+        }
+        else {
+            options = optOrCallback;
+            callback = maybeCallback;
+        }
+        if (options && options.includeEmpty) {
+            const n = this._cells.length;
+            for (let i = 1; i <= n; i++) {
+                callback(this.getCell(i), i);
+            }
+        }
+        else {
+            this._cells.forEach((cell, index) => {
+                if (cell && cell.type !== Enums.ValueType.Null) {
+                    callback(cell, index + 1);
+                }
+            });
+        }
+    }
+    // ===========================================================================
+    // Page Breaks
+    addPageBreak(lft, rght) {
+        const ws = this._worksheet;
+        const left = Math.max(0, (lft || 0) - 1) || 0;
+        const right = Math.max(0, (rght || 0) - 1) || 16838;
+        const pb = {
+            id: this._number,
+            max: right,
+            man: 1
+        };
+        if (left) {
+            pb.min = left;
+        }
+        ws.rowBreaks.push(pb);
+    }
+    /**
+     * Get a row as a sparse array
+     */
+    get values() {
+        const values = [];
+        this._cells.forEach(cell => {
+            if (cell && cell.type !== Enums.ValueType.Null) {
+                values[cell.col] = cell.value;
+            }
+        });
+        return values;
+    }
+    /**
+     * Set the values by contiguous or sparse array, or by key'd object literal
+     */
+    set values(value) {
+        // this operation is not additive - any prior cells are removed
+        this._cells = [];
+        if (!value) {
+            // empty row
+        }
+        else if (value instanceof Array) {
+            let offset = 0;
+            if (Object.prototype.hasOwnProperty.call(value, "0")) {
+                // contiguous array - start at column 1
+                offset = 1;
+            }
+            value.forEach((item, index) => {
+                if (item !== undefined) {
+                    this.getCellEx({
+                        address: colCache.encodeAddress(this._number, index + offset),
+                        row: this._number,
+                        col: index + offset
+                    }).value = item;
+                }
+            });
+        }
+        else {
+            // assume object with column keys
+            this._worksheet.eachColumnKey((column, key) => {
+                if (value[key] !== undefined) {
+                    this.getCellEx({
+                        address: colCache.encodeAddress(this._number, column.number),
+                        row: this._number,
+                        col: column.number
+                    }).value = value[key];
+                }
+            });
+        }
+    }
+    /**
+     * Get row values as a 0-based sparse array (column 1 => index 0).
+     *
+     * This is useful when you want to compare/stringify values without the
+     * leading separator produced by the 1-based sparse array returned by `values`.
+     */
+    getValues() {
+        const values = [];
+        this._cells.forEach(cell => {
+            if (cell && cell.type !== Enums.ValueType.Null) {
+                values[cell.col - 1] = cell.value;
+            }
+        });
+        return values;
+    }
+    /**
+     * Convenience stringification for row values.
+     *
+     * Equivalent to `row.getValues().join(separator)`.
+     */
+    valuesToString(separator = ",") {
+        return this.getValues().join(separator);
+    }
+    /**
+     * Returns true if the row includes at least one cell with a value
+     */
+    get hasValues() {
+        return this._cells.some(cell => cell && cell.type !== Enums.ValueType.Null);
+    }
+    /**
+     * Number of cells including empty ones
+     */
+    get cellCount() {
+        return this._cells.length;
+    }
+    /**
+     * Number of non-empty cells
+     */
+    get actualCellCount() {
+        let count = 0;
+        this.eachCell(() => {
+            count++;
+        });
+        return count;
+    }
+    /**
+     * Get the min and max column number for the non-null cells in this row or null
+     */
+    get dimensions() {
+        let min = 0;
+        let max = 0;
+        this._cells.forEach(cell => {
+            if (cell && cell.type !== Enums.ValueType.Null) {
+                if (!min || min > cell.col) {
+                    min = cell.col;
+                }
+                if (max < cell.col) {
+                    max = cell.col;
+                }
+            }
+        });
+        return min > 0
+            ? {
+                min,
+                max
+            }
+            : null;
+    }
+    // =========================================================================
+    // styles
+    _applyStyle(name, value) {
+        this.style[name] = value;
+        this._cells.forEach(cell => {
+            if (cell) {
+                cell.style[name] = value;
+            }
+        });
+    }
+    get numFmt() {
+        return this.style.numFmt;
+    }
+    set numFmt(value) {
+        if (value !== undefined) {
+            this._applyStyle("numFmt", value);
+        }
+    }
+    get font() {
+        return this.style.font;
+    }
+    set font(value) {
+        if (value !== undefined) {
+            this._applyStyle("font", value);
+        }
+    }
+    get alignment() {
+        return this.style.alignment;
+    }
+    set alignment(value) {
+        if (value !== undefined) {
+            this._applyStyle("alignment", value);
+        }
+    }
+    get protection() {
+        return this.style.protection;
+    }
+    set protection(value) {
+        if (value !== undefined) {
+            this._applyStyle("protection", value);
+        }
+    }
+    get border() {
+        return this.style.border;
+    }
+    set border(value) {
+        if (value !== undefined) {
+            this._applyStyle("border", value);
+        }
+    }
+    get fill() {
+        return this.style.fill;
+    }
+    set fill(value) {
+        if (value !== undefined) {
+            this._applyStyle("fill", value);
+        }
+    }
+    get hidden() {
+        return !!this._hidden;
+    }
+    set hidden(value) {
+        this._hidden = value;
+    }
+    get outlineLevel() {
+        return this._outlineLevel || 0;
+    }
+    set outlineLevel(value) {
+        this._outlineLevel = value;
+    }
+    get collapsed() {
+        return !!(this._outlineLevel && this._outlineLevel >= this._worksheet.properties.outlineLevelRow);
+    }
+    // =========================================================================
+    get model() {
+        const cells = [];
+        let min = 0;
+        let max = 0;
+        this._cells.forEach(cell => {
+            if (cell) {
+                const cellModel = cell.model;
+                if (cellModel) {
+                    if (!min || min > cell.col) {
+                        min = cell.col;
+                    }
+                    if (max < cell.col) {
+                        max = cell.col;
+                    }
+                    cells.push(cellModel);
+                }
+            }
+        });
+        return this.height || cells.length
+            ? {
+                cells,
+                number: this.number,
+                min,
+                max,
+                height: this.height,
+                style: this.style,
+                hidden: this.hidden,
+                outlineLevel: this.outlineLevel,
+                collapsed: this.collapsed
+            }
+            : null;
+    }
+    set model(value) {
+        if (value.number !== this._number) {
+            throw new Error("Invalid row number in model");
+        }
+        this._cells = [];
+        let previousAddress;
+        value.cells.forEach(cellModel => {
+            switch (cellModel.type) {
+                case Cell.Types.Merge:
+                    // special case - don't add this types
+                    break;
+                default: {
+                    let address;
+                    if (cellModel.address) {
+                        address = colCache.decodeAddress(cellModel.address);
+                    }
+                    else if (previousAddress) {
+                        // This is a <c> element without an r attribute
+                        // Assume that it's the cell for the next column
+                        const { row } = previousAddress;
+                        const col = previousAddress.col + 1;
+                        address = {
+                            row,
+                            col,
+                            address: colCache.encodeAddress(row, col),
+                            $col$row: `$${colCache.n2l(col)}$${row}`
+                        };
+                    }
+                    previousAddress = address;
+                    const cell = this.getCellEx(address);
+                    cell.model = cellModel;
+                    break;
+                }
+            }
+        });
+        if (value.height) {
+            this.height = value.height;
+        }
+        else {
+            delete this.height;
+        }
+        this.hidden = value.hidden;
+        this.outlineLevel = value.outlineLevel || 0;
+        this.style = (value.style && JSON.parse(JSON.stringify(value.style))) || {};
+    }
+}
+export { Row };

package/dist/esm/modules/excel/stream/hyperlink-reader.js

@@ -0,0 +1,84 @@
+/**
+ * HyperlinkReader - Streaming Hyperlink Reader
+ *
+ * Cross-platform implementation.
+ */
+import { EventEmitter } from "../../stream/index.js";
+import { parseSax } from "../utils/parse-sax.js";
+import { Enums } from "../enums.js";
+import { RelType } from "../xlsx/rel-type.js";
+class HyperlinkReader extends EventEmitter {
+    constructor({ workbook, id, iterator, options }) {
+        super();
+        this._hyperlinkCount = 0;
+        this.workbook = workbook;
+        this.id = id;
+        this.iterator = iterator;
+        this.options = options;
+    }
+    get count() {
+        return this.hyperlinks ? this._hyperlinkCount : 0;
+    }
+    each(fn) {
+        const hyperlinks = this.hyperlinks;
+        if (!hyperlinks) {
+            return;
+        }
+        for (const rId in hyperlinks) {
+            fn(hyperlinks[rId], rId);
+        }
+    }
+    async read() {
+        const { iterator } = this;
+        const hyperlinkMode = this.options.hyperlinks;
+        const emitHyperlinks = hyperlinkMode === "emit";
+        const cacheHyperlinks = hyperlinkMode === "cache";
+        let cachedHyperlinks = null;
+        if (cacheHyperlinks) {
+            this._hyperlinkCount = 0;
+            this.hyperlinks = cachedHyperlinks = Object.create(null);
+        }
+        if (!emitHyperlinks && !cacheHyperlinks) {
+            this.emit("finished");
+            return;
+        }
+        try {
+            for await (const events of parseSax(iterator)) {
+                for (const { eventType, value } of events) {
+                    if (eventType !== "opentag") {
+                        continue;
+                    }
+                    const node = value;
+                    if (node.name !== "Relationship") {
+                        continue;
+                    }
+                    const attributes = node.attributes;
+                    if (attributes.Type !== RelType.Hyperlink) {
+                        continue;
+                    }
+                    const relationship = {
+                        type: Enums.RelationshipType.Hyperlink,
+                        rId: attributes.Id,
+                        target: attributes.Target,
+                        targetMode: attributes.TargetMode
+                    };
+                    if (emitHyperlinks) {
+                        this.emit("hyperlink", relationship);
+                        continue;
+                    }
+                    // cache mode
+                    const rId = relationship.rId;
+                    if (cachedHyperlinks && cachedHyperlinks[rId] === undefined) {
+                        this._hyperlinkCount += 1;
+                    }
+                    cachedHyperlinks[rId] = relationship;
+                }
+            }
+            this.emit("finished");
+        }
+        catch (error) {
+            this.emit("error", error);
+        }
+    }
+}
+export { HyperlinkReader };

package/dist/esm/modules/excel/stream/sheet-comments-writer.js

@@ -0,0 +1,101 @@
+import { XmlStream } from "../utils/xml-stream.js";
+import { RelType } from "../xlsx/rel-type.js";
+import { colCache } from "../utils/col-cache.js";
+import { CommentXform } from "../xlsx/xform/comment/comment-xform.js";
+import { VmlShapeXform } from "../xlsx/xform/comment/vml-shape-xform.js";
+import { commentsPath, commentsRelTargetFromWorksheet, vmlDrawingPath, vmlDrawingRelTargetFromWorksheet } from "../utils/ooxml-paths.js";
+class SheetCommentsWriter {
+    constructor(worksheet, sheetRelsWriter, options) {
+        // in a workbook, each sheet will have a number
+        this.id = options.id;
+        this.count = 0;
+        this._worksheet = worksheet;
+        this._workbook = options.workbook;
+        this._sheetRelsWriter = sheetRelsWriter;
+    }
+    get commentsStream() {
+        if (!this._commentsStream) {
+            this._commentsStream = this._workbook._openStream(commentsPath(this.id));
+        }
+        return this._commentsStream;
+    }
+    get vmlStream() {
+        if (!this._vmlStream) {
+            this._vmlStream = this._workbook._openStream(vmlDrawingPath(this.id));
+        }
+        return this._vmlStream;
+    }
+    _addRelationships() {
+        const commentRel = {
+            Type: RelType.Comments,
+            Target: commentsRelTargetFromWorksheet(this.id)
+        };
+        this._sheetRelsWriter.addRelationship(commentRel);
+        const vmlDrawingRel = {
+            Type: RelType.VmlDrawing,
+            Target: vmlDrawingRelTargetFromWorksheet(this.id)
+        };
+        this.vmlRelId = this._sheetRelsWriter.addRelationship(vmlDrawingRel);
+    }
+    _addCommentRefs() {
+        this._workbook.commentRefs.push({
+            commentName: `comments${this.id}`,
+            vmlDrawing: `vmlDrawing${this.id}`
+        });
+    }
+    _writeOpen() {
+        this.commentsStream.write('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+            '<comments xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">' +
+            "<authors><author>Author</author></authors>" +
+            "<commentList>");
+        this.vmlStream.write('<?xml version="1.0" encoding="UTF-8"?>' +
+            '<xml xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:x="urn:schemas-microsoft-com:office:excel">' +
+            '<o:shapelayout v:ext="edit">' +
+            '<o:idmap v:ext="edit" data="1" />' +
+            "</o:shapelayout>" +
+            '<v:shapetype id="_x0000_t202" coordsize="21600,21600" o:spt="202" path="m,l,21600r21600,l21600,xe">' +
+            '<v:stroke joinstyle="miter" />' +
+            '<v:path gradientshapeok="t" o:connecttype="rect" />' +
+            "</v:shapetype>");
+    }
+    _writeComment(comment, index) {
+        const commentXform = new CommentXform();
+        const commentsXmlStream = new XmlStream();
+        commentXform.render(commentsXmlStream, comment);
+        this.commentsStream.write(commentsXmlStream.xml);
+        const vmlShapeXform = new VmlShapeXform();
+        const vmlXmlStream = new XmlStream();
+        vmlShapeXform.render(vmlXmlStream, comment, index);
+        this.vmlStream.write(vmlXmlStream.xml);
+    }
+    _writeClose() {
+        this.commentsStream.write("</commentList></comments>");
+        this.vmlStream.write("</xml>");
+    }
+    addComments(comments) {
+        if (comments && comments.length) {
+            if (!this.startedData) {
+                this._worksheet.comments = [];
+                this._writeOpen();
+                this._addRelationships();
+                this._addCommentRefs();
+                this.startedData = true;
+            }
+            comments.forEach(item => {
+                item.refAddress = colCache.decodeAddress(item.ref);
+            });
+            comments.forEach(comment => {
+                this._writeComment(comment, this.count);
+                this.count += 1;
+            });
+        }
+    }
+    commit() {
+        if (this.count) {
+            this._writeClose();
+            this.commentsStream.end();
+            this.vmlStream.end();
+        }
+    }
+}
+export { SheetCommentsWriter };