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

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,

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)
                 };
             }
         }

package/dist/esm/doc/range.js

@@ -2,11 +2,17 @@ import { colCache } from "../utils/col-cache.js";
 // used by worksheet to calculate sheet dimensions
 class Range {
     constructor(...args) {
+        this.model = {
+            top: 0,
+            left: 0,
+            bottom: 0,
+            right: 0
+        };
         this.decode(args);
     }
     setTLBR(t, l, b, r, s) {
-        if (arguments.length < 4) {
-            // setTLBR(tl, br, s)
+        if (typeof t === "string" && typeof l === "string") {
+            // setTLBR(tl, br, s) - t and l are address strings
             const tl = colCache.decodeAddress(t);
             const br = colCache.decodeAddress(l);
             this.model = {
@@ -14,12 +20,14 @@ class Range {
                 left: Math.min(tl.col, br.col),
                 bottom: Math.max(tl.row, br.row),
                 right: Math.max(tl.col, br.col),
-                sheetName: b
+                sheetName: typeof b === "string" ? b : undefined
             };
-            this.setTLBR(tl.row, tl.col, br.row, br.col, s);
         }
-        else {
-            // setTLBR(t, l, b, r, s)
+        else if (typeof t === "number" &&
+            typeof l === "number" &&
+            typeof b === "number" &&
+            typeof r === "number") {
+            // setTLBR(t, l, b, r, s) - all numbers
             this.model = {
                 top: Math.min(t, b),
                 left: Math.min(l, r),
@@ -32,16 +40,33 @@ class Range {
     decode(argv) {
         switch (argv.length) {
             case 5: // [t,l,b,r,s]
-                this.setTLBR(argv[0], argv[1], argv[2], argv[3], argv[4]);
+                if (typeof argv[0] === "number" &&
+                    typeof argv[1] === "number" &&
+                    typeof argv[2] === "number" &&
+                    typeof argv[3] === "number" &&
+                    typeof argv[4] === "string") {
+                    this.setTLBR(argv[0], argv[1], argv[2], argv[3], argv[4]);
+                }
                 break;
             case 4: // [t,l,b,r]
-                this.setTLBR(argv[0], argv[1], argv[2], argv[3]);
+                if (typeof argv[0] === "number" &&
+                    typeof argv[1] === "number" &&
+                    typeof argv[2] === "number" &&
+                    typeof argv[3] === "number") {
+                    this.setTLBR(argv[0], argv[1], argv[2], argv[3]);
+                }
                 break;
             case 3: // [tl,br,s]
-                this.setTLBR(argv[0], argv[1], argv[2]);
+                if (typeof argv[0] === "string" &&
+                    typeof argv[1] === "string" &&
+                    typeof argv[2] === "string") {
+                    this.setTLBR(argv[0], argv[1], argv[2]);
+                }
                 break;
             case 2: // [tl,br]
-                this.setTLBR(argv[0], argv[1]);
+                if (typeof argv[0] === "string" && typeof argv[1] === "string") {
+                    this.setTLBR(argv[0], argv[1]);
+                }
                 break;
             case 1: {
                 const value = argv[0];
@@ -55,11 +80,15 @@ class Range {
                         sheetName: value.sheetName
                     };
                 }
-                else if (value instanceof Array) {
+                else if (Array.isArray(value)) {
                     // an arguments array
                     this.decode(value);
                 }
-                else if (value.top && value.left && value.bottom && value.right) {
+                else if (typeof value === "object" &&
+                    "top" in value &&
+                    "left" in value &&
+                    "bottom" in value &&
+                    "right" in value) {
                     // a model
                     this.model = {
                         top: value.top,
@@ -69,25 +98,27 @@ class Range {
                         sheetName: value.sheetName
                     };
                 }
-                else {
+                else if (typeof value === "string") {
                     // [sheetName!]tl:br
-                    const tlbr = colCache.decodeEx(value);
-                    if (tlbr.top) {
+                    const decoded = colCache.decodeEx(value);
+                    if ("top" in decoded) {
+                        // It's a DecodedRange
                         this.model = {
-                            top: tlbr.top,
-                            left: tlbr.left,
-                            bottom: tlbr.bottom,
-                            right: tlbr.right,
-                            sheetName: tlbr.sheetName
+                            top: decoded.top,
+                            left: decoded.left,
+                            bottom: decoded.bottom,
+                            right: decoded.right,
+                            sheetName: decoded.sheetName
                         };
                     }
-                    else {
+                    else if ("row" in decoded) {
+                        // It's an Address
                         this.model = {
-                            top: tlbr.row,
-                            left: tlbr.col,
-                            bottom: tlbr.row,
-                            right: tlbr.col,
-                            sheetName: tlbr.sheetName
+                            top: decoded.row,
+                            left: decoded.col,
+                            bottom: decoded.row,
+                            right: decoded.col,
+                            sheetName: decoded.sheetName
                         };
                     }
                 }
@@ -169,7 +200,9 @@ class Range {
     }
     expandToAddress(addressStr) {
         const address = colCache.decodeEx(addressStr);
-        this.expand(address.row, address.col, address.row, address.col);
+        if ("row" in address && "col" in address) {
+            this.expand(address.row, address.col, address.row, address.col);
+        }
     }
     get tl() {
         return colCache.n2l(this.left) + this.top;
@@ -221,7 +254,10 @@ class Range {
     }
     contains(addressStr) {
         const address = colCache.decodeEx(addressStr);
-        return this.containsEx(address);
+        if ("row" in address && "col" in address) {
+            return this.containsEx(address);
+        }
+        return false;
     }
     containsEx(address) {
         if (address.sheetName && this.sheetName && address.sheetName !== this.sheetName) {