@wonfsy/wonfy-tools 0.1.0 → 0.1.1

package/README.md

@@ -6,7 +6,19 @@ You can checkout deployed version with UI on https://tools.won.fyi
 #### You can install is as a cli
 
 ```sh
-cargo install wonfy-tools
+cargo install wonfy-tools --features cli
+```
+
+then use it as 
+
+```sh
+wonfy-tools-cli -f ./0.png ./1.png ...
+```
+
+can use `--help` to list all possible inputs for the cli
+
+```sh
+wonfy-tools-cli --help
 ```
 
 #### Or add it as a library

package/package.json

@@ -2,7 +2,7 @@
   "name": "@wonfsy/wonfy-tools",
   "type": "module",
   "description": "Collection of tools for personal use, provides library and CLI.",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "license": "MIT",
   "repository": {
     "type": "git",

package/wonfy_tools.d.ts

@@ -1,12 +1,26 @@
 /* tslint:disable */
 /* eslint-disable */
-export function stitch(images: Uint8Array[], direction: string, order: string, window_size?: number | null, match_mode?: string | null, crop_padding?: number | null, preview?: Preview | null): StitchReturn;
+export function stitch(images: Uint8Array[], direction: string, order: string, window_size: number | null | undefined, match_mode: string | null | undefined, crop_padding: number | null | undefined, preview: Preview | null | undefined, format: EncodeFormat): StitchReturn;
+export function rgba_bytes_to_image(bytes: Uint8Array, width: number, height: number, format: EncodeFormat): ImageWithDHash;
 export function start(): void;
+export function encode_format_content_type(format: EncodeFormat): string;
+export function encode_format_file_extension(format: EncodeFormat): string;
+export enum EncodeFormat {
+  Png = 0,
+  Jpeg = 1,
+  Gif = 2,
+  WebP = 3,
+}
 export enum PreviewType {
   Resize = 0,
   MaxWidth = 1,
   MaxHeight = 2,
 }
+export class ImageWithDHash {
+  private constructor();
+  free(): void;
+  images(): [Uint8Array, BigInt];
+}
 export class Preview {
   free(): void;
   constructor(type: PreviewType, value: number);
@@ -38,12 +52,17 @@ export interface InitOutput {
   readonly stitchedimage_toJson: (a: number) => any;
   readonly __wbg_stitchreturn_free: (a: number, b: number) => void;
   readonly stitchreturn_images: (a: number) => any;
-  readonly stitch: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => [number, number, number];
+  readonly stitch: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => [number, number, number];
+  readonly __wbg_imagewithdhash_free: (a: number, b: number) => void;
+  readonly imagewithdhash_images: (a: number) => any;
+  readonly rgba_bytes_to_image: (a: number, b: number, c: number, d: number, e: number) => number;
   readonly start: () => void;
-  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly encode_format_content_type: (a: number) => [number, number];
+  readonly encode_format_file_extension: (a: number) => [number, number];
   readonly __wbindgen_exn_store: (a: number) => void;
   readonly __externref_table_alloc: () => number;
-  readonly __wbindgen_export_3: WebAssembly.Table;
+  readonly __wbindgen_export_2: WebAssembly.Table;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __externref_table_dealloc: (a: number) => void;

package/wonfy_tools.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,21 +33,6 @@ function getStringFromWasm0(ptr, len) {
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
-function addToExternrefTable0(obj) {
-    const idx = wasm.__externref_table_alloc();
-    wasm.__wbindgen_export_3.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);
-    }
-}
-
 let WASM_VECTOR_LEN = 0;
 
 const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
@@ -98,6 +98,71 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -124,7 +189,7 @@ function _assertClass(instance, klass) {
 }
 
 function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_export_3.get(idx);
+    const value = wasm.__wbindgen_export_2.get(idx);
     wasm.__externref_table_dealloc(idx);
     return value;
 }
@@ -132,13 +197,14 @@ function takeFromExternrefTable0(idx) {
  * @param {Uint8Array[]} images
  * @param {string} direction
  * @param {string} order
- * @param {number | null} [window_size]
- * @param {string | null} [match_mode]
- * @param {number | null} [crop_padding]
- * @param {Preview | null} [preview]
+ * @param {number | null | undefined} window_size
+ * @param {string | null | undefined} match_mode
+ * @param {number | null | undefined} crop_padding
+ * @param {Preview | null | undefined} preview
+ * @param {EncodeFormat} format
  * @returns {StitchReturn}
  */
-export function stitch(images, direction, order, window_size, match_mode, crop_padding, preview) {
+export function stitch(images, direction, order, window_size, match_mode, crop_padding, preview, format) {
     const ptr0 = passArrayJsValueToWasm0(images, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passStringToWasm0(direction, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -152,17 +218,80 @@ export function stitch(images, direction, order, window_size, match_mode, crop_p
         _assertClass(preview, Preview);
         ptr4 = preview.__destroy_into_raw();
     }
-    const ret = wasm.stitch(ptr0, len0, ptr1, len1, ptr2, len2, isLikeNone(window_size) ? 0x100000001 : (window_size) >>> 0, ptr3, len3, isLikeNone(crop_padding) ? 0x100000001 : (crop_padding) >>> 0, ptr4);
+    const ret = wasm.stitch(ptr0, len0, ptr1, len1, ptr2, len2, isLikeNone(window_size) ? 0x100000001 : (window_size) >>> 0, ptr3, len3, isLikeNone(crop_padding) ? 0x100000001 : (crop_padding) >>> 0, ptr4, format);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return StitchReturn.__wrap(ret[0]);
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+/**
+ * @param {Uint8Array} bytes
+ * @param {number} width
+ * @param {number} height
+ * @param {EncodeFormat} format
+ * @returns {ImageWithDHash}
+ */
+export function rgba_bytes_to_image(bytes, width, height, format) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.rgba_bytes_to_image(ptr0, len0, width, height, format);
+    return ImageWithDHash.__wrap(ret);
+}
+
 export function start() {
     wasm.start();
 }
 
+/**
+ * @param {EncodeFormat} format
+ * @returns {string}
+ */
+export function encode_format_content_type(format) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.encode_format_content_type(format);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {EncodeFormat} format
+ * @returns {string}
+ */
+export function encode_format_file_extension(format) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.encode_format_file_extension(format);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @enum {0 | 1 | 2 | 3}
+ */
+export const EncodeFormat = Object.freeze({
+    Png: 0, "0": "Png",
+    Jpeg: 1, "1": "Jpeg",
+    Gif: 2, "2": "Gif",
+    WebP: 3, "3": "WebP",
+});
 /**
  * @enum {0 | 1 | 2}
  */
@@ -172,6 +301,41 @@ export const PreviewType = Object.freeze({
     MaxHeight: 2, "2": "MaxHeight",
 });
 
+const ImageWithDHashFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_imagewithdhash_free(ptr >>> 0, 1));
+
+export class ImageWithDHash {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ImageWithDHash.prototype);
+        obj.__wbg_ptr = ptr;
+        ImageWithDHashFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ImageWithDHashFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_imagewithdhash_free(ptr, 0);
+    }
+    /**
+     * @returns {[Uint8Array, BigInt]}
+     */
+    images() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.imagewithdhash_images(ptr);
+        return ret;
+    }
+}
+
 const PreviewFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_preview_free(ptr >>> 0, 1));
@@ -331,6 +495,10 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
+    imports.wbg.__wbg_BigInt_ddea6d2f55558acb = function() { return handleError(function (arg0) {
+        const ret = BigInt(arg0);
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
         const ret = arg0.buffer;
         return ret;
@@ -436,8 +604,19 @@ function __wbg_get_imports() {
         const ret = StitchedImage.__wrap(arg0);
         return ret;
     };
+    imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
+        const ret = BigInt.asUintN(64, arg0);
+        return ret;
+    };
+    imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
+        const ret = debugString(arg1);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
     imports.wbg.__wbindgen_init_externref_table = function() {
-        const table = wasm.__wbindgen_export_3;
+        const table = wasm.__wbindgen_export_2;
         const offset = table.grow(4);
         table.set(0, undefined);
         table.set(offset + 0, undefined);