smart-downscaler 0.1.0 → 0.1.2

package/package.json

@@ -5,7 +5,7 @@
     "Pixagram"
   ],
   "description": "Intelligent pixel art downscaler with region-aware color quantization",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -30,4 +30,4 @@
     "quantization",
     "wasm"
   ]
-}
+}

package/smart_downscaler.d.ts

@@ -104,6 +104,36 @@ export class WasmDownscaleResult {
   readonly palette_size: number;
 }
 
+export class WasmTurboConfig {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor();
+  /**
+   * Fastest possible settings
+   */
+  static fastest(): WasmTurboConfig;
+  /**
+   * Balanced speed/quality
+   */
+  static balanced(): WasmTurboConfig;
+  /**
+   * Number of colors in output palette
+   */
+  palette_size: number;
+  /**
+   * Enable neighbor coherence (small quality boost, small perf cost)
+   */
+  neighbor_coherence: boolean;
+  /**
+   * Neighbor weight [0.0-1.0]
+   */
+  neighbor_weight: number;
+  /**
+   * Enable dithering
+   */
+  dither: boolean;
+}
+
 /**
  * Main downscaling function for WebAssembly
  *
@@ -155,6 +185,29 @@ export function log(message: string): void;
  */
 export function quantize_to_palette(image_data: Uint8Array, width: number, height: number, palette_data: Uint8Array): WasmDownscaleResult;
 
+/**
+ * TURBO: Ultra-fast downscaling (3-9x faster than standard)
+ * 
+ * Use this when speed is more important than maximum quality.
+ * Still produces good results, just uses faster algorithms.
+ */
+export function turbo_downscale(image_data: Uint8Array, width: number, height: number, target_width: number, target_height: number, config?: WasmTurboConfig | null): WasmDownscaleResult;
+
+/**
+ * TURBO: Maximum speed variant
+ */
+export function turbo_downscale_fastest(image_data: Uint8Array, width: number, height: number, target_width: number, target_height: number, num_colors: number): WasmDownscaleResult;
+
+/**
+ * TURBO: Same as turbo_downscale but accepts Uint8ClampedArray from ImageData
+ */
+export function turbo_downscale_rgba(image_data: Uint8ClampedArray, width: number, height: number, target_width: number, target_height: number, config?: WasmTurboConfig | null): WasmDownscaleResult;
+
+/**
+ * TURBO: Simplest API - just specify dimensions and colors
+ */
+export function turbo_downscale_simple(image_data: Uint8Array, width: number, height: number, target_width: number, target_height: number, num_colors: number): WasmDownscaleResult;
+
 /**
  * Get library version
  */

package/smart_downscaler_bg.js

@@ -111,6 +111,10 @@ const WasmDownscaleResultFinalization = (typeof FinalizationRegistry === 'undefi
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmdownscaleresult_free(ptr >>> 0, 1));
 
+const WasmTurboConfigFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmturboconfig_free(ptr >>> 0, 1));
+
 /**
  * Configuration options for the downscaler (JavaScript-compatible)
  */
@@ -439,6 +443,112 @@ export class WasmDownscaleResult {
 }
 if (Symbol.dispose) WasmDownscaleResult.prototype[Symbol.dispose] = WasmDownscaleResult.prototype.free;
 
