@cj-tech-master/excelts 1.4.2 → 1.4.4

package/dist/cjs/stream/xlsx/workbook-writer.js

@@ -37,8 +37,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/cjs/utils/cell-format.js

@@ -221,20 +221,24 @@ const DAYS_LONG = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Frid
  * @param fmt Format string
  */
 function formatDate(serial, fmt) {
+    // Extract time components directly from serial number (timezone-agnostic)
+    const totalSeconds = Math.round(serial * 86400);
+    const timeOfDay = totalSeconds % 86400;
+    const hours = Math.floor(timeOfDay / 3600);
+    const minutes = Math.floor((timeOfDay % 3600) / 60);
+    const seconds = timeOfDay % 60;
+    // For date components, use excelToDate but only for date parts
     const date = (0, utils_js_1.excelToDate)(serial, false);
-    const year = date.getFullYear();
-    const month = date.getMonth(); // 0-indexed
-    const day = date.getDate();
-    const hours = date.getHours();
-    const minutes = date.getMinutes();
-    const seconds = date.getSeconds();
-    const dayOfWeek = date.getDay();
+    const year = date.getUTCFullYear();
+    const month = date.getUTCMonth(); // 0-indexed
+    const day = date.getUTCDate();
+    const dayOfWeek = date.getUTCDay();
     // Calculate fractional seconds from serial
-    const totalSeconds = serial * 86400;
-    const fractionalSeconds = totalSeconds - Math.floor(totalSeconds);
+    const fractionalSeconds = serial * 86400 - Math.floor(serial * 86400);
     // Check for AM/PM
     const hasAmPm = /AM\/PM|A\/P/i.test(fmt);
     const isPm = hours >= 12;
+    // Standard 12-hour format: 0 and 12 both display as 12
     const hours12 = hours % 12 || 12;
     // Remove color codes like [Red], [Green], etc. but keep elapsed time brackets
     let result = fmt.replace(/\[(Red|Green|Blue|Yellow|Magenta|Cyan|White|Black|Color\d+)\]/gi, "");

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

@@ -24,30 +24,140 @@ exports.sheetAddAoa = sheetAddAoa;
 exports.sheetToAoa = sheetToAoa;
 const workbook_js_1 = require("../doc/workbook");
 const col_cache_js_1 = require("./col-cache");
-const utils_js_1 = require("./utils");
 const cell_format_js_1 = require("./cell-format");
+/**
+ * Convert a Date object back to Excel serial number without timezone issues.
+ * This reverses the excelToDate conversion exactly.
+ * excelToDate uses: new Date(Math.round((v - 25569) * 24 * 3600 * 1000))
+ * So we reverse it: (date.getTime() / (24 * 3600 * 1000)) + 25569
+ */
+function dateToExcelSerial(d) {
+    return d.getTime() / (24 * 3600 * 1000) + 25569;
+}
+/**
+ * Check if format is a pure time format (no date components like y, m for month, d)
+ * Time formats only contain: h, m (minutes in time context), s, AM/PM
+ * Excludes elapsed time formats like [h]:mm:ss which should keep full serial number
+ */
+function isTimeOnlyFormat(fmt) {
+    // Remove quoted strings first
+    const cleaned = fmt.replace(/"[^"]*"/g, "");
+    // Elapsed time formats [h], [m], [s] should NOT be treated as time-only
+    // They need the full serial number to calculate total hours/minutes/seconds
+    if (/\[[hms]\]/i.test(cleaned)) {
+        return false;
+    }
+    // Remove color codes and conditions (but we already checked for [h], [m], [s])
+    const withoutBrackets = cleaned.replace(/\[[^\]]*\]/g, "");
+    // Check if it has time components (h, s, or AM/PM)
+    const hasTimeComponents = /[hs]/i.test(withoutBrackets) || /AM\/PM|A\/P/i.test(withoutBrackets);
+    // Check if it has date components (y, d, or m not adjacent to h/s which would make it minutes)
+    // In Excel: "m" after "h" or before "s" is minutes, otherwise it's month
+    const hasDateComponents = /[yd]/i.test(withoutBrackets);
+    // If it has time but no date components, it's a time-only format
+    // Also check for standalone 'm' that's not minutes (not near h or s)
+    if (hasDateComponents) {
+        return false;
+    }
+    // Check for month 'm' - if 'm' exists but not in h:m or m:s context, it's a date format
+    if (/m/i.test(withoutBrackets) && !hasTimeComponents) {
+        return false;
+    }
+    return hasTimeComponents;
+}
+/**
+ * Check if format is a date format (contains y, d, or month-m)
+ * Used to determine if dateFormat override should be applied
+ */
+function isDateFormat(fmt) {
+    // Remove quoted strings first
+    const cleaned = fmt.replace(/"[^"]*"/g, "");
+    // Elapsed time formats [h], [m], [s] are NOT date formats
+    if (/\[[hms]\]/i.test(cleaned)) {
+        return false;
+    }
+    // Remove color codes and conditions
+    const withoutBrackets = cleaned.replace(/\[[^\]]*\]/g, "");
+    // Check for year or day components
+    if (/[yd]/i.test(withoutBrackets)) {
+        return true;
+    }
+    // Check for month 'm' - only if it's NOT in time context (not near h or s)
+    // In Excel: "m" after "h" or before "s" is minutes, otherwise it's month
+    if (/m/i.test(withoutBrackets)) {
+        const hasTimeComponents = /[hs]/i.test(withoutBrackets) || /AM\/PM|A\/P/i.test(withoutBrackets);
+        // If no time components, 'm' is month
+        if (!hasTimeComponents) {
+            return true;
+        }
+        // If has time components, need to check if 'm' is month or minutes
+        // Simplified: if format has both date-like and time-like patterns, consider it a date format
+        // e.g., "m/d/yy h:mm" - has 'm' as month and 'mm' as minutes
+    }
+    return false;
+}
+/**
+ * Format a value (Date, number, boolean, string) according to the given format
+ * Handles timezone-independent conversion for Date objects
+ * @param value - The value to format
+ * @param fmt - The format string to use
+ * @param dateFormat - Optional override format for date values (not applied to time or elapsed time formats)
+ */
+function formatValue(value, fmt, dateFormat) {
+    // Date object - convert back to Excel serial number
+    if (value instanceof Date) {
+        let serial = dateToExcelSerial(value);
+        // For time-only formats, use only the fractional part (time portion)
+        if (isTimeOnlyFormat(fmt)) {
+            serial = serial % 1;
+            if (serial < 0) {
+                serial += 1;
+            }
+            return (0, cell_format_js_1.format)(fmt, serial);
+        }
+        // Only apply dateFormat override to actual date formats
+        // (not elapsed time formats like [h]:mm:ss)
+        const actualFmt = dateFormat && isDateFormat(fmt) ? dateFormat : fmt;
+        return (0, cell_format_js_1.format)(actualFmt, serial);
+    }
+    // Number/Boolean/String - let cellFormat handle it
+    return (0, cell_format_js_1.format)(fmt, value);
+}
 /**
  * Get formatted display text for a cell value
  * Returns the value formatted according to the cell's numFmt
- * This matches Excel's display exactly
+ * This matches Excel's display exactly (timezone-independent)
+ * @param cell - The cell to get display text for
+ * @param dateFormat - Optional override format for date values
  */
