@cj-tech-master/excelts 4.0.0 → 4.0.1

package/dist/browser/modules/excel/range.js

@@ -0,0 +1,280 @@
+import { colCache } from "./utils/col-cache.js";
+// used by worksheet to calculate sheet dimensions
+class Range {
+    constructor(...args) {
+        this.model = {
+            top: 0,
+            left: 0,
+            bottom: 0,
+            right: 0
+        };
+        this.decode(args);
+    }
+    setTLBR(t, l, b, r, s) {
+        if (typeof t === "string" && typeof l === "string") {
+            // setTLBR(tl, br, s) - t and l are address strings
+            const tl = colCache.decodeAddress(t);
+            const br = colCache.decodeAddress(l);
+            this.model = {
+                top: Math.min(tl.row, br.row),
+                left: Math.min(tl.col, br.col),
+                bottom: Math.max(tl.row, br.row),
+                right: Math.max(tl.col, br.col),
+                sheetName: typeof b === "string" ? b : undefined
+            };
+        }
+        else if (typeof t === "number" &&
+            typeof l === "number" &&
+            typeof b === "number" &&
+            typeof r === "number") {
+            // setTLBR(t, l, b, r, s) - all numbers
+            this.model = {
+                top: Math.min(t, b),
+                left: Math.min(l, r),
+                bottom: Math.max(t, b),
+                right: Math.max(l, r),
+                sheetName: s
+            };
+        }
+    }
+    decode(argv) {
+        switch (argv.length) {
+            case 5: // [t,l,b,r,s]
+                if (typeof argv[0] === "number" &&
+                    typeof argv[1] === "number" &&
+                    typeof argv[2] === "number" &&
+                    typeof argv[3] === "number" &&
+                    typeof argv[4] === "string") {
+                    this.setTLBR(argv[0], argv[1], argv[2], argv[3], argv[4]);
+                }
+                break;
+            case 4: // [t,l,b,r]
+                if (typeof argv[0] === "number" &&
+                    typeof argv[1] === "number" &&
+                    typeof argv[2] === "number" &&
+                    typeof argv[3] === "number") {
+                    this.setTLBR(argv[0], argv[1], argv[2], argv[3]);
+                }
+                break;
+            case 3: // [tl,br,s]
+                if (typeof argv[0] === "string" &&
+                    typeof argv[1] === "string" &&
+                    typeof argv[2] === "string") {
+                    this.setTLBR(argv[0], argv[1], argv[2]);
+                }
+                break;
+            case 2: // [tl,br]
+                if (typeof argv[0] === "string" && typeof argv[1] === "string") {
+                    this.setTLBR(argv[0], argv[1]);
+                }
+                break;
+            case 1: {
+                const value = argv[0];
+                if (value instanceof Range) {
+                    // copy constructor
+                    this.model = {
+                        top: value.model.top,
+                        left: value.model.left,
+                        bottom: value.model.bottom,
+                        right: value.model.right,
+                        sheetName: value.sheetName
+                    };
+                }
+                else if (Array.isArray(value)) {
+                    // an arguments array
+                    this.decode(value);
+                }
+                else if (typeof value === "object" &&
+                    "top" in value &&
+                    "left" in value &&
+                    "bottom" in value &&
+                    "right" in value) {
+                    // a model
+                    this.model = {
+                        top: value.top,
+                        left: value.left,
+                        bottom: value.bottom,
+                        right: value.right,
+                        sheetName: value.sheetName
+                    };
+                }
+                else if (typeof value === "string") {
+                    // [sheetName!]tl:br
+                    const decoded = colCache.decodeEx(value);
+                    if ("top" in decoded) {
+                        // It's a DecodedRange
+                        this.model = {
+                            top: decoded.top,
+                            left: decoded.left,
+                            bottom: decoded.bottom,
+                            right: decoded.right,
+                            sheetName: decoded.sheetName
+                        };
+                    }
+                    else if ("row" in decoded) {
+                        // It's an Address
+                        this.model = {
+                            top: decoded.row,
+                            left: decoded.col,
+                            bottom: decoded.row,
+                            right: decoded.col,
+                            sheetName: decoded.sheetName
+                        };
+                    }
+                }
+                break;
+            }
+            case 0:
+                this.model = {
+                    top: 0,
+                    left: 0,
+                    bottom: 0,
+                    right: 0
+                };
+                break;
+            default:
+                throw new Error(`Invalid number of arguments to _getDimensions() - ${argv.length}`);
+        }
+    }
+    get top() {
+        return this.model.top || 1;
+    }
+    set top(value) {
+        this.model.top = value;
+    }
+    get left() {
+        return this.model.left || 1;
+    }
+    set left(value) {
+        this.model.left = value;
+    }
+    get bottom() {
+        return this.model.bottom || 1;
+    }
+    set bottom(value) {
+        this.model.bottom = value;
+    }
+    get right() {
+        return this.model.right || 1;
+    }
+    set right(value) {
+        this.model.right = value;
+    }
+    get sheetName() {
+        return this.model.sheetName;
+    }
+    set sheetName(value) {
+        this.model.sheetName = value;
+    }
+    get _serialisedSheetName() {
+        const { sheetName } = this.model;
+        if (sheetName) {
+            if (/^[a-zA-Z0-9]*$/.test(sheetName)) {
+                return `${sheetName}!`;
+            }
+            return `'${sheetName}'!`;
+        }
+        return "";
+    }
+    expand(top, left, bottom, right) {
+        if (!this.model.top || top < this.top) {
+            this.top = top;
+        }
+        if (!this.model.left || left < this.left) {
+            this.left = left;
+        }
+        if (!this.model.bottom || bottom > this.bottom) {
+            this.bottom = bottom;
+        }
+        if (!this.model.right || right > this.right) {
+            this.right = right;
+        }
+    }
+    expandRow(row) {
+        if (row) {
+            const { dimensions, number } = row;
+            if (dimensions) {
+                this.expand(number, dimensions.min, number, dimensions.max);
+            }
+        }
+    }
+    expandToAddress(addressStr) {
+        const address = colCache.decodeEx(addressStr);
+        if ("row" in address && "col" in address) {
+            this.expand(address.row, address.col, address.row, address.col);
+        }
+    }
+    get tl() {
+        return colCache.n2l(this.left) + this.top;
+    }
+    get $t$l() {
+        return `$${colCache.n2l(this.left)}$${this.top}`;
+    }
+    get br() {
+        return colCache.n2l(this.right) + this.bottom;
+    }
+    get $b$r() {
+        return `$${colCache.n2l(this.right)}$${this.bottom}`;
+    }
+    get range() {
+        return `${this._serialisedSheetName + this.tl}:${this.br}`;
+    }
+    get $range() {
+        return `${this._serialisedSheetName + this.$t$l}:${this.$b$r}`;
+    }
+    get shortRange() {
+        return this.count > 1 ? this.range : this._serialisedSheetName + this.tl;
+    }
+    get $shortRange() {
+        return this.count > 1 ? this.$range : this._serialisedSheetName + this.$t$l;
+    }
+    get count() {
+        return (1 + this.bottom - this.top) * (1 + this.right - this.left);
+    }
+    toString() {
+        return this.range;
+    }
+    intersects(other) {
+        if (other.sheetName && this.sheetName && other.sheetName !== this.sheetName) {
+            return false;
+        }
+        if (other.bottom < this.top) {
+            return false;
+        }
+        if (other.top > this.bottom) {
+            return false;
+        }
+        if (other.right < this.left) {
+            return false;
+        }
+        if (other.left > this.right) {
+            return false;
+        }
+        return true;
+    }
+    contains(addressStr) {
+        const address = colCache.decodeEx(addressStr);
+        if ("row" in address && "col" in address) {
+            return this.containsEx(address);
+        }
+        return false;
+    }
+    containsEx(address) {
+        if (address.sheetName && this.sheetName && address.sheetName !== this.sheetName) {
+            return false;
+        }
+        return (address.row >= this.top &&
+            address.row <= this.bottom &&
+            address.col >= this.left &&
+            address.col <= this.right);
+    }
+    forEachAddress(cb) {
+        for (let col = this.left; col <= this.right; col++) {
+            for (let row = this.top; row <= this.bottom; row++) {
+                cb(colCache.encodeAddress(row, col), row, col);
+            }
+        }
+    }
+}
+export { Range };
+export { Range as Dimensions };

