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

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);
                         }
                     });
@@ -470,10 +467,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;
@@ -611,12 +613,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 +756,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/stream/xlsx/workbook-writer.js

@@ -31,8 +31,9 @@ class WorkbookWriter {
         this.views = [];
         this.zipOptions = options.zip;
         // Extract compression level from zip options (supports both zlib.level and compressionOptions.level)
-        // Default compression level is 6 (good balance of speed and size)
-        const level = options.zip?.zlib?.level ?? options.zip?.compressionOptions?.level ?? 6;
+        // Default compression level is 1 (fast compression with good ratio)
+        // Level 1 is ~2x faster than level 6 with only ~7% larger files
+        const level = options.zip?.zlib?.level ?? options.zip?.compressionOptions?.level ?? 1;
         this.compressionLevel = Math.max(0, Math.min(9, level));
         this.media = [];
         this.commentRefs = [];

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/esm/utils/unzip/extract.js

@@ -0,0 +1,160 @@
+/**
+ * Simple ZIP extraction utilities
+ * Provides easy-to-use Promise-based API for extracting ZIP files
+ */
+import { Readable } from "stream";
+import { createParse } from "./parse.js";
+/**
+ * Extract all files from a ZIP buffer
+ *
+ * @param zipData - ZIP file data as Buffer or Uint8Array
+ * @returns Map of file paths to their content
+ *
+ * @example
+ * ```ts
+ * import { extractAll } from "./utils/unzip/extract.js";
+ *
+ * const zipData = fs.readFileSync("archive.zip");
+ * const files = await extractAll(zipData);
+ *
+ * for (const [path, file] of files) {
+ *   console.log(`${path}: ${file.data.length} bytes`);
+ * }
+ * ```
+ */
+export async function extractAll(zipData) {
+    const files = new Map();
+    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
+    const parse = createParse({ forceStream: true });
+    const stream = Readable.from([buffer]);
+    stream.pipe(parse);
+    for await (const entry of parse) {
+        const zipEntry = entry;
+        const isDirectory = zipEntry.type === "Directory";
+        if (isDirectory) {
+            files.set(zipEntry.path, {
+                path: zipEntry.path,
+                data: Buffer.alloc(0),
+                isDirectory: true,
+                size: 0
+            });
+            zipEntry.autodrain();
+        }
+        else {
+            const data = await zipEntry.buffer();
+            files.set(zipEntry.path, {
+                path: zipEntry.path,
+                data,
+                isDirectory: false,
+                size: data.length
+            });
+        }
+    }
+    return files;
+}
+/**
+ * Extract a single file from a ZIP buffer
+ *
+ * @param zipData - ZIP file data as Buffer or Uint8Array
+ * @param filePath - Path of the file to extract
+ * @returns File content as Buffer, or null if not found
+ *
+ * @example
+ * ```ts
+ * import { extractFile } from "./utils/unzip/extract.js";
+ *
+ * const zipData = fs.readFileSync("archive.zip");
+ * const content = await extractFile(zipData, "readme.txt");
+ * if (content) {
+ *   console.log(content.toString("utf-8"));
+ * }
+ * ```
+ */
+export async function extractFile(zipData, filePath) {
+    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
+    const parse = createParse({ forceStream: true });
+    const stream = Readable.from([buffer]);
+    stream.pipe(parse);
+    for await (const entry of parse) {
+        const zipEntry = entry;
+        if (zipEntry.path === filePath) {
+            if (zipEntry.type === "Directory") {
+                return Buffer.alloc(0);
+            }
+            return zipEntry.buffer();
+        }
+        zipEntry.autodrain();
+    }
+    return null;
+}
+/**
+ * List all file paths in a ZIP buffer (without extracting content)
+ *
+ * @param zipData - ZIP file data as Buffer or Uint8Array
+ * @returns Array of file paths
+ *
+ * @example
+ * ```ts
+ * import { listFiles } from "./utils/unzip/extract.js";
+ *
+ * const zipData = fs.readFileSync("archive.zip");
+ * const paths = await listFiles(zipData);
+ * console.log(paths); // ["file1.txt", "folder/file2.txt", ...]
+ * ```
+ */
+export async function listFiles(zipData) {
+    const paths = [];
+    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
+    const parse = createParse({ forceStream: true });
+    const stream = Readable.from([buffer]);
+    stream.pipe(parse);
+    for await (const entry of parse) {
+        const zipEntry = entry;
+        paths.push(zipEntry.path);
+        zipEntry.autodrain();
+    }
+    return paths;
+}
+/**
+ * Iterate over ZIP entries with a callback (memory efficient for large ZIPs)
+ *
+ * @param zipData - ZIP file data as Buffer or Uint8Array
+ * @param callback - Async callback for each entry, return false to stop iteration
+ *
+ * @example
+ * ```ts
+ * import { forEachEntry } from "./utils/unzip/extract.js";
+ *
+ * await forEachEntry(zipData, async (path, getData) => {
+ *   if (path.endsWith(".xml")) {
+ *     const content = await getData();
+ *     console.log(content.toString("utf-8"));
+ *   }
+ *   return true; // continue iteration
+ * });
+ * ```
+ */
+export async function forEachEntry(zipData, callback) {
+    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
+    const parse = createParse({ forceStream: true });
+    const stream = Readable.from([buffer]);
+    stream.pipe(parse);
+    for await (const entry of parse) {
+        const zipEntry = entry;
+        let dataPromise = null;
+        const getData = () => {
+            if (!dataPromise) {
+                dataPromise = zipEntry.buffer();
+            }
+            return dataPromise;
+        };
+        const shouldContinue = await callback(zipEntry.path, getData, zipEntry);
+        // If callback didn't read data, drain it
+        if (!dataPromise) {
+            zipEntry.autodrain();
+        }
+        if (shouldContinue === false) {
+            break;
+        }
+    }
+}

package/dist/esm/utils/unzip/index.js

@@ -10,3 +10,5 @@ export { bufferStream } from "./buffer-stream.js";
 export { parse as parseBuffer } from "./parse-buffer.js";
 export { parseDateTime } from "./parse-datetime.js";
 export { parseExtraField } from "./parse-extra-field.js";
+// Simple extraction API
+export { extractAll, extractFile, listFiles, forEachEntry } from "./extract.js";

package/dist/esm/utils/xml-stream.js

@@ -4,6 +4,8 @@ const OPEN_ANGLE = "<";
 const CLOSE_ANGLE = ">";
 const OPEN_ANGLE_SLASH = "</";
 const CLOSE_SLASH_ANGLE = "/>";
+// Chunk size for periodic consolidation (reduces final join overhead)
+const CHUNK_SIZE = 10000;
 function pushAttribute(xml, name, value) {
     xml.push(` ${name}="${xmlEncode(value.toString())}"`);
 }
@@ -21,15 +23,23 @@ function pushAttributes(xml, attributes) {
 class XmlStream {
     constructor() {
         this._xml = [];
+        this._chunks = [];
         this._stack = [];
         this._rollbacks = [];
     }
+    _consolidate() {
+        // Periodically join small strings into larger chunks to reduce final join overhead
+        if (this._xml.length >= CHUNK_SIZE) {
+            this._chunks.push(this._xml.join(""));
+            this._xml = [];
+        }
+    }
     get tos() {
         return this._stack.length ? this._stack[this._stack.length - 1] : undefined;
     }
     get cursor() {
         // handy way to track whether anything has been added
-        return this._xml.length;
+        return this._chunks.length * CHUNK_SIZE + this._xml.length;
     }
     openXml(docAttributes) {
         const xml = this._xml;
@@ -96,6 +106,7 @@ class XmlStream {
         }
         this.open = false;
         this.leaf = false;
+        this._consolidate();
     }
     leafNode(name, attributes, text) {
         this.openNode(name, attributes);
@@ -115,7 +126,8 @@ class XmlStream {
             xml: this._xml.length,
             stack: this._stack.length,
             leaf: this.leaf,
-            open: this.open
+            open: this.open,
+            chunksLength: this._chunks.length
         });
         return this.cursor;
     }
@@ -130,12 +142,22 @@ class XmlStream {
         if (this._stack.length > r.stack) {
             this._stack.splice(r.stack, this._stack.length - r.stack);
         }
+        if (this._chunks.length > r.chunksLength) {
+            this._chunks.splice(r.chunksLength, this._chunks.length - r.chunksLength);
+        }
         this.leaf = r.leaf;
         this.open = r.open;
     }
     get xml() {
         this.closeAll();
-        return this._xml.join("");
+        // Join chunks first, then remaining xml array
+        if (this._chunks.length === 0) {
+            return this._xml.join("");
+        }
+        if (this._xml.length > 0) {
+            this._chunks.push(this._xml.join(""));
+        }
+        return this._chunks.join("");
     }
 }
 XmlStream.StdDocAttributes = {