@cj-tech-master/excelts 1.4.2 → 1.4.4

package/dist/esm/xlsx/xform/book/defined-name-xform.js

@@ -42,16 +42,50 @@ class DefinedNamesXform extends BaseXform {
         return false;
     }
 }
+// Regex to validate cell range format:
+// - Cell: $A$1 or A1
+// - Range: $A$1:$B$10 or A1:B10
+// - Row range: $1:$2 (for print titles)
+// - Column range: $A:$B (for print titles)
+const cellRangeRegexp = /^[$]?[A-Za-z]{1,3}[$]?\d+(:[$]?[A-Za-z]{1,3}[$]?\d+)?$/;
+const rowRangeRegexp = /^[$]?\d+:[$]?\d+$/;
+const colRangeRegexp = /^[$]?[A-Za-z]{1,3}:[$]?[A-Za-z]{1,3}$/;
 function isValidRange(range) {
+    // Skip array constants wrapped in {} - these are not valid cell ranges
+    // e.g., {"'Sheet1'!$A$1:$B$10"} or {#N/A,#N/A,FALSE,"text"}
+    if (range.startsWith("{") || range.endsWith("}")) {
+        return false;
+    }
+    // Extract the cell reference part (after the sheet name if present)
+    const cellRef = range.split("!").pop() || "";
+    // Must match one of the valid patterns
+    if (!cellRangeRegexp.test(cellRef) &&
+        !rowRangeRegexp.test(cellRef) &&
+        !colRangeRegexp.test(cellRef)) {
+        return false;
+    }
     try {
-        colCache.decodeEx(range);
-        return true;
+        const decoded = colCache.decodeEx(range);
+        // For cell ranges: row/col or top/bottom/left/right should be valid numbers
+        // For row ranges ($1:$2): top/bottom are numbers, left/right are null
+        // For column ranges ($A:$B): left/right are numbers, top/bottom are null
+        if (("row" in decoded && typeof decoded.row === "number") ||
+            ("top" in decoded && typeof decoded.top === "number") ||
+            ("left" in decoded && typeof decoded.left === "number")) {
+            return true;
+        }
+        return false;
     }
     catch {
         return false;
     }
 }
 function extractRanges(parsedText) {
+    // Skip if the entire text is wrapped in {} (array constant)
+    const trimmed = parsedText.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+        return [];
+    }
     const ranges = [];
     let quotesOpened = false;
     let last = "";

package/dist/esm/xlsx/xform/list-xform.js

@@ -79,5 +79,11 @@ class ListXform extends BaseXform {
             });
         }
     }
+    reset() {
+        super.reset();
+        if (this.childXform) {
+            this.childXform.reset();
+        }
+    }
 }
 export { ListXform };

package/dist/esm/xlsx/xform/sheet/cell-xform.js

@@ -407,7 +407,12 @@ class CellXform extends BaseXform {
                 }
                 break;
             case Enums.ValueType.Formula:
