@pixagram/renderart 0.2.0 → 0.2.2

package/dist/index.d.ts

@@ -190,80 +190,56 @@ declare const HEX_PRESETS: Record<string, Partial<HexOptions>>;
 /**
  * WASM Module Loader
  *
- * Handles loading and initialization of the Rust WASM module.
- * Requires explicit initialization - does NOT auto-import WASM.
- *
- * @example
- * ```typescript
- * import { initWasm } from '@pixagram/renderart';
- * import init from '@pixagram/renderart/pkg/renderart_wasm.js';
- *
- * // Initialize with the WASM module
- * await initWasm(init);
- * ```
+ * Auto-initializes WASM from URL. Works with any bundler.
  */
 
 /**
- * Initialize WASM module
+ * Configure WASM loading path
+ * Call this before using any CPU renderer if you need a custom path.
  *
- * @param wasmInit - The init function from renderart_wasm.js
- * @param wasmUrl - Optional URL to the .wasm file (for custom loading)
+ * @param url - URL to the renderart_wasm_bg.wasm file
  *
  * @example
  * ```typescript
- * // Option 1: Let wasm-pack handle loading
- * import init, * as wasm from '@pixagram/renderart/pkg/renderart_wasm.js';
- * await initWasm(init, wasm);
- *
- * // Option 2: With custom WASM URL
- * import init, * as wasm from '@pixagram/renderart/pkg/renderart_wasm.js';
- * await initWasm(() => init('/path/to/renderart_wasm_bg.wasm'), wasm);
+ * setWasmUrl('/static/wasm/renderart_wasm_bg.wasm');
  * ```
  */
-declare function initWasm(wasmInit: () => Promise<void>, wasm: any): Promise<void>;
+declare function setWasmUrl(url: string): void;
+/**
+ * Initialize WASM module
+ * Called automatically on first CPU renderer use.
+ * Can be called manually for preloading.
+ */
+declare function initWasm(customUrl?: string): Promise<void>;
 /** Check if WASM is loaded */
 declare function isWasmLoaded(): boolean;
-/** Get the WASM module (throws if not initialized) */
-declare function getWasmModule(): any;
 /** CRT CPU Renderer using WASM */
 declare class CrtCpuRenderer {
     private ready;
-    /** Create renderer (WASM must be initialized first via initWasm) */
-    static create(): CrtCpuRenderer;
-    /** Check if renderer is ready */
+    /** Create and initialize renderer (auto-loads WASM) */
+    static create(): Promise<CrtCpuRenderer>;
     isReady(): boolean;
-    /** Render CRT effect */
     render(input: ImageInput | ImageData, options?: CrtOptions): ImageOutput;
-    /** Dispose resources */
     dispose(): void;
 }
 /** HEX CPU Renderer using WASM */
 declare class HexCpuRenderer {
     private ready;
-    /** Create renderer (WASM must be initialized first via initWasm) */
-    static create(): HexCpuRenderer;
-    /** Check if renderer is ready */
+    static create(): Promise<HexCpuRenderer>;
     isReady(): boolean;
-    /** Render hexagonal effect */
     render(input: ImageInput | ImageData, options?: HexOptions): ImageOutput;
-    /** Get output dimensions */
     getDimensions(srcWidth: number, srcHeight: number, scale: number, orientation?: HexOrientation): {
         width: number;
         height: number;
     };
-    /** Dispose resources */
     dispose(): void;
 }
 /** XBRZ CPU Renderer using WASM */
 declare class XbrzCpuRenderer {
     private ready;
-    /** Create renderer (WASM must be initialized first via initWasm) */
-    static create(): XbrzCpuRenderer;
-    /** Check if renderer is ready */
+    static create(): Promise<XbrzCpuRenderer>;
     isReady(): boolean;
-    /** Render xBRZ scaling */
     render(input: ImageInput | ImageData, options?: XbrzOptions): ImageOutput;
-    /** Dispose resources */
     dispose(): void;
 }
 /** XBRZ presets */
@@ -272,77 +248,47 @@ declare const XBRZ_PRESETS: Record<string, Partial<XbrzOptions>>;
 /**
  * RenderArt - Unified Pixel Art Rendering Engine
  *
- * Provides a unified API for all rendering engines (CRT, HEX, XBRZ)
- * with automatic backend selection (GPU/CPU).
- *
- * GPU renderers work standalone. CPU renderers require WASM initialization.
- *
- * @example
- * ```typescript
- * // GPU-only (no WASM needed)
- * const renderer = RenderArt.createGpuOnly();
- * const result = renderer.crt.renderSync(imageData, { scale: 3 });
- *
- * // With CPU fallback (requires WASM init)
- * import init, * as wasm from '@pixagram/renderart/pkg/renderart_wasm.js';
- * await initWasm(init, wasm);
- * const renderer = RenderArt.create();
- * ```
+ * GPU renderers work standalone. CPU renderers auto-initialize WASM.
  */
 