package/dist/browser/modules/excel/row.d.ts

@@ -0,0 +1,127 @@
+import { Cell, type CellModel, type CellAddress } from "@excel/cell";
+import type { Worksheet } from "@excel/worksheet";
+import type { Style, NumFmt, Font, Alignment, Protection, Borders, Fill, CellValue, RowValues } from "@excel/types";
+interface RowDimensions {
+    min: number;
+    max: number;
+}
+export interface RowModel {
+    cells: CellModel[];
+    number: number;
+    min: number;
+    max: number;
+    height?: number;
+    style: Partial<Style>;
+    hidden: boolean;
+    outlineLevel: number;
+    collapsed: boolean;
+}
+declare class Row {
+    private _worksheet;
+    private _number;
+    private _cells;
+    style: Partial<Style>;
+    private _hidden?;
+    private _outlineLevel?;
+    height?: number;
+    constructor(worksheet: Worksheet, number: number);
+    /**
+     * The row number
+     */
+    get number(): number;
+    /**
+     * The worksheet that contains this row
+     */
+    get worksheet(): 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(): void;
+    /**
+     * Helps GC by breaking cyclic references
+     */
+    destroy(): void;
+    findCell(colNumber: number): Cell | undefined;
+    getCellEx(address: CellAddress): Cell;
+    /**
+     * Get cell by number, column letter or column key
+     */
+    getCell(col: string | number): Cell;
+    /**
+     * Cut one or more cells (cells to the right are shifted left)
+     *
+     * Note: this operation will not affect other rows
+     */
+    splice(start: number, count: number, ...inserts: CellValue[]): void;
+    /**
+     * Iterate over all non-null cells in a row
+     */
+    eachCell(callback: (cell: Cell, colNumber: number) => void): void;
+    /**
+     * Iterate over all cells in a row (including empty cells)
+     */
+    eachCell(opt: {
+        includeEmpty?: boolean;
+    }, callback: (cell: Cell, colNumber: number) => void): void;
+    addPageBreak(lft?: number, rght?: number): void;
+    /**
+     * Get a row as a sparse array
+     */
+    get values(): CellValue[];
+    /**
+     * Set the values by contiguous or sparse array, or by key'd object literal
+     */
+    set values(value: RowValues);
+    /**
+     * 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(): CellValue[];
+    /**
+     * Convenience stringification for row values.
+     *
+     * Equivalent to `row.getValues().join(separator)`.
+     */
+    valuesToString(separator?: string): string;
+    /**
+     * Returns true if the row includes at least one cell with a value
+     */
+    get hasValues(): boolean;
+    /**
+     * Number of cells including empty ones
+     */
+    get cellCount(): number;
+    /**
+     * Number of non-empty cells
+     */
+    get actualCellCount(): number;
+    /**
+     * Get the min and max column number for the non-null cells in this row or null
+     */
+    get dimensions(): RowDimensions | null;
+    private _applyStyle;
+    get numFmt(): string | NumFmt | undefined;
+    set numFmt(value: string | undefined);
+    get font(): Partial<Font> | undefined;
+    set font(value: Partial<Font> | undefined);
+    get alignment(): Partial<Alignment> | undefined;
+    set alignment(value: Partial<Alignment> | undefined);
+    get protection(): Partial<Protection> | undefined;
+    set protection(value: Partial<Protection> | undefined);
+    get border(): Partial<Borders> | undefined;
+    set border(value: Partial<Borders> | undefined);
+    get fill(): Fill | undefined;
+    set fill(value: Fill | undefined);
+    get hidden(): boolean;
+    set hidden(value: boolean);
+    get outlineLevel(): number;
+    set outlineLevel(value: number);
+    get collapsed(): boolean;
+    get model(): RowModel | null;
+    set model(value: RowModel);
+}
+export { Row };