id-scanner-lib 1.7.0 → 2.0.0

package/dist/id-scanner-lib.js

@@ -5,251 +5,95 @@
 })(this, (function (exports, tesseract_js, imageCompression, jsQR) { 'use strict';
 
   /**
-   * @file 配置管理器
-   * @description 提供全局配置管理功能
+   * @file 配置管理器 + Scanner 配置
+   * @description 提供全局配置管理功能 + Scanner v2.0 配置接口
    * @module core/config
    */
-  /**
-   * 配置管理器
-   * 负责存储和管理应用程序的配置
-   */
+  // ============================================================
+  // 原有 ConfigManager（保持向后兼容）
+  // ============================================================
   class ConfigManager {
-      /**
-       * 私有构造函数
-       */
       constructor() {
-          /** 配置存储 */
           this.config = {};
-          /** 配置变更回调 */
           this.changeCallbacks = new Map();
-          /** 初始化状态 */
           this.initialized = false;
-          // 设置默认配置
           this._resetDefaults();
       }
-      /**
-       * 获取单例实例
-       */
       static getInstance() {
           if (!ConfigManager.instance) {
               ConfigManager.instance = new ConfigManager();
           }
           return ConfigManager.instance;
       }
-      /**
-       * 重置单例实例（主要用于测试）
-       */
       static resetInstance() {
           ConfigManager.instance = undefined;
       }
-      /**
-       * 重置为默认配置
-       */
       _resetDefaults() {
           this.config = {
               debug: false,
               logLevel: 'info',
-              camera: {
-                  resolution: {
-                      width: 1280,
-                      height: 720
-                  },
-                  frameRate: 30,
-                  facingMode: 'environment'
+              modelPath: '/models',
+              maxRetries: 3,
+              retryDelay: 1000,
+              detectionInterval: 100,
+              face: {
+                  enabled: true,
+                  confidenceThreshold: 0.5,
+                  maxFaces: 10,
+              },
+              idCard: {
+                  enabled: false,
+              },
+              qr: {
+                  enabled: false,
               },
-              performance: {
-                  useCache: true
-              }
           };
           this.initialized = true;
       }
-      /**
-       * 获取配置值
-       * @param key 配置键，支持点号分隔的路径
-       * @param defaultValue 默认值
-       */
       get(key, defaultValue) {
-          const value = this.getNestedValue(this.config, key);
-          return (value !== undefined) ? value : defaultValue;
+          const keys = key.split('.');
+          let value = this.config;
+          for (const k of keys) {
+              value = value?.[k];
+          }
+          return (value !== undefined ? value : defaultValue);
       }
-      /**
-       * 设置配置值
-       * @param key 配置键，支持点号分隔的路径
-       * @param value 配置值
-       */
       set(key, value) {
-          const oldValue = this.get(key);
-          // 如果值相同，不做任何事
-          if (oldValue === value) {
-              return;
+          const keys = key.split('.');
+          let target = this.config;
+          for (let i = 0; i < keys.length - 1; i++) {
+              if (!target[keys[i]])
+                  target[keys[i]] = {};
+              target = target[keys[i]];
+          }
+          const oldValue = target[keys[keys.length - 1]];
+          target[keys[keys.length - 1]] = value;
+          const callbacks = this.changeCallbacks.get(key);
+          if (callbacks) {
+              callbacks.forEach(cb => cb(value, oldValue));
           }
-          this.setNestedValue(this.config, key, value);
-          // 触发变更回调
-          this.triggerChangeCallbacks(key, value, oldValue);
-      }
-      /**
-       * 批量更新配置
-       * @param config 配置对象
-       */
-      updateConfig(config) {
-          Object.entries(config).forEach(([key, value]) => {
-              this.set(key, value);
-          });
-      }
-      /**
-       * 重置为默认配置
-       */
-      reset() {
-          const oldConfig = { ...this.config };
-          // 使用私有 reset 方法重建默认配置
-          this.config = {
-              debug: false,
-              logLevel: 'info',
-              camera: {
-                  resolution: {
-                      width: 1280,
-                      height: 720
-                  },
-                  frameRate: 30,
-                  facingMode: 'environment'
-              },
-              performance: {
-                  useCache: true
-              }
-          };
-          // 触发所有回调
-          Object.keys(oldConfig).forEach(key => {
-              this.triggerChangeCallbacks(key, this.get(key), oldConfig[key]);
-          });
       }
-      /**
-       * 注册配置变更回调
-       * @param key 配置键
-       * @param callback 回调函数
-       */
-      onConfigChange(key, callback) {
+      onChange(key, callback) {
           if (!this.changeCallbacks.has(key)) {
               this.changeCallbacks.set(key, []);
           }
           this.changeCallbacks.get(key).push(callback);
       }
-      /**
-       * 移除配置变更回调
-       * @param key 配置键
-       * @param callback 特定回调函数，如不提供则移除所有
-       */
-      offConfigChange(key, callback) {
-          if (!this.changeCallbacks.has(key)) {
-              return;
-          }
-          if (callback) {
-              // 移除特定回调
-              const callbacks = this.changeCallbacks.get(key);
+      /** @deprecated Use onChange instead */
+      onConfigChange(key, callback) {
+          this.onChange(key, callback);
+      }
+      removeChangeCallback(key, callback) {
+          const callbacks = this.changeCallbacks.get(key);
+          if (callbacks) {
               const index = callbacks.indexOf(callback);
-              if (index !== -1) {
+              if (index > -1)
                   callbacks.splice(index, 1);
-              }
-              // 如果没有回调，删除键
-              if (callbacks.length === 0) {
-                  this.changeCallbacks.delete(key);
-              }
-          }
-          else {
-              // 移除所有回调
-              this.changeCallbacks.delete(key);
           }
       }
-      /**
-       * 获取嵌套值
-       * @param obj 对象
-       * @param path 路径
-       */
-      getNestedValue(obj, path) {
-          // 处理根路径
-          if (!path) {
-              return obj;
-          }
-          // 处理嵌套路径
-          const parts = path.split('.');
-          let current = obj;
-          for (const part of parts) {
-              if (current === undefined || current === null) {
-                  return undefined;
-              }
-              current = current[part];
-          }
-          return current;
-      }
-      /**
-       * 设置嵌套值
-       * @param obj 对象
-       * @param path 路径
-       * @param value 值
-       */
-      setNestedValue(obj, path, value) {
-          // 处理根路径
-          if (!path) {
-              return;
-          }
-          // 处理嵌套路径
-          const parts = path.split('.');
-          let current = obj;
-          // 遍历路径，直到倒数第二部分
-          for (let i = 0; i < parts.length - 1; i++) {
-              const part = parts[i];
-              // 如果不存在，创建新对象
-              if (current[part] === undefined || current[part] === null || typeof current[part] !== 'object') {
-                  current[part] = {};
-              }
-              current = current[part];
-          }
-          // 设置最终值
-          current[parts[parts.length - 1]] = value;
-      }
-      /**
-       * 触发变更回调
-       * @param key 配置键
-       * @param value 新值
-       * @param oldValue 旧值
-       */
-      triggerChangeCallbacks(key, value, oldValue) {
-          // 触发特定键的回调
-          if (this.changeCallbacks.has(key)) {
-              const callbacks = this.changeCallbacks.get(key);
-              callbacks.forEach(callback => {
-                  try {
-                      callback(value, oldValue);
-                  }
-                  catch (error) {
-                      console.error(`Error in config change callback for key ${key}:`, error);
-                  }
-              });
-          }
-          // 触发父路径的回调
-          const parts = key.split('.');
-          while (parts.length > 1) {
-              parts.pop();
-              const parentKey = parts.join('.');
-              if (this.changeCallbacks.has(parentKey)) {
-                  const parentValue = this.get(parentKey);
-                  this.changeCallbacks.get(parentKey).forEach(callback => {
-                      try {
-                          callback(parentValue, parentValue);
-                      }
-                      catch (error) {
-                          console.error(`Error in config change callback for parent key ${parentKey}:`, error);
-                      }
-                  });
-              }
-          }
-      }
-      /**
-       * 检查模块是否启用
-       * @param moduleName 模块名称
-       */
-      isModuleEnabled(moduleName) {
-          const key = `modules.${moduleName}.enabled`;
-          return this.get(key) ?? false;
+      reset() {
+          this.config = {};
+          this._resetDefaults();
       }
   }
 
@@ -4776,157 +4620,106 @@
   }
 
   /**
-   * @file 错误处理模块
-   * @description 定义ID-Scanner-Lib的错误类层次结构
+   * @file Scanner Errors
+   * @description Error classes for Scanner
    * @module core/errors
    */
   /**
-   * ID-Scanner-Lib 基础错误类
-   * 所有库特定错误的基类
+   * Scanner specific error
    */
-  class IDScannerError extends Error {
+  class ScannerError extends Error {
       /**
-       * 构造函数
-       * @param message 错误消息
-       * @param options 错误选项
+       * Create a ScannerError
+       * @param message Error message
+       * @param code Error code
+       * @param module Module name
        */
-      constructor(message, options) {
+      constructor(message, code, module) {
           super(message);
-          // 设置错误名称
-          this.name = this.constructor.name;
-          // 设置错误代码
-          this.code = options?.code || 'UNKNOWN_ERROR';
-          // 设置错误原因
-          this.cause = options?.cause;
-          // 捕获堆栈 (Node.js专有，浏览器环境忽略)
-          if (typeof Error.captureStackTrace === 'function') {
-              Error.captureStackTrace(this, this.constructor);
-          }
+          this.name = 'ScannerError';
+          this.code = code;
+          this.module = module;
       }
   }
   /**
-   * 初始化错误
-   * 当库初始化失败时抛出
+   * Camera access error
    */
-  class InitializationError extends IDScannerError {
-      constructor(message, details) {
-          super(`初始化失败: ${message}${details ? ` (${details})` : ''}`, { code: 'INIT_FAILED' });
-          this.name = 'InitializationError';
+  class CameraAccessError extends Error {
+      constructor(message = 'Camera access denied') {
+          super(message);
+          this.name = 'CameraAccessError';
       }
   }
   /**
-   * 设备错误
-   * 当访问硬件设备(如摄像头)失败时抛出
+   * Device error
    */
-  class DeviceError extends IDScannerError {
-      constructor(message) {
-          super(`设备错误: ${message}`, { code: 'DEVICE_ERROR' });
+  class DeviceError extends Error {
+      constructor(message = 'Device error') {
+          super(message);
           this.name = 'DeviceError';
       }
   }
   /**
-   * 摄像头访问错误
-   * 当无法访问或启动摄像头时抛出
+   * Resource load error
    */
-  class CameraAccessError extends IDScannerError {
-      constructor(message, options) {
-          super(`摄像头访问失败: ${message}`, {
-              code: options?.code || 'CAMERA_ACCESS_FAILED',
-              cause: options?.cause
-          });
-          this.name = 'CameraAccessError';
+  class ResourceLoadError extends Error {
+      constructor(message = 'Failed to load resource', id) {
+          super(message);
+          this.name = 'ResourceLoadError';
+          this.id = id;
       }
   }
   /**
-   * 人脸检测错误
-   * 当人脸检测过程失败时抛出
+   * Face detection error
    */
-  class FaceDetectionError extends IDScannerError {
-      constructor(message) {
-          super(`人脸检测失败: ${message}`, { code: 'FACE_DETECTION_FAILED' });
+  class FaceDetectionError extends Error {
+      constructor(message = 'Face detection failed') {
+          super(message);
           this.name = 'FaceDetectionError';
       }
   }
   /**
-   * 人脸比对错误
-   * 当人脸比对过程失败时抛出
+   * Face comparison error
    */
-  class FaceComparisonError extends IDScannerError {
-      constructor(message) {
-          super(`人脸比对失败: ${message}`, { code: 'FACE_COMPARISON_FAILED' });
+  class FaceComparisonError extends Error {
+      constructor(message = 'Face comparison failed') {
+          super(message);
           this.name = 'FaceComparisonError';
       }
   }
   /**
-   * 活体检测错误
-   * 当活体检测过程失败时抛出
-   */
-  class LivenessDetectionError extends IDScannerError {
-      constructor(message) {
-          super(`活体检测失败: ${message}`, { code: 'LIVENESS_DETECTION_FAILED' });
-          this.name = 'LivenessDetectionError';
-      }
-  }
-  /**
-   * OCR识别错误
-   * 当OCR文字识别失败时抛出
-   */
-  class OCRProcessingError extends IDScannerError {
-      constructor(message) {
-          super(`OCR处理失败: ${message}`, { code: 'OCR_PROCESSING_FAILED' });
-          this.name = 'OCRProcessingError';
-      }
-  }
-  /**
-   * 二维码扫描错误
-   * 当二维码扫描失败时抛出
+   * Initialization error
    */
-  class QRScanError extends IDScannerError {
-      constructor(message) {
-          super(`二维码扫描失败: ${message}`, { code: 'QR_SCAN_FAILED' });
-          this.name = 'QRScanError';
-      }
-  }
-  /**
-   * 身份证检测错误
-   * 当身份证检测失败时抛出
-   */
-  class IDCardDetectionError extends IDScannerError {
-      constructor(message) {
-          super(`身份证检测失败: ${message}`, { code: 'ID_CARD_DETECTION_FAILED' });
-          this.name = 'IDCardDetectionError';
-      }
-  }
-  /**
-   * 资源加载错误
-   * 当无法加载必要资源(如模型)时抛出
-   */
-  class ResourceLoadError extends IDScannerError {
-      constructor(resource, reason) {
-          super(`无法加载资源 ${resource}: ${reason}`, { code: 'RESOURCE_LOAD_FAILED' });
-          this.name = 'ResourceLoadError';
+  class InitializationError extends Error {
+      constructor(message = 'Initialization failed') {
+          super(message);
+          this.name = 'InitializationError';
       }
   }
   /**
-   * 参数错误
-   * 当提供的参数无效时抛出
+   * Liveness detection error
    */
-  class InvalidArgumentError extends IDScannerError {
-      constructor(paramName, reason) {
-          super(`无效的参数 ${paramName}: ${reason}`, { code: 'INVALID_ARGUMENT' });
-          this.name = 'InvalidArgumentError';
+  class LivenessDetectionError extends Error {
+      constructor(message = 'Liveness detection failed') {
+          super(message);
+          this.name = 'LivenessDetectionError';
       }
   }
   /**
-   * 不支持错误
-   * 当尝试使用不支持的功能或当前环境无法使用的功能时抛出
+   * Error codes for Scanner
    */
-  class NotSupportedError extends IDScannerError {
-      constructor(feature) {
-          super(`不支持的功能: ${feature}`, { code: 'NOT_SUPPORTED' });
-          this.name = 'NotSupportedError';
-      }
-  }
+  const ErrorCodes = {
+      /** Scanner not initialized */
+      NOT_INITIALIZED: 'SCANNER_001',
+      /** Module not found */
+      MODULE_NOT_FOUND: 'SCANNER_002',
+      /** Detection failed */
+      DETECTION_FAILED: 'SCANNER_003',
+      /** Camera access denied */
+      CAMERA_ACCESS_DENIED: 'CAMERA_001',
+      /** Camera not available */
+      CAMERA_NOT_AVAILABLE: 'CAMERA_002',
+  };
 
   /* eslint-disable */
   /**
@@ -5031,27 +4824,23 @@
   exports.ConsoleLogHandler = ConsoleLogHandler;
   exports.DEFAULT_FORMATS = DEFAULT_FORMATS;
   exports.DeviceError = DeviceError;
+  exports.ErrorCodes = ErrorCodes;
   exports.FaceComparisonError = FaceComparisonError;
   exports.FaceDetectionError = FaceDetectionError;
   exports.FaceModule = FaceModule;
-  exports.IDCardDetectionError = IDCardDetectionError;
   exports.IDCardModule = IDCardModule;
   exports.IDScanner = IDScanner;
-  exports.IDScannerError = IDScannerError;
   exports.InitializationError = InitializationError;
-  exports.InvalidArgumentError = InvalidArgumentError;
   exports.LivenessDetectionError = LivenessDetectionError;
   exports.LoadingStateManager = LoadingStateManager;
   exports.LogLevel = LogLevel;
   exports.Logger = Logger;
   exports.MemoryLogHandler = MemoryLogHandler;
   exports.ModuleManager = ModuleManager;
-  exports.NotSupportedError = NotSupportedError;
-  exports.OCRProcessingError = OCRProcessingError;
   exports.QRCodeModule = QRCodeModule;
-  exports.QRScanError = QRScanError;
   exports.RemoteLogHandler = RemoteLogHandler;
   exports.ResourceLoadError = ResourceLoadError;
+  exports.ScannerError = ScannerError;
   exports.TaggedLogger = TaggedLogger;
   exports.createLoadingStateManager = createLoadingStateManager;
   exports.default = IDScanner;