-function getCellDisplayText(cell) {
+function getCellDisplayText(cell, dateFormat) {
     const value = cell.value;
     const fmt = cell.numFmt || "General";
     // Null/undefined
     if (value == null) {
         return "";
     }
-    // Date object - convert to Excel serial number
-    if (value instanceof Date) {
-        const serial = (0, utils_js_1.dateToExcel)(value, false);
-        return (0, cell_format_js_1.format)(fmt, serial);
+    // Date/Number/Boolean/String - format directly
+    if (value instanceof Date ||
+        typeof value === "number" ||
+        typeof value === "boolean" ||
+        typeof value === "string") {
+        return formatValue(value, fmt, dateFormat);
     }
-    // Number/Boolean/String - let cellFormat handle it
-    if (typeof value === "number" || typeof value === "boolean" || typeof value === "string") {
-        return (0, cell_format_js_1.format)(fmt, value);
+    // Formula type - use the result value
+    if (typeof value === "object" && "formula" in value) {
+        const result = value.result;
+        if (result == null) {
+            return "";
+        }
+        if (result instanceof Date ||
+            typeof result === "number" ||
+            typeof result === "boolean" ||
+            typeof result === "string") {
+            return formatValue(result, fmt, dateFormat);
+        }
     }
-    // Fallback to cell.text for other types (rich text, hyperlink, error, formula, etc.)
+    // Fallback to cell.text for other types (rich text, hyperlink, error, etc.)
     return cell.text;
 }
 // =============================================================================
@@ -283,7 +393,7 @@ function sheetToJson(worksheet, opts) {
             let isEmpty = true;
             for (let col = startCol; col <= endCol; col++) {
                 const cell = worksheet.getCell(row, col);
-                const val = o.raw === false ? getCellDisplayText(cell).trim() : cell.value;
+                const val = o.raw === false ? getCellDisplayText(cell, o.dateFormat).trim() : cell.value;
                 if (val != null && val !== "") {
                     rowData[col - startCol] = val;
                     isEmpty = false;
@@ -311,7 +421,7 @@ function sheetToJson(worksheet, opts) {
             let isEmpty = true;
             for (let col = startCol; col <= endCol; col++) {
                 const cell = worksheet.getCell(row, col);
-                const val = o.raw === false ? getCellDisplayText(cell).trim() : cell.value;
+                const val = o.raw === false ? getCellDisplayText(cell, o.dateFormat).trim() : cell.value;
                 const key = encodeCol(col - 1); // 0-indexed for encodeCol
                 if (val != null && val !== "") {
                     rowData[key] = val;
@@ -338,7 +448,7 @@ function sheetToJson(worksheet, opts) {
                 const colIdx = col - startCol;
                 const key = headerOpt[colIdx] ?? `__EMPTY_${colIdx}`;
                 const cell = worksheet.getCell(row, col);
-                const val = o.raw === false ? getCellDisplayText(cell).trim() : cell.value;
+                const val = o.raw === false ? getCellDisplayText(cell, o.dateFormat).trim() : cell.value;
                 if (val != null && val !== "") {
                     rowData[key] = val;
                     isEmpty = false;
@@ -380,7 +490,7 @@ function sheetToJson(worksheet, opts) {
         let isEmpty = true;
         for (let col = startCol; col <= endCol; col++) {
             const cell = worksheet.getCell(row, col);
-            const val = o.raw === false ? getCellDisplayText(cell).trim() : cell.value;
+            const val = o.raw === false ? getCellDisplayText(cell, o.dateFormat).trim() : cell.value;
             const key = headers[col - startCol];
             if (val != null && val !== "") {
                 rowData[key] = val;

package/dist/cjs/utils/unzip/extract.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * Simple ZIP extraction utilities
+ * Provides easy-to-use Promise-based API for extracting ZIP files
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAll = extractAll;
+exports.extractFile = extractFile;
+exports.listFiles = listFiles;
+exports.forEachEntry = forEachEntry;
+const stream_1 = require("stream");
+const parse_js_1 = require("./parse");
+/**
+ * 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`);
+ * }
+ * ```
+ */
+async function extractAll(zipData) {
+    const files = new Map();
+    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
+    const parse = (0, parse_js_1.createParse)({ forceStream: true });
+    const stream = stream_1.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"));
+ * }
+ * ```
+ */
+async function extractFile(zipData, filePath) {
+    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
+    const parse = (0, parse_js_1.createParse)({ forceStream: true });
+    const stream = stream_1.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", ...]
+ * ```
+ */
+async function listFiles(zipData) {
+    const paths = [];
+    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
+    const parse = (0, parse_js_1.createParse)({ forceStream: true });
+    const stream = stream_1.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
+ * });
+ * ```
+ */
+async function forEachEntry(zipData, callback) {
+    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
+    const parse = (0, parse_js_1.createParse)({ forceStream: true });
+    const stream = stream_1.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/cjs/utils/unzip/index.js

@@ -5,7 +5,7 @@
  * License: MIT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseExtraField = exports.parseDateTime = exports.parseBuffer = exports.bufferStream = exports.NoopStream = exports.PullStream = exports.createParse = exports.Parse = void 0;
+exports.forEachEntry = exports.listFiles = exports.extractFile = exports.extractAll = exports.parseExtraField = exports.parseDateTime = exports.parseBuffer = exports.bufferStream = exports.NoopStream = exports.PullStream = exports.createParse = exports.Parse = void 0;
 var parse_js_1 = require("./parse");
 Object.defineProperty(exports, "Parse", { enumerable: true, get: function () { return parse_js_1.Parse; } });
 Object.defineProperty(exports, "createParse", { enumerable: true, get: function () { return parse_js_1.createParse; } });
@@ -21,3 +21,9 @@ var parse_datetime_js_1 = require("./parse-datetime");
 Object.defineProperty(exports, "parseDateTime", { enumerable: true, get: function () { return parse_datetime_js_1.parseDateTime; } });
 var parse_extra_field_js_1 = require("./parse-extra-field");
 Object.defineProperty(exports, "parseExtraField", { enumerable: true, get: function () { return parse_extra_field_js_1.parseExtraField; } });
+// Simple extraction API
+var extract_js_1 = require("./extract");
+Object.defineProperty(exports, "extractAll", { enumerable: true, get: function () { return extract_js_1.extractAll; } });
+Object.defineProperty(exports, "extractFile", { enumerable: true, get: function () { return extract_js_1.extractFile; } });
+Object.defineProperty(exports, "listFiles", { enumerable: true, get: function () { return extract_js_1.listFiles; } });
+Object.defineProperty(exports, "forEachEntry", { enumerable: true, get: function () { return extract_js_1.forEachEntry; } });

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

@@ -7,6 +7,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}="${(0, utils_js_1.xmlEncode)(value.toString())}"`);
 }
@@ -24,15 +26,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;
@@ -99,6 +109,7 @@ class XmlStream {
         }
         this.open = false;
         this.leaf = false;
+        this._consolidate();
     }
     leafNode(name, attributes, text) {
         this.openNode(name, attributes);
@@ -118,7 +129,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;
     }
@@ -133,12 +145,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("");
     }
 }
 exports.XmlStream = XmlStream;