npm - compress-jpeg - Versions diffs - 1.0.5 → 1.1.0 - Mend

compress-jpeg 1.0.5 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/LICENSE CHANGED Viewed

@@ -1,7 +1,7 @@
-Copyright © 2025 Ganemede Labs
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Copyright © 2025 Ganemede Labs
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md CHANGED Viewed

@@ -1,118 +1,82 @@
-# Compress JPEG
-![npm](https://img.shields.io/npm/v/compress-jpeg)
-![npm](https://img.shields.io/npm/dw/compress-jpeg)
-![License](https://img.shields.io/npm/l/compress-jpeg)
-A high-performance **WASM** module that simulates JPEG compression artifacts on raw image data, designed to be used easily in JavaScript or TypeScript environments via an npm package.
-## 📋 Table of Contents
--   [Features](#-features)
--   [Installation](#-installation)
--   [Usage](#-usage)
--   [License](#-license)
--   [Contact](#-contact)
-## ✨ Features
--   **Fast** and **portable** through WebAssembly.
--   Supports customizable **compression quality**.
--   Accepts and returns raw **RGBA pixel data**.
--   Pure Rust core with zero dependencies beyond `wasm-bindgen`.
-## 🔧 Installation
-Install the package via npm:
-```bash
-npm install compress-jpeg
-```
-## 🚀 Usage
-Here's an example of how to integrate **compress-jpeg** with plain TypeScript in the browser. This snippet shows:
-1. Loading an image file via an HTML `<input>`.
-2. Drawing it to an off-screen canvas and extracting pixel data.
-3. Passing the data to the WASM function.
-4. Rendering the compressed output back onto a visible canvas.
-```html
-<!-- index.html -->
-<!DOCTYPE html>
-<html lang="en">
-    <head>
-        <meta charset="UTF-8" />
-        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-        <title>WASM JPEG Simulator Demo</title>
-    </head>
-    <body>
-        <!-- File input and canvases -->
-        <input id="fileInput" type="file" accept="image/*" />
-        <canvas id="originalCanvas" style="display:none;"></canvas>
-        <canvas id="processedCanvas"></canvas>
-        <script type="module" src="main.ts"></script>
-    </body>
-</html>
-```
-```typescript
-// main.ts
-import init, { ImageData as RustImageData, compress_jpeg } from "compress-jpeg";
-const fileInput = document.getElementById("fileInput") as HTMLInputElement;
-const originalCanvas = document.getElementById("originalCanvas") as HTMLCanvasElement;
-const processedCanvas = document.getElementById("processedCanvas") as HTMLCanvasElement;
-fileInput.addEventListener("change", async () => {
-    const file = fileInput.files?.[0];
-    if (!file) return;
-    // Initialize the WASM module with an explicit path
-    await init("/compress_jpeg_bg.wasm");
-    // Load image into an off-screen canvas
-    const img = new Image();
-    const reader = new FileReader();
-    reader.onload = () => {
-        img.src = reader.result as string;
-    };
-    reader.readAsDataURL(file);
-    img.onload = () => {
-        originalCanvas.width = img.width;
-        originalCanvas.height = img.height;
-        const ctx = originalCanvas.getContext("2d")!;
-        ctx.drawImage(img, 0, 0);
-        // Extract raw pixel data
-        const browserImageData = ctx.getImageData(0, 0, img.width, img.height);
-        const rustInput = new RustImageData(
-            browserImageData.width,
-            browserImageData.height,
-            new Uint8ClampedArray(browserImageData.data)
-        );
-        // Simulate JPEG compression at quality=30
-        const output = compress_jpeg(rustInput, 30);
-        // Convert back to browser ImageData
-        const processedData = new ImageData(output.data(), output.width(), output.height());
-        // Draw on visible canvas
-        processedCanvas.width = output.width();
-        processedCanvas.height = output.height();
-        processedCanvas.getContext("2d")!.putImageData(processedData, 0, 0);
-    };
-});
-```
-## 📜 License
-This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
-## 📧 Contact
-For inquiries or more information, you can reach out to us at [ganemedelabs@gmail.com](mailto:ganemedelabs@gmail.com).
+# Compress JPEG
+![Version](https://img.shields.io/npm/v/compress-jpeg)
+![Downloads](https://img.shields.io/npm/dw/compress-jpeg)
+![License](https://img.shields.io/npm/l/compress-jpeg)
+A lightweight WebAssembly-powered JPEG-like compressor written in Rust, exposed as an easy-to-use JavaScript API. This package performs a simplified JPEG pipeline entirely in WASM, including:
+-   RGB → YCbCr conversion
+-   4:2:0 chroma subsampling
+-   8×8 DCT + quantization
+-   Inverse DCT
+-   Reconstruction to RGBA
+The output is not a `.jpg` file, but a visually compressed `ImageData` that simulates JPEG compression artifacts—including blockiness, color loss, and ringing—directly in the browser.
+## 📋 Table of Contents
+-   [Features](#-features)
+-   [Installation](#-installation)
+-   [Usage](#-usage)
+-   [License](#-license)
+-   [Contact](#-contact)
+## ✨ Features
+-   Fast WebAssembly image compression (Rust + wasm-bindgen)
+-   Fully controllable compression strength (`0.0 → 1.0`)
+-   Implements a full JPEG-style DCT/IDCT pipeline
+-   Produces visible JPEG artifacts at higher compression levels
+-   Works directly with Canvas `ImageData`
+-   Zero dependencies — tiny package size
+-   Browser-friendly and easy to use
+-   Simple API: `compress_jpeg(imageData: ImageData, compression: number): ImageData`
+## 🔧 Installation
+```bash
+npm install compress-jpeg
+# or
+yarn add compress-jpeg
+```
+## 🚀 Usage
+```typescript
+import init, { compress_jpeg } from "compress-jpeg";
+async function run() {
+    await init(); // initialize WASM module
+    const canvas = document.getElementById("my-canvas") as HTMLCanvasElement;
+    const ctx = canvas.getContext("2d")!;
+    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+    /**
+     * Compression strength (0.0 → 1.0)
+     *
+     * - 0.0 = no compression (highest quality)
+     * - 1.0 = strongest compression (lowest quality, heavy artifacts)
+     *
+     * Recommended ranges:
+     * - 0.7–1.0 → strong blockiness / heavy JPEG artifacts
+     * - 0.3–0.7 → medium compression
+     * - 0.0–0.3 → light compression / near-lossless
+     */
+    const compression = 0.4;
+    const output = compress_jpeg(imageData, compression);
+    // Draw result onto canvas
+    ctx.putImageData(output, 0, 0);
+}
+```
+## 📜 License
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+## 📧 Contact
+For inquiries or more information, you can reach out to us at [ganemedelabs@gmail.com](mailto:ganemedelabs@gmail.com).

package/compress_jpeg.d.ts CHANGED Viewed

@@ -1,30 +1,35 @@
 /* tslint:disable */
 /* eslint-disable */
-export function compress_jpeg(image_data: ImageData, quality: number): ImageData;
-export class ImageData {
-  free(): void;
-  constructor(width: number, height: number, data: Uint8ClampedArray);
-  width(): number;
-  height(): number;
-  data(): Uint8ClampedArray;
-}
+/**
+ * Compress an ImageData using a simplified JPEG-style pipeline.
+ *
+ * **Parameters:**
+ * - `image_data`: The RGBA ImageData to compress.
+ * - `compression`: A value from 0.0–1.0:
+ *     - 0.0 = no compression (highest quality)
+ *     - 1.0 = strongest compression (lowest quality)
+ *
+ * **Returns:**
+ * A new `ImageData` object containing the visually compressed pixels.
+ */
+export function compress_jpeg(image_data: ImageData, compression: number): ImageData;
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
-  readonly __wbg_imagedata_free: (a: number, b: number) => void;
-  readonly imagedata_new: (a: number, b: number, c: any) => number;
-  readonly imagedata_width: (a: number) => number;
-  readonly imagedata_height: (a: number) => number;
-  readonly imagedata_data: (a: number) => any;
-  readonly compress_jpeg: (a: number, b: number) => [number, number, number];
-  readonly __wbindgen_export_0: WebAssembly.Table;
+  readonly compress_jpeg: (a: any, b: number) => [number, number, number];
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_externrefs: WebAssembly.Table;
   readonly __externref_table_dealloc: (a: number) => void;
   readonly __wbindgen_start: () => void;
 }
 export type SyncInitInput = BufferSource | WebAssembly.Module;
 /**
 * Instantiates the given `module`, which can either be bytes or
 * a precompiled `WebAssembly.Module`.

package/compress_jpeg.js CHANGED Viewed

@@ -1,11 +1,30 @@
 let wasm;
-const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
-if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+function getClampedArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ClampedArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
-let cachedUint8ArrayMemory0 = null;
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+let cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
     if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
         cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
@@ -13,104 +32,86 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+let cachedUint8ClampedArrayMemory0 = null;
+function getUint8ClampedArrayMemory0() {
+    if (cachedUint8ClampedArrayMemory0 === null || cachedUint8ClampedArrayMemory0.byteLength === 0) {
+        cachedUint8ClampedArrayMemory0 = new Uint8ClampedArray(wasm.memory.buffer);
+    }
+    return cachedUint8ClampedArrayMemory0;
 }
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
     }
 }
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
 function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_export_0.get(idx);
+    const value = wasm.__wbindgen_externrefs.get(idx);
     wasm.__externref_table_dealloc(idx);
     return value;
 }
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+let WASM_VECTOR_LEN = 0;
 /**
+ * Compress an ImageData using a simplified JPEG-style pipeline.
+ *
+ * **Parameters:**
+ * - `image_data`: The RGBA ImageData to compress.
+ * - `compression`: A value from 0.0–1.0:
+ *     - 0.0 = no compression (highest quality)
+ *     - 1.0 = strongest compression (lowest quality)
+ *
+ * **Returns:**
+ * A new `ImageData` object containing the visually compressed pixels.
  * @param {ImageData} image_data
- * @param {number} quality
+ * @param {number} compression
  * @returns {ImageData}
  */
-export function compress_jpeg(image_data, quality) {
-    _assertClass(image_data, ImageData);
-    var ptr0 = image_data.__destroy_into_raw();
-    const ret = wasm.compress_jpeg(ptr0, quality);
+export function compress_jpeg(image_data, compression) {
+    const ret = wasm.compress_jpeg(image_data, compression);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return ImageData.__wrap(ret[0]);
+    return takeFromExternrefTable0(ret[0]);
 }
-const ImageDataFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_imagedata_free(ptr >>> 0, 1));
-export class ImageData {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(ImageData.prototype);
-        obj.__wbg_ptr = ptr;
-        ImageDataFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        ImageDataFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_imagedata_free(ptr, 0);
-    }
-    /**
-     * @param {number} width
-     * @param {number} height
-     * @param {Uint8ClampedArray} data
-     */
-    constructor(width, height, data) {
-        const ret = wasm.imagedata_new(width, height, data);
-        this.__wbg_ptr = ret >>> 0;
-        ImageDataFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @returns {number}
-     */
-    width() {
-        const ret = wasm.imagedata_width(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    height() {
-        const ret = wasm.imagedata_height(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {Uint8ClampedArray}
-     */
-    data() {
-        const ret = wasm.imagedata_data(this.__wbg_ptr);
-        return ret;
-    }
-}
+const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
 async function __wbg_load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
         if (typeof WebAssembly.instantiateStreaming === 'function') {
             try {
                 return await WebAssembly.instantiateStreaming(module, imports);
             } catch (e) {
-                if (module.headers.get('Content-Type') != 'application/wasm') {
+                const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
                     console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
                 } else {
@@ -121,13 +122,11 @@ async function __wbg_load(module, imports) {
         const bytes = await module.arrayBuffer();
         return await WebAssembly.instantiate(bytes, imports);
     } else {
         const instance = await WebAssembly.instantiate(module, imports);
         if (instance instanceof WebAssembly.Instance) {
             return { instance, module };
         } else {
             return instance;
         }
@@ -137,54 +136,47 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
-    imports.wbg.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
-        const ret = arg0.buffer;
-        return ret;
+    imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
     };
-    imports.wbg.__wbg_length_238152a0aedbb6e7 = function(arg0) {
-        const ret = arg0.length;
-        return ret;
+    imports.wbg.__wbg_data_83b2a9a09dd4ab39 = function(arg0, arg1) {
+        const ret = arg1.data;
+        const ptr1 = passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
-    imports.wbg.__wbg_new_7a91e41fe43b3c92 = function(arg0) {
-        const ret = new Uint8ClampedArray(arg0);
+    imports.wbg.__wbg_height_93d6779af8295699 = function(arg0) {
+        const ret = arg0.height;
         return ret;
     };
-    imports.wbg.__wbg_newwithbyteoffsetandlength_6d34787141015158 = function(arg0, arg1, arg2) {
-        const ret = new Uint8ClampedArray(arg0, arg1 >>> 0, arg2 >>> 0);
+    imports.wbg.__wbg_new_with_u8_clamped_array_and_sh_5ac77cce3f6497ff = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        const ret = new ImageData(getClampedArrayU8FromWasm0(arg0, arg1), arg2 >>> 0, arg3 >>> 0);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_width_73a6511a2370c184 = function(arg0) {
+        const ret = arg0.width;
         return ret;
-    };
-    imports.wbg.__wbg_set_6775f73144c2ef27 = function(arg0, arg1, arg2) {
-        arg0.set(arg1, arg2 >>> 0);
     };
     imports.wbg.__wbindgen_init_externref_table = function() {
-        const table = wasm.__wbindgen_export_0;
+        const table = wasm.__wbindgen_externrefs;
         const offset = table.grow(4);
         table.set(0, undefined);
         table.set(offset + 0, undefined);
         table.set(offset + 1, null);
         table.set(offset + 2, true);
         table.set(offset + 3, false);
-        ;
-    };
-    imports.wbg.__wbindgen_memory = function() {
-        const ret = wasm.memory;
-        return ret;
-    };
-    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
-        throw new Error(getStringFromWasm0(arg0, arg1));
     };
     return imports;
 }
-function __wbg_init_memory(imports, memory) {
-}
 function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
+    cachedDataViewMemory0 = null;
     cachedUint8ArrayMemory0 = null;
+    cachedUint8ClampedArrayMemory0 = null;
     wasm.__wbindgen_start();
@@ -204,15 +196,10 @@ function initSync(module) {
     }
     const imports = __wbg_get_imports();
-    __wbg_init_memory(imports);
     if (!(module instanceof WebAssembly.Module)) {
         module = new WebAssembly.Module(module);
     }
     const instance = new WebAssembly.Instance(module, imports);
     return __wbg_finalize_init(instance, module);
 }
@@ -237,8 +224,6 @@ async function __wbg_init(module_or_path) {
         module_or_path = fetch(module_or_path);
     }
-    __wbg_init_memory(imports);
     const { instance, module } = await __wbg_load(await module_or_path, imports);
     return __wbg_finalize_init(instance, module);

package/compress_jpeg_bg.wasm CHANGED Viewed

Binary file

package/package.json CHANGED Viewed

@@ -2,7 +2,7 @@
   "name": "compress-jpeg",
   "type": "module",
   "description": "A simple JPEG compression library for WebAssembly",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "license": "MIT",
   "files": [
     "compress_jpeg_bg.wasm",