facebetter 1.0.8 → 1.0.10

package/dist/facebetter.esm.js

@@ -230,60 +230,157 @@ class BeautyEffectEngine {
     
     // Start loading WASM module immediately in constructor
     this._wasmLoadPromise = this._loadWasmModule();
+    this._initPromise = null;
+  }
+
+  /**
+   * Creates a timeout promise
+   * @private
+   * @param {number} timeout - Timeout in milliseconds
+   * @param {string} operation - Operation name for error message
+   * @returns {Promise} Promise that rejects after timeout
+   */
+  _createTimeout(timeout, operation) {
+    return new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new FacebetterError(
+          `${operation} timed out after ${timeout}ms. Please check your network connection or try increasing the timeout.`,
+          'TIMEOUT'
+        ));
+      }, timeout);
+    });
+  }
+
+  /**
+   * Enhances error with context information
+   * @private
+   * @param {Error} error - Original error
+   * @param {string} context - Context information
+   * @returns {FacebetterError} Enhanced error
+   */
+  _enhanceError(error, context) {
+    if (error instanceof FacebetterError) {
+      return error;
+    }
+
+    let errorCode = 'UNKNOWN_ERROR';
+    let message = error.message || 'Unknown error occurred';
+
+    // Categorize errors
+    if (error.message?.includes('timeout') || error.message?.includes('TIMEOUT')) {
+      errorCode = 'TIMEOUT';
+    } else if (error.message?.includes('network') || error.message?.includes('fetch')) {
+      errorCode = 'NETWORK_ERROR';
+    } else if (error.message?.includes('WASM') || error.message?.includes('wasm')) {
+      errorCode = 'WASM_LOAD_ERROR';
+    } else if (error.message?.includes('license') || error.message?.includes('auth')) {
+      errorCode = 'LICENSE_ERROR';
+    }
+
+    return new FacebetterError(
+      context ? `${context}: ${message}` : message,
+      errorCode
+    );
   }
 
   /**
    * Initializes the engine
+   * @param {Object} [options] - Initialization options
+   * @param {number} [options.timeout] - Timeout in milliseconds (default: 30000 for WASM, 10000 for auth)
+   * @param {number} [options.authTimeout] - Timeout for online authentication in milliseconds (default: 10000)
    * @returns {Promise<void>} Promise that resolves when initialization is complete
    */
