@cj-tech-master/excelts 3.1.0 → 4.0.0

package/dist/esm/doc/column.js

@@ -1,351 +0,0 @@
-import { colCache } from "../utils/col-cache.js";
-import { isEqual } from "../utils/under-dash.js";
-import { Enums } from "./enums.js";
-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(worksheet, cols) {
-        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/doc/data-validations.js

@@ -1,43 +0,0 @@
-import { colCache } from "../utils/col-cache.js";
-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 large ranges)
-        // Only decode address if we have range keys to check
-        const keys = Object.keys(this.model);
-        const rangeKeys = keys.filter(k => k.startsWith("range:"));
-        if (rangeKeys.length === 0) {
-            return undefined;
-        }
-        const decoded = colCache.decodeAddress(address);
-        for (const key of rangeKeys) {
-            const rangeStr = key.slice(6); // Remove "range:" prefix
-            const rangeDecoded = colCache.decodeEx(rangeStr);
-            if (rangeDecoded.dimensions) {
-                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/doc/defined-names.js

@@ -1,214 +0,0 @@
-import { colCache } from "../utils/col-cache.js";
-import { CellMatrix } from "../utils/cell-matrix.js";
-import { Range } from "./range.js";
-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/doc/image.js

@@ -1,60 +0,0 @@
-import { colCache } from "../utils/col-cache.js";
-import { Anchor } from "./anchor.js";
-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 };

package/dist/esm/doc/modelcontainer.js

@@ -1,13 +0,0 @@
-import { XLSX } from "../xlsx/xlsx.js";
-class ModelContainer {
-    constructor(model) {
-        this.model = model;
-    }
-    get xlsx() {
-        if (!this._xlsx) {
-            this._xlsx = new XLSX(this);
-        }
-        return this._xlsx;
-    }
-}
-export { ModelContainer };