@cj-tech-master/excelts 3.0.1 → 3.1.0-canary.20260102041828.82ed571

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

@@ -0,0 +1,358 @@
+import { colCache } from "@excel/utils/col-cache";
+import { isEqual } from "@excel/utils/under-dash";
+import { Enums } from "@excel/enums";
+const DEFAULT_COLUMN_WIDTH = 9;
+/**
+ * Column defines the column properties for 1 column.
+ * This includes header rows, widths, key, (style), etc.
+ * Worksheet will condense the columns as appropriate during serialization
+ */
+class Column {
+    constructor(worksheet, number, defn) {
+        this._worksheet = worksheet;
+        this._number = number;
+        if (defn !== false) {
+            // sometimes defn will follow
+            this.defn = defn;
+        }
+    }
+    get number() {
+        return this._number;
+    }
+    get worksheet() {
+        return this._worksheet;
+    }
+    /**
+     * Column letter key
+     */
+    get letter() {
+        return colCache.n2l(this._number);
+    }
+    get isCustomWidth() {
+        return this.width !== undefined && this.width !== DEFAULT_COLUMN_WIDTH;
+    }
+    get defn() {
+        return {
+            header: this._header,
+            key: this.key,
+            width: this.width,
+            style: this.style,
+            hidden: this.hidden,
+            outlineLevel: this.outlineLevel
+        };
+    }
+    set defn(value) {
+        if (value) {
+            this.key = value.key;
+            this.width = value.width !== undefined ? value.width : DEFAULT_COLUMN_WIDTH;
+            this.outlineLevel = value.outlineLevel;
+            if (value.style) {
+                this.style = value.style;
+            }
+            else {
+                this.style = {};
+            }
+            // headers must be set after style
+            this.header = value.header;
+            this._hidden = !!value.hidden;
+        }
+        else {
+            delete this._header;
+            delete this._key;
+            delete this.width;
+            this.style = {};
+            this.outlineLevel = 0;
+        }
+    }
+    /**
+     * Get header values as an array (for multi-row header support)
+     */
+    get headers() {
+        if (Array.isArray(this._header)) {
+            return this._header;
+        }
+        if (this._header !== undefined) {
+            return [this._header];
+        }
+        return [];
+    }
+    /**
+     * Can be a single value or an array for multi-row headers.
+     * Supports any CellValue type including Date, number, string, etc.
+     */
+    get header() {
+        return this._header;
+    }
+    set header(value) {
+        if (value !== undefined) {
+            this._header = value;
+            this.headers.forEach((cellValue, index) => {
+                this._worksheet.getCell(index + 1, this.number).value = cellValue;
+            });
+        }
+        else {
+            this._header = undefined;
+        }
+    }
+    /**
+     * The name of the properties associated with this column in each row
+     */
+    get key() {
+        return this._key;
+    }
+    set key(value) {
+        const column = this._key && this._worksheet.getColumnKey(this._key);
+        if (column === this) {
+            this._worksheet.deleteColumnKey(this._key);
+        }
+        this._key = value;
+        if (value) {
+            this._worksheet.setColumnKey(this._key, this);
+        }
+    }
+    /**
+     * Hides the column
+     */
+    get hidden() {
+        return !!this._hidden;
+    }
+    set hidden(value) {
+        this._hidden = value;
+    }
+    /**
+     * Set an outline level for columns
+     */
+    get outlineLevel() {
+        return this._outlineLevel || 0;
+    }
+    set outlineLevel(value) {
+        this._outlineLevel = value;
+    }
+    /**
+     * Indicate the collapsed state based on outlineLevel
+     */
+    get collapsed() {
+        return !!(this._outlineLevel && this._outlineLevel >= this._worksheet.properties.outlineLevelCol);
+    }
+    toString() {
+        return JSON.stringify({
+            key: this.key,
+            width: this.width,
+            headers: this.headers.length ? this.headers : undefined
+        });
+    }
+    equivalentTo(other) {
+        return (this.width === other.width &&
+            this.hidden === other.hidden &&
+            this.outlineLevel === other.outlineLevel &&
+            isEqual(this.style, other.style));
+    }
+    equivalentToModel(model) {
+        return (this.width === model.width &&
+            this.hidden === model.hidden &&
+            this.outlineLevel === model.outlineLevel &&
+            isEqual(this.style, model.style));
+    }
+    get isDefault() {
+        if (this.isCustomWidth) {
+            return false;
+        }
+        if (this.hidden) {
+            return false;
+        }
+        if (this.outlineLevel) {
+            return false;
+        }
+        const s = this.style;
+        if (s && (s.font || s.numFmt || s.alignment || s.border || s.fill || s.protection)) {
+            return false;
+        }
+        return true;
+    }
+    get headerCount() {
+        return this.headers.length;
+    }
+    eachCell(optionsOrCallback, maybeCallback) {
+        const colNumber = this.number;
+        let options;
+        let callback;
+        if (typeof optionsOrCallback === "function") {
+            options = {};
+            callback = optionsOrCallback;
+        }
+        else {
+            options = optionsOrCallback;
+            callback = maybeCallback;
+        }
+        this._worksheet.eachRow(options, (row, rowNumber) => {
+            callback(row.getCell(colNumber), rowNumber);
+        });
+    }
+    /**
+     * The cell values in the column
+     */
+    get values() {
+        const v = [];
+        this.eachCell((cell, rowNumber) => {
+            if (cell && cell.type !== Enums.ValueType.Null) {
+                v[rowNumber] = cell.value;
+            }
+        });
+        return v;
+    }
+    set values(v) {
+        if (!v) {
+            return;
+        }
+        const colNumber = this.number;
+        let offset = 0;
+        if (Object.prototype.hasOwnProperty.call(v, "0")) {
+            // assume contiguous array, start at row 1
+            offset = 1;
+        }
+        v.forEach((value, index) => {
+            this._worksheet.getCell(index + offset, colNumber).value = value;
+        });
+    }
+    // =========================================================================
+    // Page Breaks
+    /**
+     * Add a page break after this column.
+     * @param top - Optional top row limit for the page break (1-indexed)
+     * @param bottom - Optional bottom row limit for the page break (1-indexed)
+     */
+    addPageBreak(top, bottom) {
+        const ws = this._worksheet;
+        const topRow = Math.max(0, (top || 0) - 1) || 0;
+        const bottomRow = Math.max(0, (bottom || 0) - 1) || 1048575;
+        const pb = {
+            id: this._number,
+            max: bottomRow,
+            man: 1
+        };
+        if (topRow) {
+            pb.min = topRow;
+        }
+        ws.colBreaks.push(pb);
+    }
+    // =========================================================================
+    // styles
+    get numFmt() {
+        return this.style.numFmt;
+    }
+    set numFmt(value) {
+        this.style.numFmt = value;
+        this.eachCell(cell => {
+            cell.numFmt = value;
+        });
+    }
+    get font() {
+        return this.style.font;
+    }
+    set font(value) {
+        this.style.font = value;
+        this.eachCell(cell => {
+            cell.font = value;
+        });
+    }
+    get alignment() {
+        return this.style.alignment;
+    }
+    set alignment(value) {
+        this.style.alignment = value;
+        this.eachCell(cell => {
+            cell.alignment = value;
+        });
+    }
+    get protection() {
+        return this.style.protection;
+    }
+    set protection(value) {
+        this.style.protection = value;
+        this.eachCell(cell => {
+            cell.protection = value;
+        });
+    }
+    get border() {
+        return this.style.border;
+    }
+    set border(value) {
+        this.style.border = value;
+        this.eachCell(cell => {
+            cell.border = value;
+        });
+    }
+    get fill() {
+        return this.style.fill;
+    }
+    set fill(value) {
+        this.style.fill = value;
+        this.eachCell(cell => {
+            cell.fill = value;
+        });
+    }
+    // =============================================================================
+    // static functions
+    static toModel(columns) {
+        // Convert array of Column into compressed list cols
+        const cols = [];
+        let col = null;
+        if (columns) {
+            columns.forEach((column, index) => {
+                if (column.isDefault) {
+                    if (col) {
+                        col = null;
+                    }
+                }
+                else if (!col || !column.equivalentToModel(col)) {
+                    col = {
+                        min: index + 1,
+                        max: index + 1,
+                        width: column.width !== undefined ? column.width : DEFAULT_COLUMN_WIDTH,
+                        style: column.style,
+                        isCustomWidth: column.isCustomWidth,
+                        hidden: column.hidden,
+                        outlineLevel: column.outlineLevel,
+                        collapsed: column.collapsed
+                    };
+                    cols.push(col);
+                }
+                else {
+                    col.max = index + 1;
+                }
+            });
+        }
+        return cols.length ? cols : undefined;
+    }
+    static fromModel(worksheetOrCols, colsMaybe) {
+        // Streaming readers historically called Column.fromModel(cols) without a Worksheet.
+        // Preserve that behavior by accepting the 1-arg form and intentionally using the
+        // cols array as the backing "worksheet" object.
+        const worksheet = Array.isArray(worksheetOrCols)
+            ? worksheetOrCols
+            : worksheetOrCols;
+        let cols = Array.isArray(worksheetOrCols) ? worksheetOrCols : (colsMaybe ?? []);
+        cols = cols || [];
+        const columns = [];
+        let count = 1;
+        let index = 0;
+        /**
+         * sort cols by min
+         * If it is not sorted, the subsequent column configuration will be overwritten
+         * */
+        cols = cols.sort(function (pre, next) {
+            return pre.min - next.min;
+        });
+        while (index < cols.length) {
+            const col = cols[index++];
+            while (count < col.min) {
+                columns.push(new Column(worksheet, count++));
+            }
+            while (count <= col.max) {
+                columns.push(new Column(worksheet, count++, col));
+            }
+        }
+        return columns.length ? columns : null;
+    }
+}
+export { Column };

