@cj-tech-master/excelts 0.1.0-canary.20251025023400.dff1908

package/dist/cjs/doc/column.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Column = void 0;
+const col_cache_js_1 = require("../utils/col-cache");
+const under_dash_js_1 = require("../utils/under-dash");
+const enums_js_1 = require("./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;
+    }
+    get letter() {
+        return col_cache_js_1.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 headers() {
+        return this._header && this._header instanceof Array ? this._header : [this._header];
+    }
+    get header() {
+        return this._header;
+    }
+    set header(value) {
+        if (value !== undefined) {
+            this._header = value;
+            this.headers.forEach((text, index) => {
+                this._worksheet.getCell(index + 1, this.number).value = text;
+            });
+        }
+        else {
+            this._header = undefined;
+        }
+    }
+    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);
+        }
+    }
+    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.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 &&
+            (0, under_dash_js_1.isEqual)(this.style, other.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(options, iteratee) {
+        const colNumber = this.number;
+        if (!iteratee) {
+            iteratee = options;
+            options = null;
+        }
+        this._worksheet.eachRow(options, (row, rowNumber) => {
+            iteratee(row.getCell(colNumber), rowNumber);
+        });
+    }
+    get values() {
+        const v = [];
+        this.eachCell((cell, rowNumber) => {
+            if (cell && cell.type !== enums_js_1.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;
+        });
+    }
+    // =========================================================================
+    // styles
+    _applyStyle(name, value) {
+        this.style[name] = value;
+        this.eachCell((cell) => {
+            cell[name] = value;
+        });
+        return value;
+    }
+    get numFmt() {
+        return this.style.numFmt;
+    }
+    set numFmt(value) {
+        this._applyStyle("numFmt", value);
+    }
+    get font() {
+        return this.style.font;
+    }
+    set font(value) {
+        this._applyStyle("font", value);
+    }
+    get alignment() {
+        return this.style.alignment;
+    }
+    set alignment(value) {
+        this._applyStyle("alignment", value);
+    }
+    get protection() {
+        return this.style.protection;
+    }
+    set protection(value) {
+        this._applyStyle("protection", value);
+    }
+    get border() {
+        return this.style.border;
+    }
+    set border(value) {
+        this._applyStyle("border", value);
+    }
+    get fill() {
+        return this.style.fill;
+    }
+    set fill(value) {
+        this._applyStyle("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.equivalentTo(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;
+    }
+}
+exports.Column = Column;

package/dist/cjs/doc/data-validations.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataValidations = void 0;
+class DataValidations {
+    constructor(model) {
+        this.model = model || {};
+    }
+    add(address, validation) {
+        return (this.model[address] = validation);
+    }
+    find(address) {
+        return this.model[address];
+    }
+    remove(address) {
+        this.model[address] = undefined;
+    }
+}
+exports.DataValidations = DataValidations;

package/dist/cjs/doc/defined-names.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefinedNames = void 0;
+const col_cache_js_1 = require("../utils/col-cache");
+const cell_matrix_js_1 = require("../utils/cell-matrix");
+const range_js_1 = require("./range");
+const rangeRegexp = /[$](\w+)[$](\d+)(:[$](\w+)[$](\d+))?/;
+class DefinedNames {
+    constructor() {
+        this.matrixMap = {};
+    }
+    getMatrix(name) {
+        const matrix = this.matrixMap[name] || (this.matrixMap[name] = new cell_matrix_js_1.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 = col_cache_js_1.colCache.decodeEx(locStr);
+        this.addEx(location, name);
+    }
+    addEx(location, name) {
+        const matrix = this.getMatrix(name);
+        if (location.top) {
+            for (let col = location.left; col <= location.right; col++) {
+                for (let row = location.top; row <= location.bottom; row++) {
+                    const address = {
+                        sheetName: location.sheetName,
+                        address: col_cache_js_1.colCache.n2l(col) + row,
+                        row,
+                        col
+                    };
+                    matrix.addCellEx(address);
+                }
+            }
+        }
+        else {
+            matrix.addCellEx(location);
+        }
+    }
+    remove(locStr, name) {
+        const location = col_cache_js_1.colCache.decodeEx(locStr);
+        this.removeEx(location, name);
+    }
+    removeEx(location, name) {
+        const matrix = this.getMatrix(name);
+        matrix.removeCellEx(location);
+    }
+    removeAllNames(location) {
+        Object.values(this.matrixMap).forEach((matrix) => {
+            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) {
+        return this.getNamesEx(col_cache_js_1.colCache.decodeEx(addressStr));
+    }
+    getNamesEx(address) {
+        return Object.entries(this.matrixMap)
+            .map(([name, matrix]) => matrix.findCellEx(address, false) && name)
+            .filter(Boolean);
+    }
+    _explore(matrix, cell) {
+        cell.mark = false;
+        const { sheetName } = cell;
+        const range = new range_js_1.Range(cell.row, cell.col, cell.row, cell.col, sheetName);
+        let x;
+        let y;
+        // grow vertical - only one col to worry about
+        function vGrow(yy, edge) {
+            const c = matrix.findCellAt(sheetName, 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 = matrix.findCellAt(sheetName, 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 = col_cache_js_1.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 cell_matrix_js_1.CellMatrix());
+            definedName.ranges.forEach(rangeStr => {
+                if (rangeRegexp.test(rangeStr.split("!").pop() || "")) {
+                    matrix.addCell(rangeStr);
+                }
+            });
+        });
+    }
+}
+exports.DefinedNames = DefinedNames;

package/dist/cjs/doc/enums.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Enums = exports.ErrorValue = exports.ReadingOrder = exports.DocumentType = exports.RelationshipType = exports.FormulaType = exports.ValueType = void 0;
+var ValueType;
+(function (ValueType) {
+    ValueType[ValueType["Null"] = 0] = "Null";
+    ValueType[ValueType["Merge"] = 1] = "Merge";
+    ValueType[ValueType["Number"] = 2] = "Number";
+    ValueType[ValueType["String"] = 3] = "String";
+    ValueType[ValueType["Date"] = 4] = "Date";
+    ValueType[ValueType["Hyperlink"] = 5] = "Hyperlink";
+    ValueType[ValueType["Formula"] = 6] = "Formula";
+    ValueType[ValueType["SharedString"] = 7] = "SharedString";
+    ValueType[ValueType["RichText"] = 8] = "RichText";
+    ValueType[ValueType["Boolean"] = 9] = "Boolean";
+    ValueType[ValueType["Error"] = 10] = "Error";
+    ValueType[ValueType["JSON"] = 11] = "JSON"; // Internal type for JSON values that serialize as String
+})(ValueType || (exports.ValueType = ValueType = {}));
+var FormulaType;
+(function (FormulaType) {
+    FormulaType[FormulaType["None"] = 0] = "None";
+    FormulaType[FormulaType["Master"] = 1] = "Master";
+    FormulaType[FormulaType["Shared"] = 2] = "Shared";
+})(FormulaType || (exports.FormulaType = FormulaType = {}));
+var RelationshipType;
+(function (RelationshipType) {
+    RelationshipType[RelationshipType["None"] = 0] = "None";
+    RelationshipType[RelationshipType["OfficeDocument"] = 1] = "OfficeDocument";
+    RelationshipType[RelationshipType["Worksheet"] = 2] = "Worksheet";
+    RelationshipType[RelationshipType["CalcChain"] = 3] = "CalcChain";
+    RelationshipType[RelationshipType["SharedStrings"] = 4] = "SharedStrings";
+    RelationshipType[RelationshipType["Styles"] = 5] = "Styles";
+    RelationshipType[RelationshipType["Theme"] = 6] = "Theme";
+    RelationshipType[RelationshipType["Hyperlink"] = 7] = "Hyperlink";
+})(RelationshipType || (exports.RelationshipType = RelationshipType = {}));
+var DocumentType;
+(function (DocumentType) {
+    DocumentType[DocumentType["Xlsx"] = 1] = "Xlsx";
+})(DocumentType || (exports.DocumentType = DocumentType = {}));
+var ReadingOrder;
+(function (ReadingOrder) {
+    ReadingOrder[ReadingOrder["LeftToRight"] = 1] = "LeftToRight";
+    ReadingOrder[ReadingOrder["RightToLeft"] = 2] = "RightToLeft";
+})(ReadingOrder || (exports.ReadingOrder = ReadingOrder = {}));
+exports.ErrorValue = {
+    NotApplicable: "#N/A",
+    Ref: "#REF!",
+    Name: "#NAME?",
+    DivZero: "#DIV/0!",
+    Null: "#NULL!",
+    Value: "#VALUE!",
+    Num: "#NUM!"
+};
+exports.Enums = {
+    ValueType,
+    FormulaType,
+    RelationshipType,
+    DocumentType,
+    ReadingOrder,
+    ErrorValue: exports.ErrorValue
+};

package/dist/cjs/doc/image.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Image = void 0;
+const col_cache_js_1 = require("../utils/col-cache");
+const anchor_js_1 = require("./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 = col_cache_js_1.colCache.decode(range);
+                this.range = {
+                    tl: new anchor_js_1.Anchor(this.worksheet, { col: decoded.left, row: decoded.top }, -1),
+                    br: new anchor_js_1.Anchor(this.worksheet, { col: decoded.right, row: decoded.bottom }, 0),
+                    editAs: "oneCell"
+                };
+            }
+            else {
+                this.range = {
+                    tl: new anchor_js_1.Anchor(this.worksheet, range.tl, 0),
+                    br: range.br && new anchor_js_1.Anchor(this.worksheet, range.br, 0),
+                    ext: range.ext,
+                    editAs: range.editAs,
+                    hyperlinks: hyperlinks || range.hyperlinks
+                };
+            }
+        }
+    }
+}
+exports.Image = Image;

package/dist/cjs/doc/modelcontainer.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelContainer = void 0;
+const xlsx_js_1 = require("../xlsx/xlsx");
+class ModelContainer {
+    constructor(model) {
+        this.model = model;
+    }
+    get xlsx() {
+        if (!this._xlsx) {
+            this._xlsx = new xlsx_js_1.XLSX(this);
+        }
+        return this._xlsx;
+    }
+}
+exports.ModelContainer = ModelContainer;

package/dist/cjs/doc/note.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Note = void 0;
+const under_dash_js_1 = require("../utils/under-dash");
+class Note {
+    constructor(note) {
+        this.note = note;
+    }
+    get model() {
+        let value = null;
+        switch (typeof this.note) {
+            case "string":
+                value = {
+                    type: "note",
+                    note: {
+                        texts: [
+                            {
+                                text: this.note
+                            }
+                        ]
+                    }
+                };
+                break;
+            default:
+                value = {
+                    type: "note",
+                    note: this.note
+                };
+                break;
+        }
+        // Suitable for all cell comments
+        return (0, under_dash_js_1.deepMerge)({}, Note.DEFAULT_CONFIGS, value);
+    }
+    set model(value) {
+        const { note } = value;
+        const { texts } = note;
+        if (texts && texts.length === 1 && Object.keys(texts[0]).length === 1) {
+            this.note = texts[0].text;
+        }
+        else {
+            this.note = note;
+        }
+    }
+    static fromModel(model) {
+        const note = new Note();
+        note.model = model;
+        return note;
+    }
+}
+exports.Note = Note;
+Note.DEFAULT_CONFIGS = {
+    note: {
+        margins: {
+            insetmode: "auto",
+            inset: [0.13, 0.13, 0.25, 0.25]
+        },
+        protection: {
+            locked: "True",
+            lockText: "True"
+        },
+        editAs: "absolute"
+    },
+    type: "note"
+};