@cj-tech-master/excelts 1.4.3 → 1.4.5

package/dist/types/doc/column.d.ts

@@ -1,3 +1,5 @@
+import type { Cell } from "./cell.js";
+import type { Worksheet } from "./worksheet.js";
 interface ColumnDefn {
     header?: any;
     key?: string;
@@ -17,14 +19,14 @@ interface ColumnModel {
     collapsed?: boolean;
 }
 declare class Column {
-    _worksheet: any;
+    _worksheet: Worksheet;
     _number: number;
-    _header: any;
+    _header: string | string[] | undefined;
     _key: string | undefined;
     width?: number;
     _hidden: boolean | undefined;
     _outlineLevel: number | undefined;
-    style: any;
+    style: Record<string, unknown>;
     constructor(worksheet: any, number: number, defn?: any);
     get number(): number;
     get worksheet(): any;
@@ -46,7 +48,9 @@ declare class Column {
     equivalentTo(other: Column): boolean;
     get isDefault(): boolean;
     get headerCount(): number;
-    eachCell(options: any, iteratee?: any): void;
+    eachCell(options: {
+        includeEmpty?: boolean;
+    } | ((cell: Cell, rowNumber: number) => void), iteratee?: (cell: Cell, rowNumber: number) => void): void;
     get values(): any[];
     set values(v: any[]);
     _applyStyle(name: string, value: any): any;

package/dist/types/doc/row.d.ts

@@ -1,3 +1,4 @@
+import { Cell } from "./cell.js";
 import type { Worksheet } from "./worksheet.js";
 interface CellAddress {
     address: string;
@@ -26,22 +27,22 @@ interface EachCellOptions {
 declare class Row {
     _worksheet: Worksheet;
     _number: number;
-    _cells: any[];
-    style: any;
+    _cells: (Cell | undefined)[];
+    style: Record<string, unknown>;
     _hidden?: boolean;
     _outlineLevel?: number;
     height?: number;
     constructor(worksheet: any, number: number);
     get number(): number;
-    get worksheet(): any;
+    get worksheet(): Worksheet;
     commit(): void;
     destroy(): void;
-    findCell(colNumber: number): any;
-    getCellEx(address: CellAddress): any;
-    getCell(col: string | number): any;
+    findCell(colNumber: number): Cell | undefined;
+    getCellEx(address: CellAddress): Cell;
+    getCell(col: string | number): Cell;
     splice(start: number, count: number, ...inserts: any[]): void;
-    eachCell(iteratee: (cell: any, colNumber: number) => void): void;
-    eachCell(options: EachCellOptions, iteratee: (cell: any, colNumber: number) => void): void;
+    eachCell(iteratee: (cell: Cell, colNumber: number) => void): void;
+    eachCell(options: EachCellOptions, iteratee: (cell: Cell, colNumber: number) => void): void;
     addPageBreak(lft?: number, rght?: number): void;
     get values(): any[];
     set values(value: any[] | {

package/dist/types/doc/worksheet.d.ts

@@ -147,8 +147,8 @@ declare class Worksheet {
     _copyStyle(src: number, dest: number, styleEmpty?: boolean): void;
     duplicateRow(rowNum: number, count: number, insert?: boolean): void;
     spliceRows(start: number, count: number, ...inserts: any[]): void;
-    eachRow(iteratee: (row: any, rowNumber: number) => void): void;
-    eachRow(options: EachRowOptions, iteratee: (row: any, rowNumber: number) => void): void;
+    eachRow(iteratee: (row: Row, rowNumber: number) => void): void;
+    eachRow(options: EachRowOptions, iteratee: (row: Row, rowNumber: number) => void): void;
     getSheetValues(): any[];
     findCell(r: number | string, c?: number): any;
     getCell(r: number | string, c?: number): any;

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.3",
+  "version": "1.4.5",
   "description": "TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.",
   "private": false,
   "publishConfig": {
@@ -107,9 +107,9 @@
   "devDependencies": {
     "@eslint/js": "^9.39.1",
     "@oxc-node/core": "^0.0.35",
-    "@types/node": "^24.10.1",
-    "@typescript-eslint/eslint-plugin": "^8.48.1",
-    "@typescript-eslint/parser": "^8.48.1",
+    "@types/node": "^25.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.49.0",
+    "@typescript-eslint/parser": "^8.49.0",
     "@typescript/native-preview": "^7.0.0-dev.20251208.1",
     "@vitest/browser": "^4.0.15",
     "@vitest/browser-playwright": "^4.0.15",
@@ -120,22 +120,22 @@
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import-x": "^4.16.1",
-    "eslint-plugin-oxlint": "^1.31.0",
+    "eslint-plugin-oxlint": "^1.32.0",
     "eslint-plugin-unused-imports": "^4.3.0",
     "express": "^5.2.1",
     "fast-xml-parser": "^5.3.2",
     "husky": "^9.1.7",
     "node-stdlib-browser": "^1.3.1",
     "nodemon": "^3.1.11",
-    "oxlint": "^1.31.0",
+    "oxlint": "^1.32.0",
     "playwright": "^1.57.0",
     "prettier": "^3.7.4",
     "rimraf": "^6.1.2",
-    "rolldown": "^1.0.0-beta.53",
+    "rolldown": "^1.0.0-beta.54",
     "rollup-plugin-visualizer": "^6.0.5",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.48.1",
+    "typescript-eslint": "^8.49.0",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^4.0.15"
   },