compress-jpeg 1.0.5 → 1.0.6

package/README.md

@@ -70,8 +70,8 @@ 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");
+    // Initialize the WASM module
+    await init();
 
     // Load image into an off-screen canvas
     const img = new Image();
@@ -89,22 +89,25 @@ fileInput.addEventListener("change", async () => {
 
         // Extract raw pixel data
         const browserImageData = ctx.getImageData(0, 0, img.width, img.height);
-        const rustInput = new RustImageData(
+        const input = new RustImageData(
+            new Uint8ClampedArray(browserImageData.data),
             browserImageData.width,
-            browserImageData.height,
-            new Uint8ClampedArray(browserImageData.data)
+            browserImageData.height
         );
 
         // Simulate JPEG compression at quality=30
-        const output = compress_jpeg(rustInput, 30);
+        const output = compress_jpeg(input, 30);
 
         // Convert back to browser ImageData
-        const processedData = new ImageData(output.data(), output.width(), output.height());
+        const processedData = new ImageData(new Uint8ClampedArray(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);
+
+        // Free the WebAssembly memory
+        output.free();
     };
 });
 ```

package/compress_jpeg.d.ts

@@ -1,9 +1,9 @@
 /* tslint:disable */
 /* eslint-disable */
-export function compress_jpeg(image_data: ImageData, quality: number): ImageData;
+export function compress_jpeg(image_data: ImageData, quality: number): Promise<ImageData>;
 export class ImageData {
   free(): void;
-  constructor(width: number, height: number, data: Uint8ClampedArray);
+  constructor(data: Uint8ClampedArray, width: number, height: number);
   width(): number;
   height(): number;
   data(): Uint8ClampedArray;
@@ -14,13 +14,17 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 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_new: (a: any, b: number, c: number) => 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 __externref_table_dealloc: (a: number) => void;
+  readonly compress_jpeg: (a: number, b: number) => any;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_export_2: WebAssembly.Table;
+  readonly __wbindgen_export_3: WebAssembly.Table;
+  readonly closure6_externref_shim: (a: number, b: number, c: any) => void;
+  readonly closure23_externref_shim: (a: number, b: number, c: any, d: any) => void;
   readonly __wbindgen_start: () => void;
 }
 

package/compress_jpeg.js

@@ -1,5 +1,20 @@
 let wasm;
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_export_2.set(idx, obj);
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
 const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
 
 if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
@@ -18,30 +33,64 @@ function getStringFromWasm0(ptr, len) {
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => {
+    wasm.__wbindgen_export_3.get(state.dtor)(state.a, state.b)
+});
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            if (--state.cnt === 0) {
+                wasm.__wbindgen_export_3.get(state.dtor)(a, state.b);
+                CLOSURE_DTORS.unregister(state);
+            } else {
+                state.a = a;
+            }
+        }
+    };
+    real.original = state;
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {
         throw new Error(`expected instance of ${klass.name}`);
     }
 }
-
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_export_0.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
-}
 /**
  * @param {ImageData} image_data
  * @param {number} quality
- * @returns {ImageData}
+ * @returns {Promise<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);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return ImageData.__wrap(ret[0]);
+    return ret;
+}
+
+function __wbg_adapter_18(arg0, arg1, arg2) {
+    wasm.closure6_externref_shim(arg0, arg1, arg2);
+}
+
+function __wbg_adapter_36(arg0, arg1, arg2, arg3) {
+    wasm.closure23_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 const ImageDataFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -70,12 +119,12 @@ export class ImageData {
         wasm.__wbg_imagedata_free(ptr, 0);
     }
     /**
+     * @param {Uint8ClampedArray} data
      * @param {number} width
      * @param {number} height
-     * @param {Uint8ClampedArray} data
      */
-    constructor(width, height, data) {
-        const ret = wasm.imagedata_new(width, height, data);
+    constructor(data, width, height) {
+        const ret = wasm.imagedata_new(data, width, height);
         this.__wbg_ptr = ret >>> 0;
         ImageDataFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -141,23 +190,101 @@ function __wbg_get_imports() {
         const ret = arg0.buffer;
         return ret;
     };
+    imports.wbg.__wbg_call_672a4d21634d4a24 = function() { return handleError(function (arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_call_7cccdd69e0791ae2 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = arg0.call(arg1, arg2);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_imagedata_new = function(arg0) {
+        const ret = ImageData.__wrap(arg0);
+        return ret;
+    };
     imports.wbg.__wbg_length_238152a0aedbb6e7 = function(arg0) {
         const ret = arg0.length;
         return ret;
     };
+    imports.wbg.__wbg_new_23a2665fac83c611 = function(arg0, arg1) {
+        try {
+            var state0 = {a: arg0, b: arg1};
+            var cb0 = (arg0, arg1) => {
+                const a = state0.a;
+                state0.a = 0;
+                try {
+                    return __wbg_adapter_36(a, state0.b, arg0, arg1);
+                } finally {
+                    state0.a = a;
+                }
+            };
+            const ret = new Promise(cb0);
+            return ret;
+        } finally {
+            state0.a = state0.b = 0;
+        }
+    };
     imports.wbg.__wbg_new_7a91e41fe43b3c92 = function(arg0) {
         const ret = new Uint8ClampedArray(arg0);
         return ret;
     };
+    imports.wbg.__wbg_newnoargs_105ed471475aaf50 = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
     imports.wbg.__wbg_newwithbyteoffsetandlength_6d34787141015158 = function(arg0, arg1, arg2) {
         const ret = new Uint8ClampedArray(arg0, arg1 >>> 0, arg2 >>> 0);
         return ret;
     };
+    imports.wbg.__wbg_queueMicrotask_97d92b4fcc8a61c5 = function(arg0) {
+        queueMicrotask(arg0);
+    };
+    imports.wbg.__wbg_queueMicrotask_d3219def82552485 = function(arg0) {
+        const ret = arg0.queueMicrotask;
+        return ret;
+    };
+    imports.wbg.__wbg_resolve_4851785c9c5f573d = function(arg0) {
+        const ret = Promise.resolve(arg0);
+        return ret;
+    };
     imports.wbg.__wbg_set_6775f73144c2ef27 = function(arg0, arg1, arg2) {
         arg0.set(arg1, arg2 >>> 0);
     };
+    imports.wbg.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function() {
+        const ret = typeof global === 'undefined' ? null : global;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 = function() {
+        const ret = typeof globalThis === 'undefined' ? null : globalThis;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function() {
+        const ret = typeof self === 'undefined' ? null : self;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_WINDOW_5de37043a91a9c40 = function() {
+        const ret = typeof window === 'undefined' ? null : window;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_then_44b73946d2fb3e7d = function(arg0, arg1) {
+        const ret = arg0.then(arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_cb_drop = function(arg0) {
+        const obj = arg0.original;
+        if (obj.cnt-- == 1) {
+            obj.a = 0;
+            return true;
+        }
+        const ret = false;
+        return ret;
+    };
+    imports.wbg.__wbindgen_closure_wrapper52 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 7, __wbg_adapter_18);
+        return ret;
+    };
     imports.wbg.__wbindgen_init_externref_table = function() {
-        const table = wasm.__wbindgen_export_0;
+        const table = wasm.__wbindgen_export_2;
         const offset = table.grow(4);
         table.set(0, undefined);
         table.set(offset + 0, undefined);
@@ -166,6 +293,14 @@ function __wbg_get_imports() {
         table.set(offset + 3, false);
         ;
     };
+    imports.wbg.__wbindgen_is_function = function(arg0) {
+        const ret = typeof(arg0) === 'function';
+        return ret;
+    };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = arg0 === undefined;
+        return ret;
+    };
     imports.wbg.__wbindgen_memory = function() {
         const ret = wasm.memory;
         return ret;

package/package.json

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