package/dist/esm/modules/excel/data-validations.js

@@ -0,0 +1,43 @@
+import { colCache } from "@excel/utils/col-cache";
+class DataValidations {
+    constructor(model) {
+        this.model = model || {};
+    }
+    add(address, validation) {
+        return (this.model[address] = validation);
+    }
+    find(address) {
+        // First check direct address match
+        const direct = this.model[address];
+        if (direct !== undefined) {
+            return direct;
+        }
+        // Check range: prefixed keys in model (from parsing ranges)
+        // Only decode address if we see at least one range key.
+        let decoded;
+        for (const key in this.model) {
+            if (!key.startsWith("range:")) {
+                continue;
+            }
+            decoded || (decoded = colCache.decodeAddress(address));
+            const rangeStr = key.slice(6); // Remove "range:" prefix
+            const rangeDecoded = colCache.decodeEx(rangeStr);
+            if (!rangeDecoded.dimensions) {
+                continue;
+            }
+            const tl = rangeDecoded.tl;
+            const br = rangeDecoded.br;
+            if (decoded.row >= tl.row &&
+                decoded.row <= br.row &&
+                decoded.col >= tl.col &&
+                decoded.col <= br.col) {
+                return this.model[key];
+            }
+        }
+        return undefined;
+    }
+    remove(address) {
+        this.model[address] = undefined;
+    }
+}
+export { DataValidations };

