@cj-tech-master/excelts 1.4.4 → 1.4.5-canary.20251212064440.3eb099f

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) {

package/dist/esm/doc/row.js

@@ -80,12 +80,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;
                 }
             }
         }
@@ -97,7 +97,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;
@@ -109,13 +109,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;
@@ -195,7 +200,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.ValueType.Null);
+        return this._cells.some(cell => cell && cell.type !== Enums.ValueType.Null);
     }
     get cellCount() {
         return this._cells.length;
@@ -234,46 +239,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/esm/doc/table.js

@@ -154,9 +154,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;
@@ -374,10 +372,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/esm/doc/workbook.js

@@ -50,12 +50,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(worksheetOptions);
         this._worksheets[id] = worksheet;
         return worksheet;
@@ -103,11 +104,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/esm/doc/worksheet.js

@@ -125,7 +125,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;
@@ -161,7 +161,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
@@ -217,12 +217,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 {
@@ -248,7 +245,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);
@@ -258,7 +255,7 @@ class Worksheet {
     }
     get columnCount() {
         let maxCount = 0;
-        this.eachRow((row) => {
+        this.eachRow(row => {
             maxCount = Math.max(maxCount, row.cellCount);
         });
         return maxCount;
@@ -267,7 +264,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;
@@ -448,10 +445,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.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);
                         }
                     });
@@ -611,12 +608,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 {
@@ -752,7 +751,7 @@ Please leave feedback at https://github.com/excelts/excelts/discussions/2575`);
         };
         // =================================================
         // columns
-        model.cols = Column.toModel(this.columns);
+        model.cols = Column.toModel(this.columns || []);
         // ==========================================================
         // Rows
         const rows = (model.rows = []);

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

@@ -112,7 +112,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/types/doc/anchor.d.ts

@@ -1,26 +1,33 @@
 import type { Worksheet } from "./worksheet.js";
+interface AnchorModel {
+    nativeCol: number;
+    nativeRow: number;
+    nativeColOff: number;
+    nativeRowOff: number;
+}
 interface SimpleAddress {
-    col?: number;
-    row?: number;
+    col: number;
+    row: number;
 }
-type AddressInput = string | Anchor | SimpleAddress | null | undefined;
+type AddressInput = string | AnchorModel | SimpleAddress;
 declare class Anchor {
     nativeCol: number;
     nativeRow: number;
     nativeColOff: number;
     nativeRowOff: number;
     worksheet?: Worksheet;
-    constructor(worksheet?: Worksheet, address?: AddressInput, offset?: number);
-    static asInstance(model: any): Anchor | null;
+    constructor(worksheet?: Worksheet, address?: AddressInput | null, offset?: number);
+    static asInstance(model: AddressInput | Anchor | null | undefined): Anchor | null;
     get col(): number;
     set col(v: number);
     get row(): number;
     set row(v: number);
     get colWidth(): number;
     get rowHeight(): number;
-    get model(): Pick<Anchor, "nativeCol" | "nativeRow" | "nativeColOff" | "nativeRowOff">;
-    set model(value: Pick<Anchor, "nativeCol" | "nativeRow" | "nativeColOff" | "nativeRowOff">);
+    get model(): AnchorModel;
+    set model(value: AnchorModel);
 }
 export { Anchor };
+export type { AnchorModel };
 type IAnchor = Pick<InstanceType<typeof Anchor>, "col" | "row" | "nativeCol" | "nativeRow" | "nativeColOff" | "nativeRowOff">;
 export type { IAnchor };