-  async init() {
+  async init(options = {}) {
+    // 并发控制：如果已经初始化，直接返回
     if (this.initialized) {
       return;
     }
 
-    // Wait for WASM module to be loaded (started in constructor)
-    await this._wasmLoadPromise;
-    const Module = this._getWasmModule();
-
-    let licenseJsonToUse = this.licenseJson;
+    // 并发控制：如果正在初始化，返回同一个 Promise
+    if (this._initPromise) {
+      return this._initPromise;
+    }
 
-    // 如果用户提供了 appId 和 appKey（但没有提供 licenseJson），则在 JS 层发送 HTTP 请求
-    if (this.appId && this.appKey && !this.licenseJson && this._verifyAppKeyOnline) {
+    // 创建初始化 Promise
+    this._initPromise = (async () => {
       try {
-        // 在 JS 层调用 online_auth API 获取服务器响应
-        const authResponse = await this._verifyAppKeyOnline(this.appId, this.appKey);
-        
-        if (!authResponse) {
-          throw new FacebetterError('Failed to get server response from online_auth API');
+        const wasmTimeout = options.timeout || 30000;
+        const authTimeout = options.authTimeout || 10000;
+
+        // 等待 WASM 模块加载（带超时）
+        try {
+          await Promise.race([
+            this._wasmLoadPromise,
+            this._createTimeout(wasmTimeout, 'WASM module loading')
+          ]);
+        } catch (error) {
+          throw this._enhanceError(error, 'Failed to load WASM module');
         }
 
-        // 将服务器响应转换为 JSON 字符串，作为 licenseJson 传递给 WASM 层
-        licenseJsonToUse = JSON.stringify(authResponse);
-        console.log('Online auth response received, using as licenseJson');
-      } catch (error) {
-        throw new FacebetterError(`Failed to verify app key online: ${error.message}`);
-      }
-    }
+        const Module = this._getWasmModule();
 
-    // 如果用户直接提供了 licenseJson，则直接使用
-    // 如果通过 appId/appKey 获取到了响应，则使用响应作为 licenseJson
-    // WASM 层只需要验证 licenseJson，不需要发送 HTTP 请求
-    const enginePtr = Module.ccall(
-      'CreateBeautyEffectEngine',
-      'number',
-      ['string', 'string'],
-      [
-        this.resourcePath,
-        licenseJsonToUse || ''  // 使用 licenseJson 验证
-      ]
-    );
+        let licenseJsonToUse = this.licenseJson;
 
-    if (!enginePtr) {
-      throw new FacebetterError('Failed to create BeautyEffect engine');
-    }
+        // 如果用户提供了 appId 和 appKey（但没有提供 licenseJson），则在 JS 层发送 HTTP 请求
+        if (this.appId && this.appKey && !this.licenseJson && this._verifyAppKeyOnline) {
+          try {
+            // 在线认证（带超时）
+            const authResponse = await Promise.race([
+              this._verifyAppKeyOnline(this.appId, this.appKey),
+              this._createTimeout(authTimeout, 'Online authentication')
+            ]);
+            
+            if (!authResponse) {
+              throw new FacebetterError(
+                'Failed to get server response from online_auth API. The server returned an empty response.',
+                'AUTH_EMPTY_RESPONSE'
+              );
+            }
+
+            // 将服务器响应转换为 JSON 字符串，作为 licenseJson 传递给 WASM 层
+            licenseJsonToUse = JSON.stringify(authResponse);
+            console.log('Online auth response received, using as licenseJson');
+          } catch (error) {
+            if (error instanceof FacebetterError && error.code === 'TIMEOUT') {
+              throw new FacebetterError(
+                `Online authentication timed out after ${authTimeout}ms. Please check your network connection or provide licenseJson directly.`,
+                'AUTH_TIMEOUT'
+              );
+            }
+            throw this._enhanceError(error, 'Failed to verify app key online');
+          }
+        }
+
+        // 如果用户直接提供了 licenseJson，则直接使用
+        // 如果通过 appId/appKey 获取到了响应，则使用响应作为 licenseJson
+        // WASM 层只需要验证 licenseJson，不需要发送 HTTP 请求
+        const enginePtr = Module.ccall(
+          'CreateBeautyEffectEngine',
+          'number',
+          ['string', 'string'],
+          [
+            this.resourcePath,
+            licenseJsonToUse || ''  // 使用 licenseJson 验证
+          ]
+        );
+
+        if (!enginePtr) {
+          throw new FacebetterError(
+            'Failed to create BeautyEffect engine. This may be due to invalid license or resource path issues.',
+            'ENGINE_CREATE_FAILED'
+          );
+        }
+
+        this.enginePtr = enginePtr;
+        this.initialized = true;
+        this._initPromise = null; // 清除 Promise 缓存，允许重新初始化（如果需要）
+      } catch (error) {
+        this._initPromise = null; // 清除 Promise 缓存，允许重试
+        throw error;
+      }
+    })();
 
-    this.enginePtr = enginePtr;
-    this.initialized = true;
+    return this._initPromise;
   }
 
   /**
@@ -310,6 +407,7 @@ class BeautyEffectEngine {
     this.enginePtr = null;
     this.initialized = false;
     this.bufferSize = 0;
+    this._initPromise = null; // 清除初始化 Promise
     
     // Clean up offscreen canvas
     if (this._offscreenCanvas) {
@@ -790,7 +888,7 @@ async function verifyAppKeyOnline(appId, appKey) {
 /**
  * ESM Entry Point
  * For Vue/React/Vite/Webpack (ES Module)
- * Uses import.meta.url for automatic path resolution
+ * Uses facebetter-core npm package for WASM module loading
  */
 
 
@@ -798,49 +896,13 @@ async function verifyAppKeyOnline(appId, appKey) {
 let wasmModuleInstance = null;
 let wasmModulePromise = null;
 
-/**
- * Gets the base path of the current module
- * Uses import.meta.url (ES Module equivalent of __dirname)
- * @returns {string} Base path of the current module (with trailing slash)
- */
-function getModuleBasePath() {
-  try {
-    const url = new URL('.', import.meta.url);
-    return url.href;
-  } catch (e) {
-    // Fallback
-    return './';
-  }
-}
-
-/**
- * Resolves a relative path to absolute URL (ESM version)
- * Handles various path formats
- * @param {string} relativePath - Relative path
- * @returns {string} Absolute URL
- */
-function resolvePath(relativePath) {
-  // If relativePath is already absolute, return as-is
-  if (relativePath.startsWith('http://') || relativePath.startsWith('https://') || relativePath.startsWith('//')) {
-    return relativePath;
-  }
-  
-  try {
-    return new URL(relativePath, import.meta.url).href;
-  } catch (e) {
-    // Fallback
-    const base = getModuleBasePath();
-    const cleanPath = relativePath.replace(/^\.\//, '');
-    return base + cleanPath;
-  }
-}
-
 /**
  * Loads the WebAssembly module (ESM version)
  * Supports ESM format WASM modules (generated with MODULARIZE and EXPORT_ES6)
+ * With SINGLE_FILE=1, WASM binary and data files are embedded in the JS file
  * @param {Object} [options] - Options
- * @param {string} [options.wasmUrl] - Custom WASM URL (auto-detected if not provided)
- * @param {Function} [options.locateFile] - Custom locateFile function
+ * @param {string} [options.wasmUrl] - Custom WASM module URL (defaults to facebetter-core npm package)
+ * @param {Function} [options.locateFile] - Custom locateFile function (usually not needed with SINGLE_FILE=1)
  * @returns {Promise<Object>} Promise that resolves with the WASM module
  */
 async function loadWasmModule(options = {}) {
@@ -854,72 +916,23 @@ async function loadWasmModule(options = {}) {
 
   wasmModulePromise = (async () => {
     // Try to import the WASM module factory
-    // facebetter_wasm.js is an Emscripten-generated ESM file (with MODULARIZE and EXPORT_ES6)
+    // facebetter-core.js is an Emscripten-generated ESM file (with MODULARIZE and EXPORT_ES6)
+    // It's provided by the facebetter-core npm package
     let FaceBetterModuleFactory;
     
     try {
-      // Get the WASM module URL
-      let wasmModuleUrl;
+      // Get the WASM module
       if (options.wasmUrl) {
-        wasmModuleUrl = options.wasmUrl;
+        // If custom URL is provided, use it (for backward compatibility or custom builds)
+        const wasmModule = await import(options.wasmUrl);
+        FaceBetterModuleFactory = wasmModule.default || wasmModule.createFaceBetterModule;
       } else {
-        // Use relative path for build time
-        // At runtime in Vite, the path will be resolved correctly
-        wasmModuleUrl = resolvePath('./facebetter_wasm.js');
+        // Import from facebetter-core npm package
+        const wasmModule = await import('facebetter-core');
         
-        // In browser runtime (Vite), try to use package exports
-        if (typeof window !== 'undefined') {
-          try {
-            // Try to use package exports path (Vite will handle it at runtime)
-            const pkgPath = 'facebetter/wasm.js';
-            // Use Function constructor to avoid Rollup static analysis
-            const dynamicImport = new Function('path', 'return import(path)');
-            const wasmModule = await dynamicImport(pkgPath);
-            if (wasmModule && (wasmModule.default || wasmModule.createFaceBetterModule)) {
-              // ESM format: module.default is the factory function
-              FaceBetterModuleFactory = wasmModule.default || wasmModule.createFaceBetterModule;
-              if (FaceBetterModuleFactory) {
-                // Configure locateFile for WASM and data files
-                const moduleOptions = {
-                  locateFile: options.locateFile || function(path, prefix) {
-                    // Auto-resolve .wasm and .data files
-                    if (path.endsWith('.wasm') || path.endsWith('.data')) {
-                      try {
-                        if (typeof import.meta.resolve === 'function') {
-                          if (path.endsWith('.wasm')) {
-                            return import.meta.resolve('facebetter/wasm');
-                          } else if (path.endsWith('.data')) {
-                            const wasmUrl = import.meta.resolve('facebetter/wasm');
-                            return wasmUrl.replace(/\.wasm$/, '.data');
-                          }
-                        }
-                      } catch (e) {
-                        // Fallback
-                      }
-                      return resolvePath(path);
-                    }
-                    return prefix + path;
-                  },
-                  ...options
-                };
-                wasmModuleInstance = await FaceBetterModuleFactory(moduleOptions);
-                wasmModuleInstance.ready = true;
-                return wasmModuleInstance;
-              }
-            }
-          } catch (e) {
-            // Fallback to direct import below
-          }
-        }
+        // Get the factory function (default export or named export)
+        FaceBetterModuleFactory = wasmModule.default || wasmModule.createFaceBetterModule;
       }
-
-      // Load WASM module using dynamic import (ESM format)
-      // Emscripten with MODULARIZE=1 and EXPORT_ES6=1 generates:
-      // export default function createFaceBetterModule(options) { ... }
-      const wasmModule = await import(wasmModuleUrl);
-      
-      // Get the factory function (default export or named export)
-      FaceBetterModuleFactory = wasmModule.default || wasmModule.createFaceBetterModule;
       
       if (!FaceBetterModuleFactory) {
         throw new Error('WASM module does not export createFaceBetterModule function');
@@ -928,25 +941,13 @@ async function loadWasmModule(options = {}) {
       throw new FacebetterError(`Failed to load WASM module: ${e.message}`);
     }
 
-    // Configure locateFile for WASM and data files
+    // Configure module options
+    // With SINGLE_FILE=1, WASM binary and data files are embedded in the JS file
+    // No need to handle .wasm and .data file paths separately
     const moduleOptions = {
       locateFile: options.locateFile || function(path, prefix) {
-        // Auto-resolve .wasm and .data files
-        if (path.endsWith('.wasm') || path.endsWith('.data')) {
-          try {
-            if (typeof import.meta.resolve === 'function') {
-              if (path.endsWith('.wasm')) {
-                return import.meta.resolve('facebetter/wasm');
-              } else if (path.endsWith('.data')) {
-                const wasmUrl = import.meta.resolve('facebetter/wasm');
-                return wasmUrl.replace(/\.wasm$/, '.data');
-              }
-            }
-          } catch (e) {
-            // Fallback
-          }
-          return resolvePath(path);
-        }
+        // With SINGLE_FILE=1, Emscripten handles embedded files automatically
+        // Custom locateFile is only needed if user provides one
         return prefix + path;
       },
       ...options