package/dist/esm/modules/excel/defined-names.js

@@ -0,0 +1,214 @@
+import { colCache } from "@excel/utils/col-cache";
+import { CellMatrix } from "@excel/utils/cell-matrix";
+import { Range } from "@excel/range";
+const rangeRegexp = /[$](\w+)[$](\d+)(:[$](\w+)[$](\d+))?/;
+class DefinedNames {
+    constructor() {
+        this.matrixMap = {};
+    }
+    getMatrix(name) {
+        const matrix = this.matrixMap[name] || (this.matrixMap[name] = new CellMatrix());
+        return matrix;
+    }
+    // add a name to a cell. locStr in the form SheetName!$col$row or SheetName!$c1$r1:$c2:$r2
+    add(locStr, name) {
+        const location = colCache.decodeEx(locStr);
+        if ("error" in location) {
+            return; // Invalid reference, skip
+        }
+        this.addEx(location, name);
+    }
+    addEx(location, name) {
+        const matrix = this.getMatrix(name);
+        if ("top" in location) {
+            // It's a range (DecodedRange has top/left/bottom/right from Location)
+            for (let col = location.left; col <= location.right; col++) {
+                for (let row = location.top; row <= location.bottom; row++) {
+                    const address = {
+                        sheetName: location.sheetName,
+                        address: colCache.n2l(col) + row,
+                        row,
+                        col
+                    };
+                    matrix.addCellEx(address);
+                }
+            }
+        }
+        else {
+            // It's a single cell address
+            matrix.addCellEx(location);
+        }
+    }
+    remove(locStr, name) {
+        const location = colCache.decodeEx(locStr);
+        if ("error" in location) {
+            return; // Invalid reference, skip
+        }
+        this.removeEx(location, name);
+    }
+    removeEx(location, name) {
+        const matrix = this.getMatrix(name);
+        if ("top" in location) {
+            // Range - remove each cell
+            for (let col = location.left; col <= location.right; col++) {
+                for (let row = location.top; row <= location.bottom; row++) {
+                    matrix.removeCellEx({
+                        sheetName: location.sheetName,
+                        address: colCache.n2l(col) + row,
+                        row,
+                        col
+                    });
+                }
+            }
+        }
+        else {
+            matrix.removeCellEx(location);
+        }
+    }
+    removeAllNames(location) {
+        Object.values(this.matrixMap).forEach((matrix) => {
+            if ("top" in location) {
+                // Range - remove each cell
+                for (let col = location.left; col <= location.right; col++) {
+                    for (let row = location.top; row <= location.bottom; row++) {
+                        matrix.removeCellEx({
+                            sheetName: location.sheetName,
+                            address: colCache.n2l(col) + row,
+                            row,
+                            col
+                        });
+                    }
+                }
+            }
+            else {
+                matrix.removeCellEx(location);
+            }
+        });
+    }
+    forEach(callback) {
+        Object.entries(this.matrixMap).forEach(([name, matrix]) => {
+            matrix.forEach((cell) => {
+                callback(name, cell);
+            });
+        });
+    }
+    // get all the names of a cell
+    getNames(addressStr) {
+        const location = colCache.decodeEx(addressStr);
+        if ("error" in location || "top" in location) {
+            return []; // Invalid reference or range not supported
+        }
+        return this.getNamesEx(location);
+    }
+    getNamesEx(address) {
+        return Object.entries(this.matrixMap)
+            .map(([name, matrix]) => matrix.findCellEx(address, false) && name)
+            .filter((name) => Boolean(name));
+    }
+    _explore(matrix, cell) {
+        cell.mark = false;
+        const { sheetName } = cell;
+        const range = new Range(cell.row, cell.col, cell.row, cell.col, sheetName);
+        let x;
+        let y;
+        // Helper to get cell with proper type
+        const getCell = (row, col) => {
+            return matrix.findCellAt(sheetName, row, col);
+        };
+        // grow vertical - only one col to worry about
+        function vGrow(yy, edge) {
+            const c = getCell(yy, cell.col);
+            if (!c || !c.mark) {
+                return false;
+            }
+            range[edge] = yy;
+            c.mark = false;
+            return true;
+        }
+        for (y = cell.row - 1; vGrow(y, "top"); y--) { }
+        for (y = cell.row + 1; vGrow(y, "bottom"); y++) { }
+        // grow horizontal - ensure all rows can grow
+        function hGrow(xx, edge) {
+            const cells = [];
+            for (y = range.top; y <= range.bottom; y++) {
+                const c = getCell(y, xx);
+                if (c && c.mark) {
+                    cells.push(c);
+                }
+                else {
+                    return false;
+                }
+            }
+            range[edge] = xx;
+            for (let i = 0; i < cells.length; i++) {
+                cells[i].mark = false;
+            }
+            return true;
+        }
+        for (x = cell.col - 1; hGrow(x, "left"); x--) { }
+        for (x = cell.col + 1; hGrow(x, "right"); x++) { }
+        return range;
+    }
+    getRanges(name, matrix) {
+        matrix = matrix || this.matrixMap[name];
+        if (!matrix) {
+            return { name, ranges: [] };
+        }
+        // mark and sweep!
+        matrix.forEach((cell) => {
+            cell.mark = true;
+        });
+        const ranges = matrix
+            .map((cell) => cell.mark && this._explore(matrix, cell))
+            .filter(Boolean)
+            .map((range) => range.$shortRange);
+        return {
+            name,
+            ranges
+        };
+    }
+    normaliseMatrix(matrix, sheetName) {
+        // some of the cells might have shifted on specified sheet
+        // need to reassign rows, cols
+        matrix.forEachInSheet(sheetName, (cell, row, col) => {
+            if (cell) {
+                if (cell.row !== row || cell.col !== col) {
+                    cell.row = row;
+                    cell.col = col;
+                    cell.address = colCache.n2l(col) + row;
+                }
+            }
+        });
+    }
+    spliceRows(sheetName, start, numDelete, numInsert) {
+        Object.values(this.matrixMap).forEach((matrix) => {
+            matrix.spliceRows(sheetName, start, numDelete, numInsert);
+            this.normaliseMatrix(matrix, sheetName);
+        });
+    }
+    spliceColumns(sheetName, start, numDelete, numInsert) {
+        Object.values(this.matrixMap).forEach((matrix) => {
+            matrix.spliceColumns(sheetName, start, numDelete, numInsert);
+            this.normaliseMatrix(matrix, sheetName);
+        });
+    }
+    get model() {
+        // To get names per cell - just iterate over all names finding cells if they exist
+        return Object.entries(this.matrixMap)
+            .map(([name, matrix]) => this.getRanges(name, matrix))
+            .filter((definedName) => definedName.ranges.length);
+    }
+    set model(value) {
+        // value is [ { name, ranges }, ... ]
+        const matrixMap = (this.matrixMap = {});
+        value.forEach(definedName => {
+            const matrix = (matrixMap[definedName.name] = new CellMatrix());
+            definedName.ranges.forEach(rangeStr => {
+                if (rangeRegexp.test(rangeStr.split("!").pop() || "")) {
+                    matrix.addCell(rangeStr);
+                }
+            });
+        });
+    }
+}
+export { DefinedNames };

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

