@cj-tech-master/excelts 6.1.1 → 6.1.2

package/dist/types/modules/archive/compression/deflate-fallback.d.ts

@@ -28,10 +28,11 @@ export declare function inflateRaw(data: Uint8Array): Uint8Array;
  */
 export declare function deflateRawStore(data: Uint8Array): Uint8Array;
 /**
- * Compress data using DEFLATE with fixed Huffman codes
+ * Compress data using DEFLATE with fixed Huffman codes.
  *
- * This provides real compression using LZ77 + fixed Huffman codes.
- * Not as efficient as full DEFLATE but much better than STORE mode.
+ * Uses LZ77 with hash chains and lazy matching for significantly better
+ * compression than a single-entry hash table. The algorithm is modelled
+ * after zlib's "fast" and "slow" deflate strategies.
  *
  * @param data - Data to compress
  * @returns Compressed data in deflate-raw format
@@ -44,7 +45,10 @@ export declare function deflateRawCompressed(data: Uint8Array): Uint8Array;
  * maintains state across multiple `write()` calls:
  *
  *  - **LZ77 sliding window**: back-references can span across chunks.
- *  - **Hash table**: match positions persist across chunks.
+ *  - **Hash chains**: match positions persist across chunks with typed-array
+ *    hash tables for fast lookup.
+ *  - **Lazy matching**: each match is compared with the next position's match
+ *    to pick the longer one.
  *  - **Bit writer**: bit position is preserved, so consecutive blocks form
  *    a single valid DEFLATE bit-stream without alignment issues.
  *
@@ -57,13 +61,18 @@ export declare function deflateRawCompressed(data: Uint8Array): Uint8Array;
  */
 export declare class SyncDeflater {
     private _output;
-    private _hashTable;
+    private _head;
+    private _prev;
     /** Sliding window: the last WINDOW_SIZE bytes of uncompressed data. */
     private _window;
     /** Number of valid bytes currently in the window. */
     private _windowLen;
     /** Total bytes written so far (monotonically increasing; used for hash offsets). */
     private _totalIn;
+    private _hasPrevMatch;
+    private _prevMatchLen;
+    private _prevMatchDist;
+    private _prevLiteral;
     /**
      * Compress a chunk and return the compressed bytes produced so far.
      * The output is a valid prefix of a DEFLATE stream (one or more non-final blocks).

package/dist/types/modules/archive/compression/streaming-compress.d.ts

@@ -46,20 +46,32 @@ export declare function createZlibStream(options?: StreamCompressOptions): ZlibS
  */
 export declare function createUnzlibStream(_options?: StreamCompressOptions): UnzlibStream;
 /**
- * Node.js synchronous deflater using `deflateRawSync` with `Z_SYNC_FLUSH`.
+ * Node.js synchronous deflater that batches small writes for better
+ * compression.
  *
- * Each `write()` compresses the chunk independently (no cross-chunk dictionary)
- * but uses `Z_SYNC_FLUSH` so the output is byte-aligned and can be concatenated
- * into a single valid DEFLATE stream. The final `finish()` emits a proper
- * BFINAL=1 block.
+ * Previous implementation compressed each `write()` call independently
+ * with `deflateRawSync()`, creating a fresh zlib context every time.
+ * For streaming workloads that push many small chunks (e.g. WorkbookWriter
+ * writing one row at a time), this destroyed the LZ77 dictionary between
+ * chunks and caused compression ratios to drop from ~82% to ~58%.
  *
- * This is fast (native C zlib) and produces valid output on all Node.js versions
- * (20+). The trade-off is ~2% worse compression ratio vs a stateful context,
- * which is acceptable for streaming where memory is the priority.
+ * The new implementation accumulates incoming data into an internal buffer
+ * and only calls `deflateRawSync()` when the buffer reaches 64 KB (or on
+ * `finish()`). Each batch is still compressed independently, but 64 KB
+ * is enough for zlib to build a good dictionary — the compression ratio
+ * is within ~1% of a single-shot compression of the entire input.
+ *
+ * The trade-off is slightly higher latency (compressed output is not
+ * returned byte-for-byte immediately), but this is acceptable because
+ * the ZIP writer buffers output anyway and the streaming contract only
+ * requires data to flow *eventually*, not after every single write.
  */
 export declare class SyncDeflater implements SyncDeflaterLike {
     private _level;
+    private _pending;
+    private _pendingSize;
     constructor(level?: number);
     write(data: Uint8Array): Uint8Array;
     finish(): Uint8Array;
+    private _flushBatch;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cj-tech-master/excelts",
-  "version": "6.1.1",
+  "version": "6.1.2",
   "description": "TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -197,7 +197,7 @@
     "benchmark:compress": "rimraf dist && npm run build && node --expose-gc scripts/benchmark-compress.ts",
     "build:esm": "tsc --project tsconfig.esm.json && node scripts/fix-esm-imports.ts",
     "build:cjs": "tsc --project tsconfig.cjs.json && node scripts/fix-cjs-imports.ts",
-    "build:browser": "tsc --project tsconfig.browser.json && node scripts/fix-esm-imports.ts --dist dist/browser && node scripts/fix-browser-imports.ts --dir dist/browser",
+    "build:browser": "tsc --project tsconfig.browser.json && node scripts/fix-esm-imports.ts --dist dist/browser --types dist/browser && node scripts/fix-browser-imports.ts --dir dist/browser",
     "build:browser:bundle": "rolldown -c rolldown.config.ts",
     "preversion": "npm run lint && npm run type && npm run build && npm run test"
   }