-/** CRT rendering engine with GPU/CPU backend support */
+/** CRT rendering engine */
 declare class CrtEngine {
     private gpuRenderer;
     private cpuRenderer;
     private gpuAvailable;
-    private cpuAvailable;
-    constructor(gpuAvailable: boolean, cpuAvailable: boolean);
-    /** Initialize GPU renderer */
+    constructor(gpuAvailable: boolean);
     private ensureGpu;
-    /** Initialize CPU renderer */
     private ensureCpu;
     /** Render with automatic backend selection */
-    render(input: ImageInput | ImageData, options?: CrtOptions): ImageOutput;
-    /** Render with preset */
-    render(input: ImageInput | ImageData, preset: CrtPreset, overrides?: Partial<CrtOptions>): ImageOutput;
+    render(input: ImageInput | ImageData, options?: CrtOptions): Promise<ImageOutput>;
+    render(input: ImageInput | ImageData, preset: CrtPreset, overrides?: Partial<CrtOptions>): Promise<ImageOutput>;
     /** Render synchronously (GPU only) */
     renderSync(input: ImageInput | ImageData, options?: CrtOptions): ImageOutput;
-    /** Dispose resources */
     dispose(): void;
 }
-/** HEX rendering engine with GPU/CPU backend support */
+/** HEX rendering engine */
 declare class HexEngine {
     private gpuRenderer;
     private cpuRenderer;
     private gpuAvailable;
-    private cpuAvailable;
-    constructor(gpuAvailable: boolean, cpuAvailable: boolean);
+    constructor(gpuAvailable: boolean);
     private ensureGpu;
     private ensureCpu;
-    /** Render with automatic backend selection */
-    render(input: ImageInput | ImageData, options?: HexOptions): ImageOutput;
-    /** Render with preset */
-    render(input: ImageInput | ImageData, preset: HexPreset, overrides?: Partial<HexOptions>): ImageOutput;
-    /** Render synchronously (GPU only) */
+    render(input: ImageInput | ImageData, options?: HexOptions): Promise<ImageOutput>;
+    render(input: ImageInput | ImageData, preset: HexPreset, overrides?: Partial<HexOptions>): Promise<ImageOutput>;
     renderSync(input: ImageInput | ImageData, options?: HexOptions): ImageOutput;
-    /** Get output dimensions */
     getDimensions(srcWidth: number, srcHeight: number, options?: HexOptions): {
         width: number;
         height: number;
     };
     dispose(): void;
 }
-/** XBRZ rendering engine (CPU only - algorithm too complex for efficient GPU) */
+/** XBRZ rendering engine (CPU only) */
 declare class XbrzEngine {
     private cpuRenderer;
-    private cpuAvailable;
-    constructor(cpuAvailable: boolean);
     private ensureCpu;
-    /** Render xBRZ scaling */
-    render(input: ImageInput | ImageData, options?: XbrzOptions): ImageOutput;
-    /** Render with preset */
-    render(input: ImageInput | ImageData, preset: XbrzPreset, overrides?: Partial<XbrzOptions>): ImageOutput;
-    /** Get output dimensions */
+    render(input: ImageInput | ImageData, options?: XbrzOptions): Promise<ImageOutput>;
+    render(input: ImageInput | ImageData, preset: XbrzPreset, overrides?: Partial<XbrzOptions>): Promise<ImageOutput>;
     getDimensions(srcWidth: number, srcHeight: number, scale?: number): {
         width: number;
         height: number;
@@ -351,29 +297,19 @@ declare class XbrzEngine {
 }
 /** RenderArt - Unified Pixel Art Rendering Engine */
 declare class RenderArt {
-    /** CRT effect renderer */
     readonly crt: CrtEngine;
-    /** Hexagonal pixel renderer */
     readonly hex: HexEngine;
-    /** xBRZ scaling renderer */
     readonly xbrz: XbrzEngine;
     private _capabilities;
     private constructor();
-    /**
-     * Create RenderArt instance
-     * GPU renderers always available if WebGL2 supported.
-     * CPU renderers require WASM to be initialized via initWasm() first.
-     */
+    /** Create RenderArt instance */
     static create(): RenderArt;
-    /**
-     * Create GPU-only RenderArt instance (no WASM required)
-     * CPU fallback will not be available.
-     */
+    /** Create GPU-only instance */
     static createGpuOnly(): RenderArt;
-    /** Get renderer capabilities */
+    /** Pre-initialize WASM for faster first CPU render */
+    preloadWasm(wasmUrl?: string): Promise<void>;
     get capabilities(): RendererCapabilities;
-    /** Dispose all resources */
     dispose(): void;
 }
 
-export { type Backend, CRT_PRESETS, CrtCpuRenderer, CrtEngine, CrtGpuRenderer, type CrtOptions, type CrtPreset, HEX_PRESETS, HexCpuRenderer, HexEngine, HexGpuRenderer, type HexOptions, type HexOrientation, type HexPreset, type ImageInput, type ImageOutput, type PixelData, RenderArt, type RenderStats, type Renderer, type RendererCapabilities, XBRZ_PRESETS, XbrzCpuRenderer, XbrzEngine, type XbrzOptions, type XbrzPreset, getWasmModule, hexGetDimensions, initWasm, isWasmLoaded };
+export { type Backend, CRT_PRESETS, CrtCpuRenderer, CrtEngine, CrtGpuRenderer, type CrtOptions, type CrtPreset, HEX_PRESETS, HexCpuRenderer, HexEngine, HexGpuRenderer, type HexOptions, type HexOrientation, type HexPreset, type ImageInput, type ImageOutput, type PixelData, RenderArt, type RenderStats, type Renderer, type RendererCapabilities, XBRZ_PRESETS, XbrzCpuRenderer, XbrzEngine, type XbrzOptions, type XbrzPreset, hexGetDimensions, initWasm, isWasmLoaded, setWasmUrl };