-                if (model.result !== undefined && style && isDateFmt(style.numFmt)) {
+                // Only convert formula result to date if the result is a number
+                // String results (t="str") should not be converted even if the cell has a date format
+                if (model.result !== undefined &&
+                    typeof model.result === "number" &&
+                    style &&
+                    isDateFmt(style.numFmt)) {
                     model.result = excelToDate(model.result, options.date1904);
                 }
                 if (model.shareType === "shared") {

package/dist/esm/xlsx/xform/sheet/row-xform.js

@@ -1,6 +1,7 @@
 import { BaseXform } from "../base-xform.js";
 import { CellXform } from "./cell-xform.js";
 import { parseBoolean } from "../../../utils/utils.js";
+import { colCache } from "../../../utils/col-cache.js";
 class RowXform extends BaseXform {
     constructor(options) {
         super();
@@ -12,6 +13,11 @@ class RowXform extends BaseXform {
     get tag() {
         return "row";
     }
+    reset() {
+        super.reset();
+        this.numRowsSeen = 0;
+        this.lastCellCol = 0;
+    }
     prepare(model, options) {
         const styleId = options.styles.addStyleModel(model.style);
         if (styleId) {
@@ -62,11 +68,15 @@ class RowXform extends BaseXform {
         }
         if (node.name === "row") {
             this.numRowsSeen += 1;
+            // Reset lastCellCol for each new row
+            this.lastCellCol = 0;
             const spans = node.attributes.spans
                 ? node.attributes.spans.split(":").map((span) => parseInt(span, 10))
                 : [undefined, undefined];
+            // If r attribute is missing, use numRowsSeen as the row number
+            const rowNumber = node.attributes.r ? parseInt(node.attributes.r, 10) : this.numRowsSeen;
             const model = (this.model = {
-                number: parseInt(node.attributes.r, 10),
+                number: rowNumber,
                 min: spans[0],
                 max: spans[1],
                 cells: []
@@ -106,7 +116,19 @@ class RowXform extends BaseXform {
     parseClose(name) {
         if (this.parser) {
             if (!this.parser.parseClose(name)) {
-                this.model.cells.push(this.parser.model);
+                const cellModel = this.parser.model;
+                // If cell has address, extract column number from it
+                // Otherwise, calculate address based on position
+                if (cellModel.address) {
+                    const decoded = colCache.decodeAddress(cellModel.address);
+                    this.lastCellCol = decoded.col;
+                }
+                else {
+                    // No r attribute, calculate address from position
+                    this.lastCellCol += 1;
+                    cellModel.address = colCache.encodeAddress(this.model.number, this.lastCellCol);
+                }
+                this.model.cells.push(cellModel);
                 if (this.maxItems && this.model.cells.length > this.maxItems) {
                     throw new Error(`Max column count (${this.maxItems}) exceeded`);
                 }

package/dist/esm/xlsx/xform/table/filter-column-xform.js

@@ -54,6 +54,10 @@ class FilterColumnXform extends BaseXform {
                     filterButton: attributes.hiddenButton === "0"
                 };
                 return true;
+            case "dynamicFilter":
+                // Ignore dynamicFilter nodes - we don't need to preserve them for reading
+                // See: https://github.com/exceljs/exceljs/issues/2972
+                return true;
             default:
                 this.parser = this.map[node.name];
                 if (this.parser) {

package/dist/types/utils/sheet-utils.d.ts

@@ -73,7 +73,7 @@ export interface JSON2SheetOpts {
     /** Use specified field order (default Object.keys) */
     header?: string[];
     /** Use specified date format in string output */
-    dateNF?: string;
+    dateFormat?: string;
     /** Store dates as type d (default is n) */
     cellDates?: boolean;
     /** If true, do not include header row in output */
@@ -117,6 +117,12 @@ export interface Sheet2JSONOpts {
     defval?: CellValue;
     /** Include blank lines in the output */
     blankrows?: boolean;
+    /**
+     * Override format for date values (not applied to time-only formats).
+     * When provided, Date values will be formatted using this format string.
+     * @example "dd/mm/yyyy" or "yyyy-mm-dd"
+     */
+    dateFormat?: string;
 }
 /**
  * Convert worksheet to JSON array (xlsx compatible)
@@ -164,7 +170,7 @@ export interface AOA2SheetOpts {
     /** Use specified cell as starting point */
     origin?: Origin;
     /** Use specified date format in string output */
-    dateNF?: string;
+    dateFormat?: string;
     /** Store dates as type d (default is n) */
     cellDates?: boolean;
 }

package/dist/types/utils/unzip/extract.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Simple ZIP extraction utilities
+ * Provides easy-to-use Promise-based API for extracting ZIP files
+ */
+import { type ZipEntry } from "./parse.js";
+/**
+ * Extracted file entry
+ */
+export interface ExtractedFile {
+    /** File path within the ZIP */
+    path: string;
+    /** File content as Buffer */
+    data: Buffer;
+    /** Whether this is a directory */
+    isDirectory: boolean;
+    /** Uncompressed size */
+    size: number;
+}
+/**
+ * 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 declare function extractAll(zipData: Buffer | Uint8Array): Promise<Map<string, ExtractedFile>>;
+/**
+ * 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 declare function extractFile(zipData: Buffer | Uint8Array, filePath: string): Promise<Buffer | 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 declare function listFiles(zipData: Buffer | Uint8Array): Promise<string[]>;
+/**
+ * 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 declare function forEachEntry(zipData: Buffer | Uint8Array, callback: (path: string, getData: () => Promise<Buffer>, entry: ZipEntry) => Promise<boolean | void>): Promise<void>;

package/dist/types/utils/unzip/index.d.ts

@@ -10,3 +10,4 @@ export { bufferStream } from "./buffer-stream.js";
 export { parse as parseBuffer } from "./parse-buffer.js";
 export { parseDateTime } from "./parse-datetime.js";
 export { parseExtraField, type ExtraField, type ZipVars } from "./parse-extra-field.js";
+export { extractAll, extractFile, listFiles, forEachEntry, type ExtractedFile } from "./extract.js";

package/dist/types/utils/xml-stream.d.ts

@@ -3,11 +3,13 @@ interface Attributes {
 }
 declare class XmlStream {
     private _xml;
+    private _chunks;
     private _stack;
     private _rollbacks;
     leaf?: boolean;
     open?: boolean;
     constructor();
+    private _consolidate;
     get tos(): string | undefined;
     get cursor(): number;
     openXml(docAttributes?: Attributes): void;

package/dist/types/utils/zip/compress.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Native compression utilities using platform APIs
+ *
+ * - Node.js: Uses native zlib module (C++ implementation, fastest)
+ * - Browser: Uses CompressionStream API (Chrome 80+, Firefox 113+, Safari 16.4+)
+ *
+ * Both use "deflate-raw" format which is required for ZIP files
+ * (raw DEFLATE without zlib header/trailer)
+ */
+import type * as zlibType from "zlib";
+/**
+ * Compression options
+ */
+export interface CompressOptions {
+    /**
+     * Compression level (0-9)
+     * - 0: No compression (STORE)
+     * - 1: Fastest compression
+     * - 6: Default compression (good balance)
+     * - 9: Best compression (slowest)
+     *
+     * Note: CompressionStream does not support level configuration,
+     * it uses a fixed level (~6)
+     */
+    level?: number;
+}
+/**
+ * Ensure zlib is loaded (Node.js only)
+ * Call this before using sync methods if you need to guarantee availability
+ */
+export declare function ensureZlib(): Promise<typeof zlibType | null>;
+/**
+ * Check if native zlib is available (Node.js)
+ */
+export declare function hasNativeZlib(): boolean;
+/**
+ * Check if CompressionStream is available (Browser/Node.js 17+)
+ */
+export declare function hasCompressionStream(): boolean;
+/**
+ * Compress data using the best available native method
+ *
+ * Priority:
+ * 1. Node.js zlib (if available) - fastest, supports compression levels
+ * 2. CompressionStream (browser/Node.js 17+) - no level support
+ * 3. Return uncompressed data (fallback)
+ *
+ * @param data - Data to compress
+ * @param options - Compression options
+ * @returns Compressed data
+ *
+ * @example
+ * ```ts
+ * const data = new TextEncoder().encode("Hello, World!");
+ * const compressed = await compress(data, { level: 6 });
+ * ```
+ */
+export declare function compress(data: Uint8Array, options?: CompressOptions): Promise<Uint8Array>;
+/**
+ * Compress data synchronously using Node.js zlib
+ * Only available in Node.js environment
+ *
+ * @param data - Data to compress
+ * @param options - Compression options
+ * @returns Compressed data
+ * @throws Error if not in Node.js environment
+ */
+export declare function compressSync(data: Uint8Array, options?: CompressOptions): Uint8Array;
+/**
+ * Decompress data using the best available native method
+ *
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
+ */
+export declare function decompress(data: Uint8Array): Promise<Uint8Array>;
+/**
+ * Decompress data synchronously using Node.js zlib
+ *
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
+ * @throws Error if not in Node.js environment
+ */
+export declare function decompressSync(data: Uint8Array): Uint8Array;

package/dist/types/utils/zip/crc32.d.ts

@@ -0,0 +1,55 @@
+/**
+ * CRC32 calculation utility for ZIP files
+ *
+ * - Node.js: Uses native zlib.crc32 (C++ implementation, ~100x faster)
+ * - Browser: Uses lookup table optimization
+ *
+ * The polynomial used is the standard CRC-32 IEEE 802.3:
+ * x^32 + x^26 + x^23 + x^22 + x^16 + x^12 + x^11 + x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x + 1
+ * Represented as 0xEDB88320 in reversed (LSB-first) form
+ */
+/**
+ * Calculate CRC32 checksum for the given data
+ * Uses native zlib.crc32 in Node.js for ~100x better performance
+ *
+ * @param data - Input data as Uint8Array or Buffer
+ * @returns CRC32 checksum as unsigned 32-bit integer
+ *
+ * @example
+ * ```ts
+ * const data = new TextEncoder().encode("Hello, World!");
+ * const checksum = crc32(data);
+ * console.log(checksum.toString(16)); // "ec4ac3d0"
+ * ```
+ */
+export declare function crc32(data: Uint8Array): number;
+/**
+ * Ensure zlib is loaded (for use before calling crc32)
+ */
+export declare function ensureCrc32(): Promise<void>;
+/**
+ * Calculate CRC32 incrementally (useful for streaming)
+ * Call with initial crc of 0xffffffff, then finalize with crc32Finalize
+ * Note: This always uses JS implementation for consistency in streaming
+ *
+ * @param crc - Current CRC value (start with 0xffffffff)
+ * @param data - Input data chunk
+ * @returns Updated CRC value (not finalized)
+ *
+ * @example
+ * ```ts
+ * let crc = 0xffffffff;
+ * crc = crc32Update(crc, chunk1);
+ * crc = crc32Update(crc, chunk2);
+ * const checksum = crc32Finalize(crc);
+ * ```
+ */
+export declare function crc32Update(crc: number, data: Uint8Array): number;
+/**
+ * Finalize CRC32 calculation
+ * XOR with 0xffffffff and convert to unsigned 32-bit
+ *
+ * @param crc - CRC value from crc32Update
+ * @returns Final CRC32 checksum
+ */
+export declare function crc32Finalize(crc: number): number;

package/dist/types/utils/zip/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Native ZIP utilities - Pure native implementation without third-party dependencies
+ *
+ * This module provides ZIP file creation using only native platform APIs:
+ * - Node.js: Uses native zlib module (C++ implementation, fastest)
+ * - Browser: Uses CompressionStream API (Chrome 80+, Firefox 113+, Safari 16.4+)
+ *
+ * Features:
+ * - Full ZIP format support (Local File Headers, Central Directory, EOCD)
+ * - DEFLATE compression (level 0-9 on Node.js, fixed level on browser)
+ * - STORE mode (no compression)
+ * - UTF-8 filename support
+ * - File comments and ZIP comments
+ * - Streaming API for large files
+ * - Both sync (Node.js) and async APIs
+ *
+ * @example Basic usage
+ * ```ts
+ * import { createZip } from "./utils/zip/index.js";
+ *
+ * const zipData = await createZip([
+ *   { name: "hello.txt", data: new TextEncoder().encode("Hello!") },
+ *   { name: "folder/nested.txt", data: new TextEncoder().encode("Nested file") }
+ * ], { level: 6 });
+ *
+ * // Write to file (Node.js)
+ * fs.writeFileSync("output.zip", zipData);
+ * ```
+ *
+ * @example Streaming usage
+ * ```ts
+ * import { ZipBuilder } from "./utils/zip/index.js";
+ *
+ * const builder = new ZipBuilder({ level: 1 });
+ *
+ * // Add files one by one
+ * const [header1, data1] = await builder.addFile({
+ *   name: "file1.txt",
+ *   data: new TextEncoder().encode("File 1 content")
+ * });
+ * stream.write(header1);
+ * stream.write(data1);
+ *
+ * // Finalize and write central directory
+ * for (const chunk of builder.finalize()) {
+ *   stream.write(chunk);
+ * }
+ * ```
+ */
+export { crc32, crc32Update, crc32Finalize } from "./crc32.js";
+export { compress, compressSync, decompress, decompressSync, hasNativeZlib, hasCompressionStream, type CompressOptions } from "./compress.js";
+export { createZip, createZipSync, ZipBuilder, type ZipEntry, type ZipOptions } from "./zip-builder.js";

package/dist/types/utils/zip/zip-builder.d.ts

@@ -0,0 +1,110 @@
+/**
+ * ZIP file format builder
+ *
+ * Implements ZIP file structure according to PKWARE's APPNOTE.TXT specification
+ * https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+ *
+ * ZIP file structure:
+ * ┌──────────────────────────┐
+ * │   Local File Header 1    │
+ * │   File Data 1            │
+ * ├──────────────────────────┤
+ * │   Local File Header 2    │
+ * │   File Data 2            │
+ * ├──────────────────────────┤
+ * │         ...              │
+ * ├──────────────────────────┤
+ * │  Central Directory 1     │
+ * │  Central Directory 2     │
+ * │         ...              │
+ * ├──────────────────────────┤
+ * │ End of Central Directory │
+ * └──────────────────────────┘
+ */
+import { type CompressOptions } from "./compress.js";
+/**
+ * ZIP file entry
+ */
+export interface ZipEntry {
+    /** File name (can include directory path, use forward slashes) */
+    name: string;
+    /** File data (will be compressed unless level=0) */
+    data: Uint8Array;
+    /** File modification time (optional, defaults to current time) */
+    modTime?: Date;
+    /** File comment (optional) */
+    comment?: string;
+}
+/**
+ * ZIP builder options
+ */
+export interface ZipOptions extends CompressOptions {
+    /** ZIP file comment (optional) */
+    comment?: string;
+}
+/**
+ * Create a ZIP file from entries (async)
+ *
+ * @param entries - Files to include in ZIP
+ * @param options - ZIP options
+ * @returns ZIP file as Uint8Array
+ *
+ * @example
+ * ```ts
+ * const zip = await createZip([
+ *   { name: "hello.txt", data: new TextEncoder().encode("Hello!") },
+ *   { name: "folder/file.txt", data: new TextEncoder().encode("Nested!") }
+ * ], { level: 6 });
+ * ```
+ */
+export declare function createZip(entries: ZipEntry[], options?: ZipOptions): Promise<Uint8Array>;
+/**
+ * Create a ZIP file from entries (sync, Node.js only)
+ *
+ * @param entries - Files to include in ZIP
+ * @param options - ZIP options
+ * @returns ZIP file as Uint8Array
+ * @throws Error if not in Node.js environment
+ */
+export declare function createZipSync(entries: ZipEntry[], options?: ZipOptions): Uint8Array;
+/**
+ * Streaming ZIP builder for large files
+ * Writes chunks to a callback as they are generated
+ */
+export declare class ZipBuilder {
+    private entries;
+    private currentOffset;
+    private level;
+    private zipComment;
+    private finalized;
+    /**
+     * Create a new ZIP builder
+     * @param options - ZIP options
+     */
+    constructor(options?: ZipOptions);
+    /**
+     * Add a file to the ZIP (async)
+     * @param entry - File entry
+     * @returns Local file header and compressed data chunks
+     */
+    addFile(entry: ZipEntry): Promise<Uint8Array[]>;
+    /**
+     * Add a file to the ZIP (sync, Node.js only)
+     * @param entry - File entry
+     * @returns Local file header and compressed data chunks
+     */
+    addFileSync(entry: ZipEntry): Uint8Array[];
+    /**
+     * Finalize the ZIP and return central directory + end record
+     * @returns Central directory and end of central directory chunks
+     */
+    finalize(): Uint8Array[];
+    /**
+     * Get current number of entries
+     */
+    get entryCount(): number;
+    /**
+     * Get current ZIP data size (without central directory)
+     */
+    get dataSize(): number;
+}

package/dist/types/utils/zip-stream.d.ts

@@ -1,9 +1,9 @@
 import events from "events";
-import { Zip } from "fflate";
 interface ZipWriterOptions {
-    type?: string;
+    /** Compression method: "DEFLATE" (default) or "STORE" (no compression) */
     compression?: "DEFLATE" | "STORE";
     compressionOptions?: {
+        /** Compression level 0-9: 0=none, 1=fast (default), 9=best */
         level?: number;
     };
 }
@@ -11,17 +11,11 @@ interface AppendOptions {
     name: string;
     base64?: boolean;
 }
-interface ZipFile {
-    data: Uint8Array;
-    isStream?: boolean;
-}
 declare class ZipWriter extends events.EventEmitter {
-    options: ZipWriterOptions;
-    files: Record<string, ZipFile>;
-    stream: any;
-    zip: Zip;
-    finalized: boolean;
-    compressionLevel: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+    private stream;
+    private zipBuilder;
+    private finalized;
+    private pendingWrites;
     constructor(options?: ZipWriterOptions);
     append(data: any, options: AppendOptions): void;
     push(chunk: any): boolean;

package/dist/types/xlsx/xform/list-xform.d.ts

@@ -27,5 +27,6 @@ declare class ListXform extends BaseXform {
     parseText(text: string): void;
     parseClose(name: string): boolean;
     reconcile(model: any[], options: any): void;
+    reset(): void;
 }
 export { ListXform };

package/dist/types/xlsx/xform/sheet/row-xform.d.ts

@@ -23,8 +23,10 @@ declare class RowXform extends BaseXform {
     model: RowModel;
     parser: any;
     private numRowsSeen;
+    private lastCellCol;
     constructor(options?: RowXformOptions);
     get tag(): string;
+    reset(): void;
     prepare(model: RowModel, options: any): void;
     render(xmlStream: any, model?: RowModel, options?: any): void;
     parseOpen(node: any): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cj-tech-master/excelts",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "description": "TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.",
   "private": false,
   "publishConfig": {