+/**
+ * Turbo mode configuration
+ */
+export class WasmTurboConfig {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmTurboConfig.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmTurboConfigFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmTurboConfigFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmturboconfig_free(ptr, 0);
+    }
+    /**
+     * Number of colors in output palette
+     * @returns {number}
+     */
+    get palette_size() {
+        const ret = wasm.__wbg_get_wasmturboconfig_palette_size(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of colors in output palette
+     * @param {number} arg0
+     */
+    set palette_size(arg0) {
+        wasm.__wbg_set_wasmturboconfig_palette_size(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Enable neighbor coherence (small quality boost, small perf cost)
+     * @returns {boolean}
+     */
+    get neighbor_coherence() {
+        const ret = wasm.__wbg_get_wasmturboconfig_neighbor_coherence(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Enable neighbor coherence (small quality boost, small perf cost)
+     * @param {boolean} arg0
+     */
+    set neighbor_coherence(arg0) {
+        wasm.__wbg_set_wasmturboconfig_neighbor_coherence(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Neighbor weight [0.0-1.0]
+     * @returns {number}
+     */
+    get neighbor_weight() {
+        const ret = wasm.__wbg_get_wasmturboconfig_neighbor_weight(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Neighbor weight [0.0-1.0]
+     * @param {number} arg0
+     */
+    set neighbor_weight(arg0) {
+        wasm.__wbg_set_wasmturboconfig_neighbor_weight(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Enable dithering
+     * @returns {boolean}
+     */
+    get dither() {
+        const ret = wasm.__wbg_get_wasmturboconfig_dither(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Enable dithering
+     * @param {boolean} arg0
+     */
+    set dither(arg0) {
+        wasm.__wbg_set_wasmturboconfig_dither(this.__wbg_ptr, arg0);
+    }
+    constructor() {
+        const ret = wasm.wasmturboconfig_balanced();
+        this.__wbg_ptr = ret >>> 0;
+        WasmTurboConfigFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Fastest possible settings
+     * @returns {WasmTurboConfig}
+     */
+    static fastest() {
+        const ret = wasm.wasmturboconfig_fastest();
+        return WasmTurboConfig.__wrap(ret);
+    }
+    /**
+     * Balanced speed/quality
+     * @returns {WasmTurboConfig}
+     */
+    static balanced() {
+        const ret = wasm.wasmturboconfig_balanced();
+        return WasmTurboConfig.__wrap(ret);
+    }
+}
+if (Symbol.dispose) WasmTurboConfig.prototype[Symbol.dispose] = WasmTurboConfig.prototype.free;
+
 /**
  * Main downscaling function for WebAssembly
  *
@@ -588,6 +698,91 @@ export function quantize_to_palette(image_data, width, height, palette_data) {
     return WasmDownscaleResult.__wrap(ret[0]);
 }
 
+/**
+ * TURBO: Ultra-fast downscaling (3-9x faster than standard)
+ *
+ * Use this when speed is more important than maximum quality.
+ * Still produces good results, just uses faster algorithms.
+ * @param {Uint8Array} image_data
+ * @param {number} width
+ * @param {number} height
+ * @param {number} target_width
+ * @param {number} target_height
+ * @param {WasmTurboConfig | null} [config]
+ * @returns {WasmDownscaleResult}
+ */
+export function turbo_downscale(image_data, width, height, target_width, target_height, config) {
+    let ptr0 = 0;
+    if (!isLikeNone(config)) {
+        _assertClass(config, WasmTurboConfig);
+        ptr0 = config.__destroy_into_raw();
+    }
+    const ret = wasm.turbo_downscale(image_data, width, height, target_width, target_height, ptr0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmDownscaleResult.__wrap(ret[0]);
+}
+
+/**
+ * TURBO: Maximum speed variant
+ * @param {Uint8Array} image_data
+ * @param {number} width
+ * @param {number} height
+ * @param {number} target_width
+ * @param {number} target_height
+ * @param {number} num_colors
+ * @returns {WasmDownscaleResult}
+ */
+export function turbo_downscale_fastest(image_data, width, height, target_width, target_height, num_colors) {
+    const ret = wasm.turbo_downscale_fastest(image_data, width, height, target_width, target_height, num_colors);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmDownscaleResult.__wrap(ret[0]);
+}
+
+/**
+ * TURBO: Same as turbo_downscale but accepts Uint8ClampedArray from ImageData
+ * @param {Uint8ClampedArray} image_data
+ * @param {number} width
+ * @param {number} height
+ * @param {number} target_width
+ * @param {number} target_height
+ * @param {WasmTurboConfig | null} [config]
+ * @returns {WasmDownscaleResult}
+ */
+export function turbo_downscale_rgba(image_data, width, height, target_width, target_height, config) {
+    let ptr0 = 0;
+    if (!isLikeNone(config)) {
+        _assertClass(config, WasmTurboConfig);
+        ptr0 = config.__destroy_into_raw();
+    }
+    const ret = wasm.turbo_downscale_rgba(image_data, width, height, target_width, target_height, ptr0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmDownscaleResult.__wrap(ret[0]);
+}
+
+/**
+ * TURBO: Simplest API - just specify dimensions and colors
+ * @param {Uint8Array} image_data
+ * @param {number} width
+ * @param {number} height
+ * @param {number} target_width
+ * @param {number} target_height
+ * @param {number} num_colors
+ * @returns {WasmDownscaleResult}
+ */
+export function turbo_downscale_simple(image_data, width, height, target_width, target_height, num_colors) {
+    const ret = wasm.turbo_downscale_simple(image_data, width, height, target_width, target_height, num_colors);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmDownscaleResult.__wrap(ret[0]);
+}
+
 /**
  * Get library version
  * @returns {string}