Add support for deflate/deflate-raw streams

Author: pimterry

README.md

@@ -61,10 +61,14 @@ Each method accepts a buffer and returns a promise for a buffer.
 
 ## Streaming methods
 
-This library also supports streaming decoding, using web de(compression) streams wherever possible.
+This library also supports streaming encoding and decoding, returning web-standard `TransformStream` instances. This uses native `CompressionStream`/`DecompressionStream` where available (all modern browsers and Node 18+).
 
 * `createGzipStream`
 * `createGunzipStream`
+* `createDeflateStream`
+* `createInflateStream`
+* `createDeflateRawStream`
+* `createInflateRawStream`
 
 ## Browser usage
 

src/index.ts

@@ -146,6 +146,50 @@ export function createGunzipStream(): TransformStream<BufferSource, Uint8Array>
     return getDuplex().toWeb(zlib.createGunzip()) as TransformStream<BufferSource, Uint8Array>;
 }
 
+export function createDeflateStream(): TransformStream<BufferSource, Uint8Array> {
+    // Use native CompressionStream where available:
+    if (typeof CompressionStream !== 'undefined') {
+        return new CompressionStream('deflate');
+    }
+    // Turn zlib node built-in into a web stream if not:
+    return getDuplex().toWeb(zlib.createDeflate()) as TransformStream<BufferSource, Uint8Array>;
+}
+
+export function createInflateStream(): TransformStream<BufferSource, Uint8Array> {
+    // Use native DecompressionStream where available:
+    if (typeof DecompressionStream !== 'undefined') {
+        return new DecompressionStream('deflate');
+    }
+    // Turn zlib node built-in into a web stream if not:
+    return getDuplex().toWeb(zlib.createInflate()) as TransformStream<BufferSource, Uint8Array>;
+}
+
+export function createDeflateRawStream(): TransformStream<BufferSource, Uint8Array> {
+    // Use native CompressionStream where available:
+    if (typeof CompressionStream !== 'undefined') {
+        try {
+            return new CompressionStream('deflate-raw');
+        } catch {
+            // deflate-raw not supported (e.g. Node 18)
+        }
+    }
+    // Turn zlib node built-in into a web stream if not:
+    return getDuplex().toWeb(zlib.createDeflateRaw()) as TransformStream<BufferSource, Uint8Array>;
+}
+
+export function createInflateRawStream(): TransformStream<BufferSource, Uint8Array> {
+    // Use native DecompressionStream where available:
+    if (typeof DecompressionStream !== 'undefined') {
+        try {
+            return new DecompressionStream('deflate-raw');
+        } catch {
+            // deflate-raw not supported (e.g. Node 18)
+        }
+    }
+    // Turn zlib node built-in into a web stream if not:
+    return getDuplex().toWeb(zlib.createInflateRaw()) as TransformStream<BufferSource, Uint8Array>;
+}
+
 // --- Buffer helpers ---
 
 const asBuffer = (input: Buffer | Uint8Array | ArrayBuffer): Buffer => {

test/stream.spec.ts

@@ -5,7 +5,11 @@ const expect = chai.expect;
 
 import {
     createGzipStream,
-    createGunzipStream
+    createGunzipStream,
+    createDeflateStream,
+    createInflateStream,
+    createDeflateRawStream,
+    createInflateRawStream
 } from '../src/index';
 
 // Helper to collect all chunks from a ReadableStream into a single Uint8Array
@@ -121,4 +125,76 @@ describe("Streaming", () => {
             expect(decompressed.toString()).to.equal(repeated);
         });
     });
+
+    describe("Deflate", () => {
+        it('should compress data with deflate stream', async () => {
+            const input = Buffer.from('Hello streaming deflate world!');
+            const inputStream = createReadableStream(input);
+
+            const compressedStream = inputStream.pipeThrough(createDeflateStream());
+            const compressed = await collectStream(compressedStream);
+
+            // Verify the compressed data can be decompressed with zlib
+            const decompressed = zlib.inflateSync(Buffer.from(compressed));
+            expect(decompressed.toString()).to.equal('Hello streaming deflate world!');
+        });
+
+        it('should decompress deflate data with stream', async () => {
+            const original = 'Hello streaming inflate world!';
+            const compressed = zlib.deflateSync(original);
+            const inputStream = createReadableStream(compressed);
+
+            const decompressedStream = inputStream.pipeThrough(createInflateStream());
+            const decompressed = await collectStream(decompressedStream);
+
+            expect(Buffer.from(decompressed).toString()).to.equal(original);
+        });
+
+        it('should handle round-trip compression and decompression', async () => {
+            const original = 'Round-trip deflate streaming test with some repeated data data data data';
+            const inputStream = createReadableStream(Buffer.from(original));
+
+            const compressedStream = inputStream.pipeThrough(createDeflateStream());
+            const decompressedStream = compressedStream.pipeThrough(createInflateStream());
+            const result = await collectStream(decompressedStream);
+
+            expect(Buffer.from(result).toString()).to.equal(original);
+        });
+    });
+
+    describe("Deflate-Raw", () => {
+        it('should compress data with deflate-raw stream', async () => {
+            const input = Buffer.from('Hello streaming deflate-raw world!');
+            const inputStream = createReadableStream(input);
+
+            const compressedStream = inputStream.pipeThrough(createDeflateRawStream());
+            const compressed = await collectStream(compressedStream);
+
+            // Verify the compressed data can be decompressed with zlib
+            const decompressed = zlib.inflateRawSync(Buffer.from(compressed));
+            expect(decompressed.toString()).to.equal('Hello streaming deflate-raw world!');
+        });
+
+        it('should decompress deflate-raw data with stream', async () => {
+            const original = 'Hello streaming inflate-raw world!';
+            const compressed = zlib.deflateRawSync(original);
+            const inputStream = createReadableStream(compressed);
+
+            const decompressedStream = inputStream.pipeThrough(createInflateRawStream());
+            const decompressed = await collectStream(decompressedStream);
+
+            expect(Buffer.from(decompressed).toString()).to.equal(original);
+        });
+
+        it('should handle round-trip compression and decompression', async () => {
+            const original = 'Round-trip deflate-raw streaming test with some repeated data data data data';
+            const inputStream = createReadableStream(Buffer.from(original));
+
+            const compressedStream = inputStream.pipeThrough(createDeflateRawStream());
+            const decompressedStream = compressedStream.pipeThrough(createInflateRawStream());
+            const result = await collectStream(decompressedStream);
+
+            expect(Buffer.from(result).toString()).to.equal(original);
+        });
+    });
 });