zstd-wasm-vn 1.0.0 → 1.2.0

package/README.md

@@ -1,21 +1,149 @@
 # zstd-wasm-vn
 [![npm](https://img.shields.io/npm/v/zstd-wasm-vn)](https://www.npmjs.com/package/zstd-wasm-vn)
 
-## Installing `wasm-bindgen-cli`
+## Browser
 
-```sh
-cargo install wasm-bindgen-cli
-cargo install wasm-opt --locked
+### Bulk (One-shot)
+
+For simple, full-buffer compression/decompression.
+
+```js
+import init, { Zstd } from 'zstd-wasm-vn/web';
+
+await init();
+
+const str = "Compresses data using Zstandard compression";
+
+const data = new TextEncoder().encode(str);
+const compressed = Zstd.compress(data, 6);
+const decompressed = Zstd.decompress(compressed);
+
+console.log("Original String: ", str);
+console.log("Decompressed String: ", new TextDecoder().decode(decompressed));
 ```
 
-## Building via `wasm-bindgen-cli`
+### Streaming
+
+For processing large files read from a drag-and-drop event or an HTTP fetch stream.
+
+```js
+import init, { ZstdCompressor, ZstdDecompressor } from 'zstd-wasm-vn/web';
+
+await init();
 
-```sh
-chmod +x build.sh && ./build.sh
+// --- Decompression Stream Example (Browser File Input) ---
+// Assuming you have the full compressed Uint8Array (e.g., loaded from a file input)
+async function streamDecompress(compressedData) {
+    const decompressor = new ZstdDecompressor(compressedData);
+    const CHUNK_SIZE = 1024 * 128; // Request 128KB chunks
+
+    const decompressedChunks = [];
+    
+    while (true) {
+        // 1. Decompress a chunk
+        const chunk = decompressor.decompress_chunk(CHUNK_SIZE);
+        
+        // 2. Stop condition
+        if (chunk.length === 0) {
+            break;
+        }
+
+        // 3. Collect the chunk for processing
+        decompressedChunks.push(chunk);
+        
+        // Optionally, yield or process the chunk here
+        // console.log(`Processed ${chunk.length} bytes`);
+    }
+
+    // Combine all chunks into a final array
+    const totalLength = decompressedChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const finalData = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of decompressedChunks) {
+        finalData.set(chunk, offset);
+        offset += chunk.length;
+    }
+    
+    console.log(`Total decompressed bytes: ${finalData.length}`);
+    return finalData;
+}
+
+// Example usage with placeholder compressed data
+// const compressedFileBytes = await fetch('data.zst').then(r => r.arrayBuffer()).then(b => new Uint8Array(b));
+// streamDecompress(compressedFileBytes);
 ```
 
-### Publish to NPM
+## Node.js
+
+### Bulk (One-shot)
+
+For simple, full-buffer compression/decompression.
+
+```js
+const { randomBytes } = require('node:crypto');
+const { Zstd } = require('zstd-wasm-vn/nodejs');
+
+// Generate 32 bytes of random data
+const data = randomBytes(32); 
+
+// Compress the entire buffer at level 6
+const compressed = Zstd.compress(data, 6);
+
+// Decompress the entire buffer
+const decompressed = Zstd.decompress(compressed);
+
+// Verify
+console.log('Match:', data.equals(decompressed));
+```
+
+### Streaming
+
+For handling large files or continuous network data without loading the entire content into memory.
+
+```js
+const { ZstdCompressor, ZstdDecompressor } = require('zstd-wasm-vn/nodejs');
+const { createReadStream, createWriteStream } = require('node:fs');
+
+// --- Compression Stream Example ---
+
+// 1. Create a stream compressor instance (level 3)
+const compressor = new ZstdCompressor(3);
+
+createReadStream('large_input.txt', { highWaterMark: 64 * 1024 }) // Read 64KB chunks
+    .on('data', (chunk) => {
+        // 2. Compress each chunk
+        compressor.compress_chunk(chunk);
+    })
+    .on('end', () => {
+        // 3. Finalize and get the full compressed output
+        const compressedData = compressor.finalize(); 
+        console.log(`Compressed size: ${compressedData.length} bytes`);
+        // Write the result to a file (optional)
+        // createWriteStream('output.zst').write(compressedData);
+    });
+
+// --- Decompression Stream Example ---
+
+// Assuming 'compressed_data' is a Buffer containing the Zstd file content
+const compressedData = /* ... load compressed data Buffer here ... */;
+const decompressor = new ZstdDecompressor(compressedData);
+
+let totalDecompressedSize = 0;
+const CHUNK_SIZE = 1024 * 64; // Request 64KB uncompressed chunks
+
+while (true) {
+    // 1. Decompress a chunk
+    const chunk = decompressor.decompress_chunk(CHUNK_SIZE);
+
+    // 2. Stop condition (empty chunk means EOF)
+    if (chunk.length === 0) {
+        break;
+    }
+
+    // 3. Process/write the uncompressed chunk
+    // createWriteStream('decompressed.txt').write(chunk);
+    totalDecompressedSize += chunk.length;
+}
 
-```sh
-cd pkg && npm publish
+console.log(`Total decompressed size: ${totalDecompressedSize} bytes`);
 ```

package/bundler/zstd_wasm_vn.d.ts

@@ -1,5 +1,41 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * Compresses data using Zstandard compression
+ *
+ * # Arguments
+ *
+ * * `data` - Input data to compress
+ * * `level` - Compression level (1-22, default 6). Higher = better compression but slower
+ */
+export function compress(data: Uint8Array, level?: number | null): Uint8Array;
+/**
+ * Compresses data using Zstandard compression with a dictionary
+ *
+ * # Arguments
+ *
+ * * `data` - Input data to compress
+ * * `dict` - The compression dictionary
+ * * `level` - Compression level (1-22, default 6). Higher = better compression but slower
+ */
+export function compress_with_dict(data: Uint8Array, dict: Uint8Array, level?: number | null): Uint8Array;
+/**
+ * Decompresses Zstandard compressed data
+ *
+ * # Arguments
+ *
+ * * `compressed_data` - Zstandard compressed data
+ */
+export function decompress(compressed_data: Uint8Array): Uint8Array;
+/**
+ * Decompresses Zstandard compressed data using a dictionary
+ *
+ * # Arguments
+ *
+ * * `data` - Zstandard compressed data
+ * * `dict` - The decompression dictionary (must match the compression dictionary)
+ */
+export function decompress_with_dict(data: Uint8Array, dict: Uint8Array): Uint8Array;
 /**
  * ZSTD compression and decompression for WebAssembly
  */
@@ -7,23 +43,10 @@ export class Zstd {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  /**
-   * Compresses data using Zstandard compression
-   *
-   * # Arguments
-   *
-   * * `data` - Input data to compress
-   * * `level` - Compression level (1-22, default 3). Higher = better compression but slower
-   */
   static compress(data: Uint8Array, level?: number | null): Uint8Array;
-  /**
-   * Decompresses Zstandard compressed data
-   *
-   * # Arguments
-   *
-   * * `compressed_data` - Zstandard compressed data
-   */
+  static compress_with_dict(data: Uint8Array, dict: Uint8Array, level?: number | null): Uint8Array;
   static decompress(compressed_data: Uint8Array): Uint8Array;
+  static decompress_with_dict(compressed_data: Uint8Array, dict: Uint8Array): Uint8Array;
   /**
    * Returns the recommended default compression level
    */
@@ -50,6 +73,7 @@ export class Zstd {
   static spaceSavings(original_size: number, compressed_size: number): number;
 }
 /**
+ * ==================================== [Streaming] ====================================
  * Streaming compression for large data
  */
 export class ZstdCompressor {
@@ -67,10 +91,6 @@ export class ZstdCompressor {
    * Finalizes compression and returns the compressed data
    */
   finalize(): Uint8Array;
-  /**
-   * Gets the current compression level
-   */
-  readonly level: number;
 }
 /**
  * Streaming decompression for large data
@@ -87,7 +107,7 @@ export class ZstdDecompressor {
    */
   decompress_chunk(max_output_size: number): Uint8Array;
   /**
-   * Decompresses all remaining data
+   * Decompresses all remaining data and consumes the decoder.
    */
   finalize(): Uint8Array;
 }

package/bundler/zstd_wasm_vn_bg.js

@@ -57,6 +57,101 @@ function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
+/**
+ * Compresses data using Zstandard compression
+ *
+ * # Arguments
+ *
+ * * `data` - Input data to compress
+ * * `level` - Compression level (1-22, default 6). Higher = better compression but slower
+ * @param {Uint8Array} data
+ * @param {number | null} [level]
+ * @returns {Uint8Array}
+ */
+export function compress(data, level) {
+    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.compress(ptr0, len0, isLikeNone(level) ? 0x100000001 : (level) >> 0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Compresses data using Zstandard compression with a dictionary
+ *
+ * # Arguments
+ *
+ * * `data` - Input data to compress
+ * * `dict` - The compression dictionary
+ * * `level` - Compression level (1-22, default 6). Higher = better compression but slower
+ * @param {Uint8Array} data
+ * @param {Uint8Array} dict
+ * @param {number | null} [level]
+ * @returns {Uint8Array}
+ */
+export function compress_with_dict(data, dict, level) {
+    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(dict, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.compress_with_dict(ptr0, len0, ptr1, len1, isLikeNone(level) ? 0x100000001 : (level) >> 0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+
+/**
+ * Decompresses Zstandard compressed data
+ *
+ * # Arguments
+ *
+ * * `compressed_data` - Zstandard compressed data
+ * @param {Uint8Array} compressed_data
+ * @returns {Uint8Array}
+ */
+export function decompress(compressed_data) {
+    const ptr0 = passArray8ToWasm0(compressed_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.decompress(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Decompresses Zstandard compressed data using a dictionary
+ *
+ * # Arguments
+ *
+ * * `data` - Zstandard compressed data
+ * * `dict` - The decompression dictionary (must match the compression dictionary)
+ * @param {Uint8Array} data
+ * @param {Uint8Array} dict
+ * @returns {Uint8Array}
+ */
+export function decompress_with_dict(data, dict) {
+    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(dict, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.decompress_with_dict(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
 
 const ZstdFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -78,12 +173,6 @@ export class Zstd {
         wasm.__wbg_zstd_free(ptr, 0);
     }
     /**
-     * Compresses data using Zstandard compression
-     *
-     * # Arguments
-     *
-     * * `data` - Input data to compress
-     * * `level` - Compression level (1-22, default 3). Higher = better compression but slower
      * @param {Uint8Array} data
      * @param {number | null} [level]
      * @returns {Uint8Array}
@@ -100,11 +189,25 @@ export class Zstd {
         return v2;
     }
     /**
-     * Decompresses Zstandard compressed data
-     *
-     * # Arguments
-     *
-     * * `compressed_data` - Zstandard compressed data
+     * @param {Uint8Array} data
+     * @param {Uint8Array} dict
+     * @param {number | null} [level]
+     * @returns {Uint8Array}
+     */
+    static compress_with_dict(data, dict, level) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(dict, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.zstd_compress_with_dict(ptr0, len0, ptr1, len1, isLikeNone(level) ? 0x100000001 : (level) >> 0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v3;
+    }
+    /**
      * @param {Uint8Array} compressed_data
      * @returns {Uint8Array}
      */
@@ -119,6 +222,24 @@ export class Zstd {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v2;
     }
+    /**
+     * @param {Uint8Array} compressed_data
+     * @param {Uint8Array} dict
+     * @returns {Uint8Array}
+     */
+    static decompress_with_dict(compressed_data, dict) {
+        const ptr0 = passArray8ToWasm0(compressed_data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(dict, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.zstd_decompress_with_dict(ptr0, len0, ptr1, len1);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v3;
+    }
     /**
      * Returns the recommended default compression level
      * @returns {number}
@@ -179,6 +300,7 @@ const ZstdCompressorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_zstdcompressor_free(ptr >>> 0, 1));
 /**
+ * ==================================== [Streaming] ====================================
  * Streaming compression for large data
  */
 export class ZstdCompressor {
@@ -232,14 +354,6 @@ export class ZstdCompressor {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
-    /**
-     * Gets the current compression level
-     * @returns {number}
-     */
-    get level() {
-        const ret = wasm.zstdcompressor_level(this.__wbg_ptr);
-        return ret;
-    }
 }
 if (Symbol.dispose) ZstdCompressor.prototype[Symbol.dispose] = ZstdCompressor.prototype.free;
 
@@ -292,7 +406,7 @@ export class ZstdDecompressor {
         return v1;
     }
     /**
-     * Decompresses all remaining data
+     * Decompresses all remaining data and consumes the decoder.
      * @returns {Uint8Array}
      */
     finalize() {

package/bundler/zstd_wasm_vn_bg.wasm.d.ts

@@ -1,9 +1,15 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const compress: (a: number, b: number, c: number) => [number, number, number, number];
+export const compress_with_dict: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+export const decompress: (a: number, b: number) => [number, number, number, number];
+export const decompress_with_dict: (a: number, b: number, c: number, d: number) => [number, number, number, number];
 export const __wbg_zstd_free: (a: number, b: number) => void;
 export const zstd_compress: (a: number, b: number, c: number) => [number, number, number, number];
+export const zstd_compress_with_dict: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
 export const zstd_decompress: (a: number, b: number) => [number, number, number, number];
+export const zstd_decompress_with_dict: (a: number, b: number, c: number, d: number) => [number, number, number, number];
 export const zstd_defaultCompressionLevel: () => number;
 export const zstd_minCompressionLevel: () => number;
 export const zstd_maxCompressionLevel: () => number;
@@ -14,7 +20,6 @@ export const __wbg_zstdcompressor_free: (a: number, b: number) => void;
 export const zstdcompressor_new: (a: number) => [number, number, number];
 export const zstdcompressor_compress_chunk: (a: number, b: number, c: number) => [number, number];
 export const zstdcompressor_finalize: (a: number) => [number, number, number, number];
-export const zstdcompressor_level: (a: number) => number;
 export const __wbg_zstddecompressor_free: (a: number, b: number) => void;
 export const zstddecompressor_new: (a: number, b: number) => [number, number, number];
 export const zstddecompressor_decompress_chunk: (a: number, b: number) => [number, number, number, number];

package/deno/zstd_wasm_vn.d.ts

@@ -1,5 +1,41 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * Compresses data using Zstandard compression
+ *
+ * # Arguments
+ *
+ * * `data` - Input data to compress
+ * * `level` - Compression level (1-22, default 6). Higher = better compression but slower
+ */
+export function compress(data: Uint8Array, level?: number | null): Uint8Array;
+/**
+ * Compresses data using Zstandard compression with a dictionary
+ *
+ * # Arguments
+ *
+ * * `data` - Input data to compress
+ * * `dict` - The compression dictionary
+ * * `level` - Compression level (1-22, default 6). Higher = better compression but slower
+ */
+export function compress_with_dict(data: Uint8Array, dict: Uint8Array, level?: number | null): Uint8Array;
+/**
+ * Decompresses Zstandard compressed data
+ *
+ * # Arguments
+ *
+ * * `compressed_data` - Zstandard compressed data
+ */
+export function decompress(compressed_data: Uint8Array): Uint8Array;
+/**
+ * Decompresses Zstandard compressed data using a dictionary
+ *
+ * # Arguments
+ *
+ * * `data` - Zstandard compressed data
+ * * `dict` - The decompression dictionary (must match the compression dictionary)
+ */
+export function decompress_with_dict(data: Uint8Array, dict: Uint8Array): Uint8Array;
 /**
  * ZSTD compression and decompression for WebAssembly
  */
@@ -7,23 +43,10 @@ export class Zstd {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  /**
-   * Compresses data using Zstandard compression
-   *
-   * # Arguments
-   *
-   * * `data` - Input data to compress
-   * * `level` - Compression level (1-22, default 3). Higher = better compression but slower
-   */
   static compress(data: Uint8Array, level?: number | null): Uint8Array;
-  /**
-   * Decompresses Zstandard compressed data
-   *
-   * # Arguments
-   *
-   * * `compressed_data` - Zstandard compressed data
-   */
+  static compress_with_dict(data: Uint8Array, dict: Uint8Array, level?: number | null): Uint8Array;
   static decompress(compressed_data: Uint8Array): Uint8Array;
+  static decompress_with_dict(compressed_data: Uint8Array, dict: Uint8Array): Uint8Array;
   /**
    * Returns the recommended default compression level
    */
@@ -50,6 +73,7 @@ export class Zstd {
   static spaceSavings(original_size: number, compressed_size: number): number;
 }
 /**
+ * ==================================== [Streaming] ====================================
  * Streaming compression for large data
  */
 export class ZstdCompressor {
@@ -67,10 +91,6 @@ export class ZstdCompressor {
    * Finalizes compression and returns the compressed data
    */
   finalize(): Uint8Array;
-  /**
-   * Gets the current compression level
-   */
-  readonly level: number;
 }
 /**
  * Streaming decompression for large data
@@ -87,7 +107,7 @@ export class ZstdDecompressor {
    */
   decompress_chunk(max_output_size: number): Uint8Array;
   /**
-   * Decompresses all remaining data
+   * Decompresses all remaining data and consumes the decoder.
    */
   finalize(): Uint8Array;
 }