smart-downscaler 0.3.0 → 0.3.1

package/package.json

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

package/smart_downscaler.d.ts

@@ -1,6 +1,40 @@
 /* tslint:disable */
 /* eslint-disable */
 
+export class ColorAnalysisResult {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get color at index
+   */
+  get_color(index: number): ColorEntry | undefined;
+  /**
+   * Get all colors as a flat array: [r, g, b, count(4 bytes), percentage(4 bytes), ...] 
+   * Each color is 11 bytes
+   */
+  get_colors_flat(): Uint8Array;
+  /**
+   * Get colors as JSON-compatible array
+   */
+  to_json(): any;
+  readonly success: boolean;
+  readonly color_count: number;
+  readonly total_pixels: number;
+}
+
+export class ColorEntry {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly r: number;
+  readonly g: number;
+  readonly b: number;
+  readonly count: number;
+  readonly percentage: number;
+  readonly hex: string;
+}
+
 export class WasmDownscaleConfig {
   free(): void;
   [Symbol.dispose](): void;
@@ -116,6 +150,25 @@ export class WasmDownscaleResult {
   readonly palette_size: number;
 }
 
+/**
+ * Analyze colors in an image
+ *
+ * # Arguments
+ * * `image_data` - RGBA pixel data
+ * * `max_colors` - Maximum number of unique colors to track (stops if exceeded)
+ * * `sort_method` - Sorting method: "frequency", "morton", or "hilbert"
+ *
+ * # Returns
+ * ColorAnalysisResult with array of colors (r, g, b, count, percentage, hex)
+ * If unique colors exceed max_colors, returns early with success=false
+ */
+export function analyze_colors(image_data: Uint8Array, max_colors: number, sort_method: string): ColorAnalysisResult;
+
+/**
+ * Compute perceptual color distance between two RGB colors
+ */
+export function color_distance(r1: number, g1: number, b1: number, r2: number, g2: number, b2: number): number;
+
 /**
  * Main downscaling function for WebAssembly
  *
@@ -152,6 +205,16 @@ export function downscale_with_palette(image_data: Uint8Array, width: number, he
  */
 export function extract_palette_from_image(image_data: Uint8Array, _width: number, _height: number, num_colors: number, kmeans_iterations: number, strategy?: string | null): Uint8Array;
 
+/**
+ * Get chroma (saturation) of an RGB color
+ */
+export function get_chroma(r: number, g: number, b: number): number;
+
+/**
+ * Get lightness of an RGB color in Oklab space
+ */
+export function get_lightness(r: number, g: number, b: number): number;
+
 /**
  * Get available palette strategies
  */
@@ -167,11 +230,21 @@ export function init(): void;
  */
 export function log(message: string): void;
 
+/**
+ * Convert Oklab to RGB (utility function for JS)
+ */
+export function oklab_to_rgb(l: number, a: number, b: number): Uint8Array;
+
 /**
  * Quantize an image to a specific palette without resizing
  */
 export function quantize_to_palette(image_data: Uint8Array, width: number, height: number, palette_data: Uint8Array): WasmDownscaleResult;
 
+/**
+ * Convert RGB to Oklab (utility function for JS)
+ */
+export function rgb_to_oklab(r: number, g: number, b: number): Float32Array;
+
 /**
  * Get library version
  */

package/smart_downscaler_bg.js

@@ -3,6 +3,12 @@ export function __wbg_set_wasm(val) {
     wasm = val;
 }
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {
         throw new Error(`expected instance of ${klass.name}`);
@@ -27,6 +33,15 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
 function isLikeNone(x) {
     return x === undefined || x === null;
 }
@@ -103,6 +118,14 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
+const ColorAnalysisResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_coloranalysisresult_free(ptr >>> 0, 1));
+
+const ColorEntryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_colorentry_free(ptr >>> 0, 1));
+
 const WasmDownscaleConfigFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmdownscaleconfig_free(ptr >>> 0, 1));
@@ -111,6 +134,154 @@ const WasmDownscaleResultFinalization = (typeof FinalizationRegistry === 'undefi
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmdownscaleresult_free(ptr >>> 0, 1));
 
