@pixagram/renderart 0.4.0 → 0.4.4

package/dist/index.js

@@ -622,47 +622,13 @@ var HEX_PRESETS = {
 // src/wasm-loader.ts
 var wasm = null;
 var wasmReady = false;
-var initPromise = null;
-var initError = null;
-async function initWasm(wasmUrl) {
-  if (wasmReady) return;
-  if (initError) throw initError;
-  if (initPromise) return initPromise;
-  initPromise = (async () => {
-    try {
-      const wasmModule = await import('./renderart_wasm.js');
-      const init = wasmModule.default || wasmModule.__wbg_init || wasmModule;
-      if (typeof init === "function") {
-        await init();
-      } else if (typeof init.default === "function") {
-        await init.default();
-      } else {
-        throw new Error("Could not find WASM init function");
-      }
-      wasm = wasmModule;
-      wasmReady = true;
-    } catch (e) {
-      initError = new Error(`Failed to initialize WASM: ${e}`);
-      initPromise = null;
-      throw initError;
-    }
-  })();
-  return initPromise;
+function initWasm(wasmModule) {
+  wasm = wasmModule;
+  wasmReady = true;
 }
 function isWasmLoaded() {
   return wasmReady;
 }
-function hasWasmError() {
-  return initError !== null;
-}
-function getWasmError() {
-  return initError;
-}
-async function ensureWasm() {
-  if (!wasmReady) {
-    await initWasm();
-  }
-}
 function getOutputData(result) {
   const memory = wasm.get_memory();
   const buffer = new Uint8Array(memory.buffer, result.ptr, result.len);
@@ -672,30 +638,24 @@ function toUint8Array(input) {
   const data = input instanceof ImageData ? input.data : input.data;
   return data instanceof Uint8Array ? data : new Uint8Array(data);
 }
-var CrtCpuRenderer = class _CrtCpuRenderer {
-  constructor() {
-    this.initialized = false;
+function ensureWasm() {
+  if (!wasmReady || !wasm) {
+    throw new Error("WASM not initialized. Call initWasm() first.");
   }
-  /** Create and initialize renderer */
-  static async create() {
-    const renderer = new _CrtCpuRenderer();
-    await renderer.init();
-    return renderer;
-  }
-  /** Initialize (loads WASM if needed) */
-  async init() {
-    await ensureWasm();
-    this.initialized = true;
+}
+var CrtCpuRenderer = class _CrtCpuRenderer {
+  /** Create renderer (WASM must be initialized first) */
+  static create() {
+    ensureWasm();
+    return new _CrtCpuRenderer();
   }
   /** Check if renderer is ready */
   isReady() {
-    return this.initialized && wasmReady;
+    return wasmReady;
   }
   /** Render CRT effect */
   render(input, options = {}) {
-    if (!this.initialized || !wasm) {
-      throw new Error("Renderer not initialized. Call init() first or use CrtCpuRenderer.create()");
-    }
+    ensureWasm();
     const data = toUint8Array(input);
     const width = input.width;
     const height = input.height;
@@ -720,9 +680,7 @@ var CrtCpuRenderer = class _CrtCpuRenderer {
       height: result.height
     };
   }
-  /** Dispose resources */
   dispose() {
-    this.initialized = false;
   }
 };
 function parseColorToU32(color, defaultVal) {
@@ -731,39 +689,21 @@ function parseColorToU32(color, defaultVal) {
   if (color === "transparent") return 0;
   if (color.startsWith("#")) {
     const hex = color.slice(1);
-    if (hex.length === 6) {
-      return parseInt(hex, 16) << 8 | 255;
-    }
-    if (hex.length === 8) {
-      return parseInt(hex, 16);
-    }
+    if (hex.length === 6) return parseInt(hex, 16) << 8 | 255;
+    if (hex.length === 8) return parseInt(hex, 16);
   }
   return defaultVal;
 }
 var HexCpuRenderer = class _HexCpuRenderer {
-  constructor() {
-    this.initialized = false;
-  }
-  /** Create and initialize renderer */
-  static async create() {
-    const renderer = new _HexCpuRenderer();
-    await renderer.init();
-    return renderer;
-  }
-  /** Initialize (loads WASM if needed) */
-  async init() {
-    await ensureWasm();
-    this.initialized = true;
+  static create() {
+    ensureWasm();
+    return new _HexCpuRenderer();
   }
-  /** Check if renderer is ready */
   isReady() {
-    return this.initialized && wasmReady;
+    return wasmReady;
   }
-  /** Render hexagonal effect */
   render(input, options = {}) {
-    if (!this.initialized || !wasm) {
-      throw new Error("Renderer not initialized. Call init() first or use HexCpuRenderer.create()");
-    }
+    ensureWasm();
     const data = toUint8Array(input);
     const width = input.width;
     const height = input.height;
@@ -785,43 +725,24 @@ var HexCpuRenderer = class _HexCpuRenderer {
       height: result.height
     };
   }
-  /** Get output dimensions */
   getDimensions(srcWidth, srcHeight, scale, orientation = "flat-top") {
-    if (!this.initialized || !wasm) {
-      throw new Error("Renderer not initialized");
-    }
+    ensureWasm();
     const dims = wasm.hex_get_dimensions(srcWidth, srcHeight, scale, orientation === "pointy-top" ? 1 : 0);
     return { width: dims[0], height: dims[1] };
   }
-  /** Dispose resources */
   dispose() {
-    this.initialized = false;
   }
 };
 var XbrzCpuRenderer = class _XbrzCpuRenderer {
-  constructor() {
-    this.initialized = false;
-  }
-  /** Create and initialize renderer */
-  static async create() {
-    const renderer = new _XbrzCpuRenderer();
-    await renderer.init();
-    return renderer;
-  }
-  /** Initialize (loads WASM if needed) */
-  async init() {
-    await ensureWasm();
-    this.initialized = true;
+  static create() {
+    ensureWasm();
+    return new _XbrzCpuRenderer();
   }
-  /** Check if renderer is ready */
   isReady() {
-    return this.initialized && wasmReady;
+    return wasmReady;
   }
-  /** Render xBRZ scaling */
   render(input, options = {}) {
-    if (!this.initialized || !wasm) {
-      throw new Error("Renderer not initialized. Call init() first or use XbrzCpuRenderer.create()");
-    }
+    ensureWasm();
     const data = toUint8Array(input);
     const width = input.width;
     const height = input.height;
@@ -842,9 +763,7 @@ var XbrzCpuRenderer = class _XbrzCpuRenderer {
       height: result.height
     };
   }
-  /** Dispose resources */
   dispose() {
-    this.initialized = false;
   }
 };
 var XBRZ_PRESETS = {
@@ -896,33 +815,24 @@ var CrtEngine = class {
     if (!this.gpuRenderer) throw new Error("GPU renderer not available");
     return this.gpuRenderer;
   }
-  async ensureCpu() {
+  ensureCpu() {
     if (!this.cpuRenderer) {
-      this.cpuRenderer = await CrtCpuRenderer.create();
+      this.cpuRenderer = CrtCpuRenderer.create();
     }
     return this.cpuRenderer;
   }
-  async render(input, optionsOrPreset, overrides) {
-    let options = {};
-    if (typeof optionsOrPreset === "string") {
-      options = { ...CRT_PRESETS[optionsOrPreset], ...overrides };
-    } else if (optionsOrPreset) {
-      options = optionsOrPreset;
-    }
+  /** Render with options or preset */
+  render(input, optionsOrPreset = {}) {
+    const options = typeof optionsOrPreset === "string" ? { ...CRT_PRESETS[optionsOrPreset] } : optionsOrPreset;
     const backend = options.backend ?? "auto";
     if (backend === "gpu" || backend === "auto" && this.gpuAvailable) {
-      try {
-        return this.ensureGpu().render(input, options);
-      } catch (e) {
-        if (backend === "gpu") throw e;
-      }
+      return this.ensureGpu().render(input, options);
     }
-    const cpu = await this.ensureCpu();
-    return cpu.render(input, options);
+    return this.ensureCpu().render(input, options);
   }
-  /** Render synchronously (GPU only) */
-  renderSync(input, options) {
-    return this.ensureGpu().render(input, options ?? {});
+  /** Synchronous GPU-only render */
+  renderSync(input, options = {}) {
+    return this.ensureGpu().render(input, options);
   }
   dispose() {
     this.gpuRenderer?.dispose();
@@ -944,36 +854,26 @@ var HexEngine = class {
     if (!this.gpuRenderer) throw new Error("GPU renderer not available");
     return this.gpuRenderer;
   }
-  async ensureCpu() {
+  ensureCpu() {
     if (!this.cpuRenderer) {
-      this.cpuRenderer = await HexCpuRenderer.create();
+      this.cpuRenderer = HexCpuRenderer.create();
     }
     return this.cpuRenderer;
   }
-  async render(input, optionsOrPreset, overrides) {
-    let options = {};
-    if (typeof optionsOrPreset === "string") {
-      options = { ...HEX_PRESETS[optionsOrPreset], ...overrides };
-    } else if (optionsOrPreset) {
-      options = optionsOrPreset;
-    }
+  render(input, optionsOrPreset = {}) {
+    const options = typeof optionsOrPreset === "string" ? { ...HEX_PRESETS[optionsOrPreset] } : optionsOrPreset;
     const backend = options.backend ?? "auto";
     if (backend === "gpu" || backend === "auto" && this.gpuAvailable) {
-      try {
-        return this.ensureGpu().render(input, options);
-      } catch (e) {
-        if (backend === "gpu") throw e;
-      }
+      return this.ensureGpu().render(input, options);
     }
-    const cpu = await this.ensureCpu();
-    return cpu.render(input, options);
+    return this.ensureCpu().render(input, options);
   }
-  renderSync(input, options) {
-    return this.ensureGpu().render(input, options ?? {});
+  renderSync(input, options = {}) {
+    return this.ensureGpu().render(input, options);
   }
-  getDimensions(srcWidth, srcHeight, options) {
-    const scale = options?.scale ?? 16;
-    const orientation = options?.orientation ?? "flat-top";
+  getDimensions(srcWidth, srcHeight, options = {}) {
+    const scale = options.scale ?? 16;
+    const orientation = options.orientation ?? "flat-top";
     return hexGetDimensions(srcWidth, srcHeight, scale, orientation);
   }
   dispose() {
@@ -987,25 +887,15 @@ var XbrzEngine = class {
   constructor() {
     this.cpuRenderer = null;
   }
-  async ensureCpu() {
+  ensureCpu() {
     if (!this.cpuRenderer) {
-      this.cpuRenderer = await XbrzCpuRenderer.create();
+      this.cpuRenderer = XbrzCpuRenderer.create();
     }
     return this.cpuRenderer;
   }
-  async render(input, optionsOrPreset, overrides) {
-    let options = {};
-    if (typeof optionsOrPreset === "string") {
-      options = { ...XBRZ_PRESETS[optionsOrPreset], ...overrides };
-    } else if (optionsOrPreset) {
-      options = optionsOrPreset;
-    }
-    const cpu = await this.ensureCpu();
-    return cpu.render(input, options);
-  }
-  getDimensions(srcWidth, srcHeight, scale = 2) {
-    const s = Math.min(6, Math.max(2, scale));
-    return { width: srcWidth * s, height: srcHeight * s };
+  render(input, optionsOrPreset = {}) {
+    const options = typeof optionsOrPreset === "string" ? { ...XBRZ_PRESETS[optionsOrPreset] } : optionsOrPreset;
+    return this.ensureCpu().render(input, options);
   }
   dispose() {
     this.cpuRenderer?.dispose();
@@ -1013,37 +903,40 @@ var XbrzEngine = class {
   }
 };
 var RenderArt = class _RenderArt {
-  constructor(gpuAvailable) {
-    this.crt = new CrtEngine(gpuAvailable);
-    this.hex = new HexEngine(gpuAvailable);
+  constructor(capabilities) {
+    this.capabilities = capabilities;
+    this.crt = new CrtEngine(capabilities.gpu);
+    this.hex = new HexEngine(capabilities.gpu);
     this.xbrz = new XbrzEngine();
-    const maxTextureSize = gpuAvailable ? getMaxTextureSize() : 0;
-    this._capabilities = {
-      gpu: gpuAvailable,
-      cpu: true,
-      // Always potentially available via async init
-      maxTextureSize,
-      recommendedBackend: gpuAvailable ? "gpu" : "cpu"
-    };
   }
-  /** Create RenderArt instance */
+  /**
+   * Create RenderArt instance.
+   * For CPU/WASM support, call initWasm() first.
+   */
   static create() {
     const gpuAvailable = checkWebGL2();
-    return new _RenderArt(gpuAvailable);
+    const cpuAvailable = isWasmLoaded();
+    return new _RenderArt({
+      gpu: gpuAvailable,
+      cpu: cpuAvailable,
+      maxTextureSize: gpuAvailable ? getMaxTextureSize() : 0,
+      recommendedBackend: gpuAvailable ? "gpu" : cpuAvailable ? "cpu" : "gpu"
+    });
   }
-  /** Create GPU-only instance */
+  /**
+   * Create GPU-only RenderArt instance (no WASM needed).
+   */
   static createGpuOnly() {
-    if (!checkWebGL2()) {
-      throw new Error("WebGL2 not supported");
-    }
-    return new _RenderArt(true);
-  }
-  /** Pre-initialize WASM for faster first CPU render */
-  async preloadWasm(wasmUrl) {
-    await initWasm();
-  }
-  get capabilities() {
-    return { ...this._capabilities };
+    const gpuAvailable = checkWebGL2();
+    if (!gpuAvailable) {
+      throw new Error("WebGL2 not available");
+    }
+    return new _RenderArt({
+      gpu: true,
+      cpu: false,
+      maxTextureSize: getMaxTextureSize(),
+      recommendedBackend: "gpu"
+    });
   }
   dispose() {
     this.crt.dispose();
@@ -1064,8 +957,6 @@ exports.RenderArt = RenderArt;
 exports.XBRZ_PRESETS = XBRZ_PRESETS;
 exports.XbrzCpuRenderer = XbrzCpuRenderer;
 exports.XbrzEngine = XbrzEngine;
-exports.getWasmError = getWasmError;
-exports.hasWasmError = hasWasmError;
 exports.hexGetDimensions = hexGetDimensions;
 exports.initWasm = initWasm;
 exports.isWasmLoaded = isWasmLoaded;