@cj-tech-master/excelts 1.4.5 → 1.5.0

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

@@ -2,9 +2,11 @@ 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
+/**
+ * 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;
@@ -20,6 +22,9 @@ class Column {
     get worksheet() {
         return this._worksheet;
     }
+    /**
+     * Column letter key
+     */
     get letter() {
         return colCache.n2l(this._number);
     }
@@ -60,8 +65,17 @@ 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 [];
     }
+    /**
+     * Can be a string to set one row high header or an array to set multi-row high header
+     */
     get header() {
         return this._header;
     }
@@ -76,6 +90,9 @@ class Column {
             this._header = undefined;
         }
     }
+    /**
+     * The name of the properties associated with this column in each row
+     */
     get key() {
         return this._key;
     }
@@ -89,18 +106,27 @@ class Column {
             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);
     }
@@ -117,6 +143,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;
@@ -136,16 +168,25 @@ class Column {
     get headerCount() {
         return this.headers.length;
     }
-    eachCell(options, iteratee) {
+    eachCell(optionsOrCallback, maybeCallback) {
         const colNumber = this.number;
-        if (!iteratee) {
-            iteratee = options;
+        let options;
+        let callback;
+        if (typeof optionsOrCallback === "function") {
             options = {};
+            callback = optionsOrCallback;
+        }
+        else {
+            options = optionsOrCallback;
+            callback = maybeCallback;
         }
         this._worksheet.eachRow(options, (row, rowNumber) => {
-            iteratee(row.getCell(colNumber), rowNumber);
+            callback(row.getCell(colNumber), rowNumber);
         });
     }
+    /**
+     * The cell values in the column
+     */
     get values() {
         const v = [];
         this.eachCell((cell, rowNumber) => {
@@ -171,48 +212,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 +279,7 @@ class Column {
                         col = null;
                     }
                 }
-                else if (!col || !column.equivalentTo(col)) {
+                else if (!col || !column.equivalentToModel(col)) {
                     col = {
                         min: index + 1,
                         max: index + 1,

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

@@ -13,11 +13,15 @@ class DefinedNames {
     // 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 (location.top) {
+        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 = {
@@ -31,20 +35,54 @@ class DefinedNames {
             }
         }
         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);
-        matrix.removeCellEx(location);
+        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) => {
-            matrix.removeCellEx(location);
+            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) {
@@ -56,12 +94,16 @@ class DefinedNames {
     }
     // get all the names of a cell
     getNames(addressStr) {
-        return this.getNamesEx(colCache.decodeEx(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(Boolean);
+            .filter((name) => Boolean(name));
     }
     _explore(matrix, cell) {
         cell.mark = false;
@@ -69,9 +111,13 @@ class DefinedNames {
         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 = matrix.findCellAt(sheetName, yy, cell.col);
+            const c = getCell(yy, cell.col);
             if (!c || !c.mark) {
                 return false;
             }
@@ -85,7 +131,7 @@ class DefinedNames {
         function hGrow(xx, edge) {
             const cells = [];
             for (y = range.top; y <= range.bottom; y++) {
-                const c = matrix.findCellAt(sheetName, y, xx);
+                const c = getCell(y, xx);
                 if (c && c.mark) {
                     cells.push(c);
                 }

package/dist/esm/doc/image.js

@@ -36,19 +36,22 @@ class Image {
         if (type === "image") {
             if (typeof range === "string") {
                 const decoded = colCache.decode(range);
-                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"
-                };
+                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 {
+            else if (range) {
                 this.range = {
                     tl: new Anchor(this.worksheet, range.tl, 0),
-                    br: range.br && new Anchor(this.worksheet, range.br, 0),
+                    br: range.br ? new Anchor(this.worksheet, range.br, 0) : undefined,
                     ext: range.ext,
                     editAs: range.editAs,
-                    hyperlinks: hyperlinks || range.hyperlinks
+                    hyperlinks: hyperlinks || ("hyperlinks" in range ? range.hyperlinks : undefined)
                 };
             }
         }