+/**
+ * Result of color analysis
+ */
+export class ColorAnalysisResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ColorAnalysisResult.prototype);
+        obj.__wbg_ptr = ptr;
+        ColorAnalysisResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ColorAnalysisResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_coloranalysisresult_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get success() {
+        const ret = wasm.coloranalysisresult_success(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get color_count() {
+        const ret = wasm.coloranalysisresult_color_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get total_pixels() {
+        const ret = wasm.coloranalysisresult_total_pixels(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get color at index
+     * @param {number} index
+     * @returns {ColorEntry | undefined}
+     */
+    get_color(index) {
+        const ret = wasm.coloranalysisresult_get_color(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : ColorEntry.__wrap(ret);
+    }
+    /**
+     * Get all colors as a flat array: [r, g, b, count(4 bytes), percentage(4 bytes), ...]
+     * Each color is 11 bytes
+     * @returns {Uint8Array}
+     */
+    get_colors_flat() {
+        const ret = wasm.coloranalysisresult_get_colors_flat(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get colors as JSON-compatible array
+     * @returns {any}
+     */
+    to_json() {
+        const ret = wasm.coloranalysisresult_to_json(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) ColorAnalysisResult.prototype[Symbol.dispose] = ColorAnalysisResult.prototype.free;
+
+/**
+ * A single color entry with statistics
+ */
+export class ColorEntry {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ColorEntry.prototype);
+        obj.__wbg_ptr = ptr;
+        ColorEntryFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ColorEntryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_colorentry_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get r() {
+        const ret = wasm.colorentry_r(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get g() {
+        const ret = wasm.colorentry_g(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get b() {
+        const ret = wasm.colorentry_b(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get count() {
+        const ret = wasm.colorentry_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get percentage() {
+        const ret = wasm.colorentry_percentage(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    get hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.colorentry_hex(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) ColorEntry.prototype[Symbol.dispose] = ColorEntry.prototype.free;
+
 /**
  * Configuration options for the downscaler (JavaScript-compatible)
  */
@@ -480,6 +651,47 @@ export class WasmDownscaleResult {
 }
 if (Symbol.dispose) WasmDownscaleResult.prototype[Symbol.dispose] = WasmDownscaleResult.prototype.free;
 
+/**
+ * Analyze colors in an image
+ *
+ * # Arguments
+ * * `image_data` - RGBA pixel data
+ * * `max_colors` - Maximum number of unique colors to track (stops if exceeded)
+ * * `sort_method` - Sorting method: "frequency", "morton", or "hilbert"
+ *
+ * # Returns
+ * ColorAnalysisResult with array of colors (r, g, b, count, percentage, hex)
+ * If unique colors exceed max_colors, returns early with success=false
+ * @param {Uint8Array} image_data
+ * @param {number} max_colors
+ * @param {string} sort_method
+ * @returns {ColorAnalysisResult}
+ */
+export function analyze_colors(image_data, max_colors, sort_method) {
+    const ptr0 = passStringToWasm0(sort_method, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.analyze_colors(image_data, max_colors, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ColorAnalysisResult.__wrap(ret[0]);
+}
+
+/**
+ * Compute perceptual color distance between two RGB colors
+ * @param {number} r1
+ * @param {number} g1
+ * @param {number} b1
+ * @param {number} r2
+ * @param {number} g2
+ * @param {number} b2
+ * @returns {number}
+ */
+export function color_distance(r1, g1, b1, r2, g2, b2) {
+    const ret = wasm.color_distance(r1, g1, b1, r2, g2, b2);
+    return ret;
+}
+
 /**
  * Main downscaling function for WebAssembly
  *
@@ -599,6 +811,30 @@ export function extract_palette_from_image(image_data, _width, _height, num_colo
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Get chroma (saturation) of an RGB color
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ * @returns {number}
+ */
+export function get_chroma(r, g, b) {
+    const ret = wasm.get_chroma(r, g, b);
+    return ret;
+}
+
+/**
+ * Get lightness of an RGB color in Oklab space
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ * @returns {number}
+ */
+export function get_lightness(r, g, b) {
+    const ret = wasm.get_lightness(r, g, b);
+    return ret;
+}
+
 /**
  * Get available palette strategies
  * @returns {Array<any>}
@@ -625,6 +861,18 @@ export function log(message) {
     wasm.log(ptr0, len0);
 }
 
+/**
+ * Convert Oklab to RGB (utility function for JS)
+ * @param {number} l
+ * @param {number} a
+ * @param {number} b
+ * @returns {Uint8Array}
+ */
+export function oklab_to_rgb(l, a, b) {
+    const ret = wasm.oklab_to_rgb(l, a, b);
+    return ret;
+}
+
 /**
  * Quantize an image to a specific palette without resizing
  * @param {Uint8Array} image_data
@@ -641,6 +889,18 @@ export function quantize_to_palette(image_data, width, height, palette_data) {
     return WasmDownscaleResult.__wrap(ret[0]);
 }
 
+/**
+ * Convert RGB to Oklab (utility function for JS)
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ * @returns {Float32Array}
+ */
+export function rgb_to_oklab(r, g, b) {
+    const ret = wasm.rgb_to_oklab(r, g, b);
+    return ret;
+}
+
 /**
  * Get library version
  * @returns {string}
@@ -671,6 +931,11 @@ export function __wbg_log_1d990106d99dacb7(arg0) {
     console.log(arg0);
 };
 
+export function __wbg_new_1ba21ce319a06297() {
+    const ret = new Object();
+    return ret;
+};
+
 export function __wbg_new_25f239778d6112b9() {
     const ret = new Array();
     return ret;
@@ -691,6 +956,11 @@ export function __wbg_new_from_slice_f9c22b9153b26992(arg0, arg1) {
     return ret;
 };
 
+export function __wbg_new_with_length_95ba657dfb7d3dfb(arg0) {
+    const ret = new Float32Array(arg0 >>> 0);
+    return ret;
+};
+
 export function __wbg_new_with_length_aa5eaf41d35235e5(arg0) {
     const ret = new Uint8Array(arg0 >>> 0);
     return ret;
@@ -705,12 +975,31 @@ export function __wbg_push_7d9be8f38fc13975(arg0, arg1) {
     return ret;
 };
 
+export function __wbg_set_781438a03c0c3c81() { return handleError(function (arg0, arg1, arg2) {
+    const ret = Reflect.set(arg0, arg1, arg2);
+    return ret;
+}, arguments) };
+
+export function __wbg_set_index_04c4b93e64d08a52(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
+};
+
+export function __wbg_set_index_165b46b0114d368c(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
+};
+
 export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
     return ret;
 };
 
+export function __wbindgen_cast_d6cd19b81560fd6e(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return ret;
+};
+
 export function __wbindgen_init_externref_table() {
     const table = wasm.__wbindgen_externrefs;
     const offset = table.grow(4);