@@ -0,0 +1,60 @@
+import { colCache } from "@excel/utils/col-cache";
+import { Anchor } from "@excel/anchor";
+class Image {
+    constructor(worksheet, model) {
+        this.worksheet = worksheet;
+        if (model) {
+            this.model = model;
+        }
+    }
+    get model() {
+        switch (this.type) {
+            case "background":
+                return {
+                    type: this.type,
+                    imageId: this.imageId
+                };
+            case "image":
+                return {
+                    type: this.type,
+                    imageId: this.imageId,
+                    hyperlinks: this.range.hyperlinks,
+                    range: {
+                        tl: this.range.tl.model,
+                        br: this.range.br && this.range.br.model,
+                        ext: this.range.ext,
+                        editAs: this.range.editAs
+                    }
+                };
+            default:
+                throw new Error("Invalid Image Type");
+        }
+    }
+    set model({ type, imageId, range, hyperlinks }) {
+        this.type = type;
+        this.imageId = imageId;
+        if (type === "image") {
+            if (typeof range === "string") {
+                const decoded = colCache.decode(range);
+                if ("top" in decoded) {
+                    // It's a Location (range like "A1:C3")
+                    this.range = {
+                        tl: new Anchor(this.worksheet, { col: decoded.left, row: decoded.top }, -1),
+                        br: new Anchor(this.worksheet, { col: decoded.right, row: decoded.bottom }, 0),
+                        editAs: "oneCell"
+                    };
+                }
+            }
+            else if (range) {
+                this.range = {
+                    tl: new Anchor(this.worksheet, range.tl, 0),
+                    br: range.br ? new Anchor(this.worksheet, range.br, 0) : undefined,
+                    ext: range.ext,
+                    editAs: range.editAs,
+                    hyperlinks: hyperlinks || ("hyperlinks" in range ? range.hyperlinks : undefined)
+                };
+            }
+        }
+    }
+}
+export { Image };