@cj-tech-master/excelts 1.4.4 → 1.4.5-canary.20251212053535.13d32d8

package/dist/cjs/doc/row.js

@@ -83,12 +83,12 @@ class Row {
                     cDst = this.getCell(i);
                     cDst.value = cSrc.value;
                     cDst.style = cSrc.style;
-                    cDst._comment = cSrc._comment;
+                    cDst.comment = cSrc.comment;
                 }
                 else if (cDst) {
                     cDst.value = null;
                     cDst.style = {};
-                    cDst._comment = undefined;
+                    cDst.comment = undefined;
                 }
             }
         }
@@ -100,7 +100,7 @@ class Row {
                     cDst = this.getCell(i + nExpand);
                     cDst.value = cSrc.value;
                     cDst.style = cSrc.style;
-                    cDst._comment = cSrc._comment;
+                    cDst.comment = cSrc.comment;
                 }
                 else {
                     this._cells[i + nExpand - 1] = undefined;
@@ -112,13 +112,18 @@ class Row {
             cDst = this.getCell(start + i);
             cDst.value = inserts[i];
             cDst.style = {};
-            cDst._comment = undefined;
+            cDst.comment = undefined;
         }
     }
-    eachCell(options, iteratee) {
-        if (!iteratee) {
-            iteratee = options;
-            options = null;
+    eachCell(optionsOrIteratee, maybeIteratee) {
+        let options = null;
+        let iteratee;
+        if (typeof optionsOrIteratee === "function") {
+            iteratee = optionsOrIteratee;
+        }
+        else {
+            options = optionsOrIteratee;
+            iteratee = maybeIteratee;
         }
         if (options && options.includeEmpty) {
             const n = this._cells.length;
@@ -198,7 +203,7 @@ class Row {
     }
     // returns true if the row includes at least one cell with a value
     get hasValues() {
-        return this._cells.some((cell) => cell && cell.type !== enums_js_1.Enums.ValueType.Null);
+        return this._cells.some(cell => cell && cell.type !== enums_js_1.Enums.ValueType.Null);
     }
     get cellCount() {
         return this._cells.length;
@@ -237,46 +242,57 @@ class Row {
         this.style[name] = value;
         this._cells.forEach(cell => {
             if (cell) {
-                cell[name] = value;
+                cell.style[name] = value;
             }
         });
-        return value;
     }
     get numFmt() {
         return this.style.numFmt;
     }
     set numFmt(value) {
-        this._applyStyle("numFmt", value);
+        if (value !== undefined) {
+            this._applyStyle("numFmt", value);
+        }
     }
     get font() {
         return this.style.font;
     }
     set font(value) {
-        this._applyStyle("font", value);
+        if (value !== undefined) {
+            this._applyStyle("font", value);
+        }
     }
     get alignment() {
         return this.style.alignment;
     }
     set alignment(value) {
-        this._applyStyle("alignment", value);
+        if (value !== undefined) {
+            this._applyStyle("alignment", value);
+        }
     }
     get protection() {
         return this.style.protection;
     }
     set protection(value) {
-        this._applyStyle("protection", value);
+        if (value !== undefined) {
+            this._applyStyle("protection", value);
+        }
     }
     get border() {
         return this.style.border;
     }
     set border(value) {
-        this._applyStyle("border", value);
+        if (value !== undefined) {
+            this._applyStyle("border", value);
+        }
     }
     get fill() {
         return this.style.fill;
     }
     set fill(value) {
-        this._applyStyle("fill", value);
+        if (value !== undefined) {
+            this._applyStyle("fill", value);
+        }
     }
     get hidden() {
         return !!this._hidden;

package/dist/cjs/doc/table.js

@@ -157,9 +157,7 @@ class Table {
         // the sheet...
         const assignStyle = (cell, style) => {
             if (style) {
-                Object.keys(style).forEach(key => {
-                    cell.style[key] = style[key];
-                });
+                Object.assign(cell.style, style);
             }
         };
         const { worksheet, table } = this;
@@ -377,10 +375,10 @@ class Table {
         this._assign(this.table, "totalsRow", value);
     }
     get theme() {
-        return this.table.style.name;
+        return this.table.style.theme;
     }
     set theme(value) {
-        this.table.style.name = value;
+        this.table.style.theme = value;
     }
     get showFirstColumn() {
         return this.table.style.showFirstColumn;

package/dist/cjs/doc/workbook.js

@@ -53,12 +53,13 @@ class Workbook {
     addWorksheet(name, options) {
         const id = this.nextId;
         const lastOrderNo = this._worksheets.reduce((acc, ws) => ((ws && ws.orderNo) > acc ? ws.orderNo : acc), 0);
-        const worksheetOptions = Object.assign({}, options, {
+        const worksheetOptions = {
+            ...options,
             id,
             name,
             orderNo: lastOrderNo + 1,
             workbook: this
-        });
+        };
         const worksheet = new worksheet_js_1.Worksheet(worksheetOptions);
         this._worksheets[id] = worksheet;
         return worksheet;
@@ -106,11 +107,11 @@ class Workbook {
     addImage(image) {
         // TODO:  validation?
         const id = this.media.length;
-        this.media.push(Object.assign({}, image, { type: "image" }));
+        this.media.push({ ...image, type: "image" });
         return id;
     }
     getImage(id) {
-        return this.media[id];
+        return this.media[Number(id)];
     }
     get model() {
         return {

package/dist/cjs/doc/worksheet.js

@@ -128,7 +128,7 @@ class Worksheet {
             }
             name = name.substring(0, 31);
         }
-        if (this._workbook._worksheets.find((ws) => ws && ws.name.toLowerCase() === name.toLowerCase())) {
+        if (this._workbook.worksheets.find(ws => ws && ws.name.toLowerCase() === name.toLowerCase())) {
             throw new Error(`Worksheet name already exists: ${name}`);
         }
         this._name = name;
@@ -164,7 +164,7 @@ class Worksheet {
     set columns(value) {
         // calculate max header row count
         this._headerRowCount = value.reduce((pv, cv) => {
-            const headerCount = (cv.header && 1) || (cv.headers && cv.headers.length) || 0;
+            const headerCount = Array.isArray(cv.header) ? cv.header.length : cv.header ? 1 : 0;
             return Math.max(pv, headerCount);
         }, 0);
         // construct Column objects
@@ -220,12 +220,9 @@ class Worksheet {
         if (inserts.length > 0) {
             // must iterate over all rows whether they exist yet or not
             for (let i = 0; i < nRows; i++) {
-                const rowArguments = [start, count];
-                inserts.forEach(insert => {
-                    rowArguments.push(insert[i] || null);
-                });
+                const insertValues = inserts.map(insert => insert[i] || null);
                 const row = this.getRow(i + 1);
-                row.splice(...rowArguments);
+                row.splice(start, count, ...insertValues);
             }
         }
         else {
@@ -251,7 +248,7 @@ class Worksheet {
             }
         }
         for (let i = start; i < start + inserts.length; i++) {
-            this.getColumn(i).defn = null;
+            this.getColumn(i).defn = undefined;
         }
         // account for defined names
         this.workbook.definedNames.spliceColumns(this.name, start, count, inserts.length);
@@ -261,7 +258,7 @@ class Worksheet {
     }
     get columnCount() {
         let maxCount = 0;
-        this.eachRow((row) => {
+        this.eachRow(row => {
             maxCount = Math.max(maxCount, row.cellCount);
         });
         return maxCount;
@@ -270,7 +267,7 @@ class Worksheet {
         // performance nightmare - for each row, counts all the columns used
         const counts = [];
         let count = 0;
-        this.eachRow((row) => {
+        this.eachRow(row => {
             row.eachCell(({ col }) => {
                 if (!counts[col]) {
                     counts[col] = true;
@@ -451,10 +448,10 @@ class Worksheet {
                     rSrc.eachCell({ includeEmpty: true }, (cell, colNumber) => {
                         rDst.getCell(colNumber).style = cell.style;
                         // remerge cells accounting for insert offset
-                        if (cell._value.constructor.name === "MergeValue") {
-                            const cellToBeMerged = this.getRow(cell._row._number + nInserts).getCell(colNumber);
-                            const prevMaster = cell._value._master;
-                            const newMaster = this.getRow(prevMaster._row._number + nInserts).getCell(prevMaster._column._number);
+                        if (cell.type === enums_js_1.Enums.ValueType.Merge) {
+                            const cellToBeMerged = this.getRow(cell.row + nInserts).getCell(colNumber);
+                            const prevMaster = cell.master;
+                            const newMaster = this.getRow(prevMaster.row + nInserts).getCell(prevMaster.col);
                             cellToBeMerged.merge(newMaster);
                         }
                     });
@@ -473,10 +470,15 @@ class Worksheet {
         // account for defined names
         this.workbook.definedNames.spliceRows(this.name, start, count, nInserts);
     }
-    eachRow(options, iteratee) {
-        if (!iteratee) {
-            iteratee = options;
-            options = undefined;
+    eachRow(optionsOrIteratee, maybeIteratee) {
+        let options;
+        let iteratee;
+        if (typeof optionsOrIteratee === "function") {
+            iteratee = optionsOrIteratee;
+        }
+        else {
+            options = optionsOrIteratee;
+            iteratee = maybeIteratee;
         }
         if (options && options.includeEmpty) {
             const n = this._rows.length;
@@ -614,12 +616,14 @@ class Worksheet {
         for (let r = top; r <= bottom; r++) {
             for (let c = left; c <= right; c++) {
                 if (first) {
-                    this.getCell(r, c).value = {
+                    const cell = this.getCell(r, c);
+                    const formulaValue = {
                         shareType,
                         formula,
                         ref: range,
                         result: getResult(r, c)
                     };
+                    cell.value = formulaValue;
                     first = false;
                 }
                 else {
@@ -755,7 +759,7 @@ Please leave feedback at https://github.com/excelts/excelts/discussions/2575`);
         };
         // =================================================
         // columns
-        model.cols = column_js_1.Column.toModel(this.columns);
+        model.cols = column_js_1.Column.toModel(this.columns || []);
         // ==========================================================
         // Rows
         const rows = (model.rows = []);

package/dist/cjs/utils/sheet-utils.js

@@ -132,7 +132,9 @@ function formatValue(value, fmt, dateFormat) {
  */
 function getCellDisplayText(cell, dateFormat) {
     const value = cell.value;
-    const fmt = cell.numFmt || "General";
+    const numFmt = cell.numFmt;
+    // Extract format code string from numFmt (which can be string or NumFmt object)
+    const fmt = typeof numFmt === "string" ? numFmt : (numFmt?.formatCode ?? "General");
     // Null/undefined
     if (value == null) {
         return "";

package/dist/esm/doc/anchor.js

@@ -1,4 +1,14 @@
 import { colCache } from "../utils/col-cache.js";
+function isAnchorModel(value) {
+    return (typeof value === "object" &&
+        "nativeCol" in value &&
+        "nativeRow" in value &&
+        "nativeColOff" in value &&
+        "nativeRowOff" in value);
+}
+function isSimpleAddress(value) {
+    return typeof value === "object" && "col" in value && "row" in value;
+}
 class Anchor {
     constructor(worksheet, address, offset = 0) {
         this.worksheet = worksheet;
@@ -15,17 +25,15 @@ class Anchor {
             this.nativeRow = decoded.row + offset;
             this.nativeRowOff = 0;
         }
-        else if (address.nativeCol !== undefined) {
-            const anchor = address;
-            this.nativeCol = anchor.nativeCol || 0;
-            this.nativeColOff = anchor.nativeColOff || 0;
-            this.nativeRow = anchor.nativeRow || 0;
-            this.nativeRowOff = anchor.nativeRowOff || 0;
+        else if (isAnchorModel(address)) {
+            this.nativeCol = address.nativeCol || 0;
+            this.nativeColOff = address.nativeColOff || 0;
+            this.nativeRow = address.nativeRow || 0;
+            this.nativeRowOff = address.nativeRowOff || 0;
         }
-        else if (address.col !== undefined) {
-            const simple = address;
-            this.col = simple.col + offset;
-            this.row = simple.row + offset;
+        else if (isSimpleAddress(address)) {
+            this.col = address.col + offset;
+            this.row = address.row + offset;
         }
         else {
             this.nativeCol = 0;
@@ -35,7 +43,13 @@ class Anchor {
         }
     }
     static asInstance(model) {
-        return model instanceof Anchor || model == null ? model : new Anchor(undefined, model);
+        if (model == null) {
+            return null;
+        }
+        if (model instanceof Anchor) {
+            return model;
+        }
+        return new Anchor(undefined, model);
     }
     get col() {
         return this.nativeCol + Math.min(this.colWidth - 1, this.nativeColOff) / this.colWidth;

package/dist/esm/doc/cell.js

@@ -184,11 +184,30 @@ class Cell {
         this._value = Value.create(Value.getType(v), this, v);
     }
     get note() {
-        return this._comment && this._comment.note;
+        if (!this._comment) {
+            return undefined;
+        }
+        const noteValue = this._comment.note;
+        return noteValue;
     }
     set note(note) {
         this._comment = new Note(note);
     }
+    // Internal comment accessor for row operations
+    get comment() {
+        return this._comment;
+    }
+    set comment(comment) {
+        if (comment === undefined) {
+            this._comment = undefined;
+        }
+        else if (comment instanceof Note) {
+            this._comment = comment;
+        }
+        else {
+            this._comment = new Note(comment);
+        }
+    }
     get text() {
         return this._value.toString();
     }
@@ -202,7 +221,7 @@ class Cell {
         // if this cell is a string, turn it into a Hyperlink
         if (this.type === Cell.Types.String) {
             this._value = Value.create(Cell.Types.Hyperlink, this, {
-                text: this._value.value,
+                text: String(this._value.value),
                 hyperlink
             });
         }
@@ -295,8 +314,6 @@ class Cell {
     }
 }
 Cell.Types = Enums.ValueType;
-// =============================================================================
-// Internal Value Types
 class NullValue {
     constructor(cell) {
         this.model = {
@@ -413,7 +430,7 @@ class RichTextValue {
         this.model.value = value;
     }
     toString() {
-        return this.model.value.richText.map((t) => t.text).join("");
+        return this.model.value.richText.map(t => t.text).join("");
     }
     get type() {
         return Cell.Types.RichText;
@@ -482,14 +499,11 @@ class HyperlinkValue {
         }
     }
     get value() {
-        const v = {
-            text: this.model.text,
-            hyperlink: this.model.hyperlink
+        return {
+            text: this.model.text || "",
+            hyperlink: this.model.hyperlink || "",
+            tooltip: this.model.tooltip
         };
-        if (this.model.tooltip) {
-            v.tooltip = this.model.tooltip;
-        }
-        return v;
     }
     set value(value) {
         this.model.text = value.text;
@@ -600,24 +614,42 @@ class FormulaValue {
     }
     _copyModel(model) {
         const copy = {};
-        const cp = (name) => {
-            const value = model[name];
-            if (value) {
-                copy[name] = value;
-            }
-        };
-        cp("formula");
-        cp("result");
-        cp("ref");
-        cp("shareType");
-        cp("sharedFormula");
+        if (model.formula) {
+            copy.formula = model.formula;
+        }
+        if (model.result !== undefined) {
+            copy.result = model.result;
+        }
+        if (model.ref) {
+            copy.ref = model.ref;
+        }
+        if (model.shareType) {
+            copy.shareType = model.shareType;
+        }
+        if (model.sharedFormula) {
+            copy.sharedFormula = model.sharedFormula;
+        }
         return copy;
     }
     get value() {
         return this._copyModel(this.model);
     }
     set value(value) {
-        this.model = this._copyModel(value);
+        if (value.formula) {
+            this.model.formula = value.formula;
+        }
+        if (value.result !== undefined) {
+            this.model.result = value.result;
+        }
+        if (value.ref) {
+            this.model.ref = value.ref;
+        }
+        if (value.shareType) {
+            this.model.shareType = value.shareType;
+        }
+        if (value.sharedFormula) {
+            this.model.sharedFormula = value.sharedFormula;
+        }
     }
     validate(value) {
         switch (Value.getType(value)) {
@@ -681,11 +713,8 @@ class FormulaValue {
         if (v instanceof Date) {
             return Enums.ValueType.Date;
         }
-        if (v.text && v.hyperlink) {
-            return Enums.ValueType.Hyperlink;
-        }
-        if (v.formula) {
-            return Enums.ValueType.Formula;
+        if (typeof v === "object" && "error" in v) {
+            return Enums.ValueType.Error;
         }
         return Enums.ValueType.Null;
     }
@@ -868,20 +897,23 @@ const Value = {
         if (value instanceof Date) {
             return Cell.Types.Date;
         }
-        if (value.text && value.hyperlink) {
-            return Cell.Types.Hyperlink;
-        }
-        if (value.formula || value.sharedFormula) {
-            return Cell.Types.Formula;
-        }
-        if (value.richText) {
-            return Cell.Types.RichText;
-        }
-        if (value.sharedString) {
-            return Cell.Types.SharedString;
-        }
-        if (value.error) {
-            return Cell.Types.Error;
+        if (typeof value === "object") {
+            if ("text" in value && value.text && "hyperlink" in value && value.hyperlink) {
+                return Cell.Types.Hyperlink;
+            }
+            if (("formula" in value && value.formula) ||
+                ("sharedFormula" in value && value.sharedFormula)) {
+                return Cell.Types.Formula;
+            }
+            if ("richText" in value && value.richText) {
+                return Cell.Types.RichText;
+            }
+            if ("sharedString" in value && value.sharedString) {
+                return Cell.Types.SharedString;
+            }
+            if ("error" in value && value.error) {
+                return Cell.Types.Error;
+            }
         }
         return Cell.Types.JSON;
     },

package/dist/esm/doc/column.js

@@ -60,7 +60,13 @@ class Column {
         }
     }
     get headers() {
-        return this._header && this._header instanceof Array ? this._header : [this._header];
+        if (Array.isArray(this._header)) {
+            return this._header;
+        }
+        if (this._header !== undefined) {
+            return [this._header];
+        }
+        return [];
     }
     get header() {
         return this._header;
@@ -117,6 +123,12 @@ class Column {
             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;
@@ -140,7 +152,7 @@ class Column {
         const colNumber = this.number;
         if (!iteratee) {
             iteratee = options;
-            options = null;
+            options = {};
         }
         this._worksheet.eachRow(options, (row, rowNumber) => {
             iteratee(row.getCell(colNumber), rowNumber);
@@ -171,48 +183,59 @@ class Column {
     }
     // =========================================================================
     // 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);
+        this.style.numFmt = value;
+        this.eachCell(cell => {
+            cell.numFmt = value;
+        });
     }
     get font() {
         return this.style.font;
     }
     set font(value) {
-        this._applyStyle("font", value);
+        this.style.font = value;
+        this.eachCell(cell => {
+            cell.font = value;
+        });
     }
     get alignment() {
         return this.style.alignment;
     }
     set alignment(value) {
-        this._applyStyle("alignment", value);
+        this.style.alignment = value;
+        this.eachCell(cell => {
+            cell.alignment = value;
+        });
     }
     get protection() {
         return this.style.protection;
     }
     set protection(value) {
-        this._applyStyle("protection", value);
+        this.style.protection = value;
+        this.eachCell(cell => {
+            cell.protection = value;
+        });
     }
     get border() {
         return this.style.border;
     }
     set border(value) {
-        this._applyStyle("border", value);
+        this.style.border = value;
+        this.eachCell(cell => {
+            cell.border = value;
+        });
     }
     get fill() {
         return this.style.fill;
     }
     set fill(value) {
-        this._applyStyle("fill", value);
+        this.style.fill = value;
+        this.eachCell(cell => {
+            cell.fill = value;
+        });
     }
     // =============================================================================
     // static functions
@@ -227,7 +250,7 @@ class Column {
                         col = null;
                     }
                 }
-                else if (!col || !column.equivalentTo(col)) {
+                else if (!col || !column.equivalentToModel(col)) {
                     col = {
                         min: index + 1,
                         max: index + 1,