id-scanner-lib 1.3.3 → 1.6.2

package/src/index.ts

@@ -1,989 +1,167 @@
 /**
- * @file ID扫描识别库主入口文件
- * @description 提供身份证识别与二维码、条形码扫描功能的纯前端TypeScript库
- * @module IDScannerLib
- * @version 1.3.0
- * @license MIT
+ * @file 主入口文件
+ * @description ID Scanner库的主入口点，提供统一的API和模块导出
+ * @module index
  */
 
-import { Camera, CameraOptions } from "./utils/camera"
-import { IDCardInfo, DetectionResult } from "./utils/types"
-import {
-  ImageProcessor,
-  ImageProcessorOptions,
-  ImageCompressionOptions,
-} from "./utils/image-processing"
-
-// 先只导入类型定义，不导入实际实现
-import type { QRScannerOptions } from "./scanner/qr-scanner"
-import type { BarcodeScannerOptions } from "./scanner/barcode-scanner"
-
-// 导入防伪检测器
-import {
-  AntiFakeDetector,
-  AntiFakeDetectionResult,
-} from "./id-recognition/anti-fake-detector"
+import { ModuleManager } from './core/module-manager';
+import { IDCardModule } from './modules/id-card';
+import { QRCodeModule } from './modules/qrcode';
+import { FaceModule } from './modules/face';
+import { VERSION, BUILD_DATE } from './version';
+import { Logger, LogLevel } from './core/logger';
+import { IDCardModuleOptions } from './modules/id-card/types';
+import { QRCodeModuleOptions } from './modules/qrcode/types';
+import { FaceModuleOptions } from './modules/face/types';
 
 /**
- * IDScanner配置选项接口
+ * IDScanner配置选项
  */
 export interface IDScannerOptions {
-  cameraOptions?: CameraOptions
-  qrScannerOptions?: QRScannerOptions
-  barcodeScannerOptions?: BarcodeScannerOptions
-  onQRCodeScanned?: (result: string) => void
-  onBarcodeScanned?: (result: string) => void
-  onIDCardScanned?: (info: IDCardInfo) => void
-  onImageProcessed?: (processedImage: ImageData | File) => void
-  onAntiFakeDetected?: (result: AntiFakeDetectionResult) => void
-  onError?: (error: Error) => void
+  /** 日志级别 */
+  logLevel?: LogLevel;
+  /** 是否启用身份证识别模块 */
+  enableIDCard?: boolean;
+  /** 是否启用二维码识别模块 */
+  enableQRCode?: boolean;
+  /** 是否启用人脸识别模块 */
+  enableFace?: boolean;
+  /** 身份证模块配置 */
+  idCard?: IDCardModuleOptions;
+  /** 二维码模块配置 */
+  qrCode?: QRCodeModuleOptions;
+  /** 人脸识别模块配置 */
+  face?: FaceModuleOptions;
 }
 
 /**
- * IDScanner 主类
- *
- * 整合二维码、条形码扫描和身份证识别功能，提供统一的接口
- * 使用动态导入实现按需加载
+ * IDScanner类
+ * 提供整合的身份证、二维码和人脸识别功能
  */
 export class IDScanner {
-  private camera: Camera
-  private scanMode: "qr" | "barcode" | "idcard" = "qr"
-  private videoElement: HTMLVideoElement | null = null
-  private scanning = false
-  private qrModule: any = null
-  private ocrModule: any = null
-  private scanTimer: number | null = null
-  private isQRModuleLoaded: boolean = false
-  private isOCRModuleLoaded: boolean = false
-
-  // 新增防伪检测器
-  private antiFakeDetector: AntiFakeDetector | null = null
-  private isAntiFakeModuleLoaded: boolean = false
-
+  /** 版本号 */
+  public static readonly VERSION = VERSION;
+  /** 构建日期 */
+  public static readonly BUILD_DATE = BUILD_DATE;
+  
+  /** 模块管理器 */
+  private moduleManager: ModuleManager;
+  /** 是否已经初始化 */
+  private initialized = false;
+  /** 日志工具 */
+  private logger: Logger;
+  
   /**
    * 构造函数
    * @param options 配置选项
    */
-  constructor(private options: IDScannerOptions = {}) {
-    this.camera = new Camera(options.cameraOptions)
-  }
-
-  /**
-   * 初始化模块
-   * 根据需要初始化OCR引擎和防伪检测模块
-   */
-  async initialize(): Promise<void> {
-    try {
-      // 预加载OCR模块但不初始化
-      if (!this.isOCRModuleLoaded) {
-        // 动态导入OCR模块
-        const OCRModule = await import("./ocr-module").then((m) => m.OCRModule)
-        this.ocrModule = new OCRModule({
-          cameraOptions: this.options.cameraOptions,
-          onIDCardScanned: this.options.onIDCardScanned,
-          onError: this.options.onError,
-        })
-        this.isOCRModuleLoaded = true
-
-        // 初始化OCR模块
-        await this.ocrModule.initialize()
-      }
-
-      // 初始化防伪检测模块
-      if (!this.isAntiFakeModuleLoaded) {
-        this.antiFakeDetector = new AntiFakeDetector()
-        this.isAntiFakeModuleLoaded = true
-      }
-
-      console.log("IDScanner初始化完成")
-    } catch (error) {
-      console.error("初始化失败:", error)
-      this.handleError(error as Error)
-      throw error
-    }
-  }
-
-  /**
-   * 初始化OCR模块
-   */
-  private async initOCRModule(): Promise<void> {
-    if (this.isOCRModuleLoaded) return
-
-    try {
-      // 动态导入OCR模块
-      const OCRModule = await import("./ocr-module").then((m) => m.OCRModule)
-      this.ocrModule = new OCRModule({
-        cameraOptions: this.options.cameraOptions,
-        onIDCardScanned: this.options.onIDCardScanned,
-        onError: this.options.onError,
-      })
-      this.isOCRModuleLoaded = true
-
-      // 初始化OCR模块
-      await this.ocrModule.initialize()
-    } catch (error) {
-      console.error("OCR模块初始化失败:", error)
-      throw error
-    }
-  }
-
-  /**
-   * 启动二维码扫描
-   * @param videoElement HTML视频元素
-   */
-  async startQRScanner(videoElement: HTMLVideoElement): Promise<void> {
-    this.stop()
-    this.videoElement = videoElement
-    this.scanMode = "qr"
-
-    try {
-      // 动态加载二维码模块
-      if (!this.isQRModuleLoaded) {
-        const ScannerModule = await import("./qr-module").then(
-          (m) => m.ScannerModule
-        )
-        this.qrModule = new ScannerModule({
-          cameraOptions: this.options.cameraOptions,
-          qrScannerOptions: this.options.qrScannerOptions,
-          barcodeScannerOptions: this.options.barcodeScannerOptions,
-          onQRCodeScanned: this.options.onQRCodeScanned,
-          onBarcodeScanned: this.options.onBarcodeScanned,
-          onError: this.options.onError,
-        })
-        this.isQRModuleLoaded = true
-      }
-
-      await this.qrModule.startQRScanner(videoElement)
-    } catch (error) {
-      this.handleError(error as Error)
-    }
-  }
-
-  /**
-   * 启动条形码扫描
-   * @param videoElement HTML视频元素
-   */
-  async startBarcodeScanner(videoElement: HTMLVideoElement): Promise<void> {
-    this.stop()
-    this.videoElement = videoElement
-    this.scanMode = "barcode"
-
-    try {
-      // 动态加载二维码模块
-      if (!this.isQRModuleLoaded) {
-        const ScannerModule = await import("./qr-module").then(
-          (m) => m.ScannerModule
-        )
-        this.qrModule = new ScannerModule({
-          cameraOptions: this.options.cameraOptions,
-          qrScannerOptions: this.options.qrScannerOptions,
-          barcodeScannerOptions: this.options.barcodeScannerOptions,
-          onQRCodeScanned: this.options.onQRCodeScanned,
-          onBarcodeScanned: this.options.onBarcodeScanned,
-          onError: this.options.onError,
-        })
-        this.isQRModuleLoaded = true
-      }
-
-      await this.qrModule.startBarcodeScanner(videoElement)
-    } catch (error) {
-      this.handleError(error as Error)
+  constructor(options: IDScannerOptions = {}) {
+    // 配置日志级别
+    this.logger = Logger.getInstance();
+    if (options.logLevel !== undefined) {
+      this.logger.setLevel(options.logLevel);
     }
-  }
-
-  /**
-   * 启动身份证扫描
-   * @param videoElement HTML视频元素
-   */
-  async startIDCardScanner(videoElement: HTMLVideoElement): Promise<void> {
-    this.stop()
-    this.videoElement = videoElement
-    this.scanMode = "idcard"
-
-    try {
-      // 检查OCR模块是否已加载，若未加载则自动初始化
-      if (!this.isOCRModuleLoaded) {
-        await this.initialize()
-      }
-
-      await this.ocrModule.startIDCardScanner(videoElement)
-    } catch (error) {
-      this.handleError(error as Error)
+    
+    this.moduleManager = ModuleManager.getInstance();
+    
+    // 注册模块
+    if (options.enableIDCard !== false) {
+      this.moduleManager.register(new IDCardModule(options.idCard));
     }
-  }
-
-  /**
-   * 停止扫描
-   */
-  stop(): void {
-    if (this.scanMode === "qr" || this.scanMode === "barcode") {
-      if (this.qrModule) {
-        this.qrModule.stop()
-      }
-    } else if (this.scanMode === "idcard") {
-      if (this.ocrModule) {
-        this.ocrModule.stop()
-      }
+    
+    if (options.enableQRCode !== false) {
+      this.moduleManager.register(new QRCodeModule(options.qrCode));
     }
-  }
-
-  /**
-   * 处理错误
-   */
-  private handleError(error: Error): void {
-    if (this.options.onError) {
-      this.options.onError(error)
-    } else {
-      console.error("IDScanner错误:", error)
+    
+    if (options.enableFace !== false) {
+      this.moduleManager.register(new FaceModule(options.face));
     }
   }
 
   /**
-   * 释放资源
+   * 初始化库
    */
-  async terminate(): Promise<void> {
-    this.stop()
-
-    // 释放OCR资源
-    if (this.isOCRModuleLoaded && this.ocrModule) {
-      await this.ocrModule.terminate()
-      this.ocrModule = null
-      this.isOCRModuleLoaded = false
+  public async initialize(): Promise<void> {
+    if (this.initialized) {
+      return;
     }
 
-    // 释放QR扫描资源
-    if (this.isQRModuleLoaded && this.qrModule) {
-      this.qrModule = null
-      this.isQRModuleLoaded = false
-    }
+    this.logger.info('IDScanner', `初始化 IDScanner v${VERSION}`);
 
-    // 释放防伪检测资源
-    if (this.antiFakeDetector) {
-      this.antiFakeDetector.dispose()
-      this.antiFakeDetector = null
-      this.isAntiFakeModuleLoaded = false
-    }
-  }
-
-  /**
-   * 处理图片中的二维码
-   * @param imageSource 图片源，可以是Image元素、Canvas元素或URL字符串
-   * @returns 返回Promise，解析为扫描结果
-   */
-  async processQRCodeImage(
-    imageSource: HTMLImageElement | HTMLCanvasElement | string | File
-  ): Promise<string> {
     try {
-      // 动态加载二维码模块
-      if (!this.isQRModuleLoaded) {
-        const ScannerModule = await import("./qr-module").then(
-          (m) => m.ScannerModule
-        )
-        this.qrModule = new ScannerModule({
-          qrScannerOptions: this.options.qrScannerOptions,
-          onQRCodeScanned: this.options.onQRCodeScanned,
-          onError: this.options.onError,
-        })
-        this.isQRModuleLoaded = true
-      }
-
-      // 处理不同类型的图片源
-      let imageElement: HTMLImageElement
-
-      if (imageSource instanceof File) {
-        // 如果是File对象，创建新的Image元素并加载图片
-        imageElement = new Image()
-        imageElement.crossOrigin = "anonymous" // 处理跨域图片
-        const url = URL.createObjectURL(imageSource)
-        await new Promise((resolve, reject) => {
-          imageElement.onload = resolve
-          imageElement.onerror = reject
-          imageElement.src = url
-        })
-        // 使用后释放URL对象
-        URL.revokeObjectURL(url)
-      } else if (typeof imageSource === "string") {
-        // 如果是URL字符串，创建新的Image元素并加载图片
-        imageElement = new Image()
-        imageElement.crossOrigin = "anonymous" // 处理跨域图片
-        await new Promise((resolve, reject) => {
-          imageElement.onload = resolve
-          imageElement.onerror = reject
-          imageElement.src = imageSource
-        })
-      } else if (imageSource instanceof HTMLImageElement) {
-        // 如果已经是Image元素，直接使用
-        imageElement = imageSource
-      } else if (imageSource instanceof HTMLCanvasElement) {
-        // 如果是Canvas元素，创建Image并从Canvas获取数据
-        imageElement = new Image()
-        imageElement.src = imageSource.toDataURL()
-        await new Promise((resolve) => {
-          imageElement.onload = resolve
-        })
-      } else {
-        throw new Error("不支持的图片源类型")
-      }
+      // 初始化所有模块
+      await this.moduleManager.initialize();
 
-      // 获取图像数据
-      const canvas = document.createElement("canvas")
-      canvas.width = imageElement.naturalWidth
-      canvas.height = imageElement.naturalHeight
-      const ctx = canvas.getContext("2d")
-
-      if (!ctx) {
-        throw new Error("无法创建Canvas上下文")
-      }
-
-      ctx.drawImage(imageElement, 0, 0)
-      const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height)
-
-      // 使用QR模块处理图像
-      return this.qrModule.processQRCodeImage(imageData)
+      this.initialized = true;
+      this.logger.info('IDScanner', 'IDScanner初始化完成');
     } catch (error) {
-      this.handleError(error as Error)
-      throw error
+      this.logger.error('IDScanner', 'IDScanner初始化失败', error as Error);
+      throw new Error(`IDScanner初始化失败: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
 
   /**
-   * 处理图片中的条形码
-   * @param imageSource 图片源，可以是Image元素、Canvas元素或URL字符串
-   * @returns 返回Promise，解析为扫描结果
+   * 获取身份证模块实例
+   * @returns 身份证模块
    */
-  async processBarcodeImage(
-    imageSource: HTMLImageElement | HTMLCanvasElement | string | File
-  ): Promise<string> {
-    try {
-      // 动态加载二维码模块
-      if (!this.isQRModuleLoaded) {
-        const ScannerModule = await import("./qr-module").then(
-          (m) => m.ScannerModule
-        )
-        this.qrModule = new ScannerModule({
-          barcodeScannerOptions: this.options.barcodeScannerOptions,
-          onBarcodeScanned: this.options.onBarcodeScanned,
-          onError: this.options.onError,
-        })
-        this.isQRModuleLoaded = true
-      }
-
-      // 处理不同类型的图片源
-      let imageElement: HTMLImageElement
-
-      if (imageSource instanceof File) {
-        // 如果是File对象，创建新的Image元素并加载图片
-        imageElement = new Image()
-        imageElement.crossOrigin = "anonymous" // 处理跨域图片
-        const url = URL.createObjectURL(imageSource)
-        await new Promise((resolve, reject) => {
-          imageElement.onload = resolve
-          imageElement.onerror = reject
-          imageElement.src = url
-        })
-        // 使用后释放URL对象
-        URL.revokeObjectURL(url)
-      } else if (typeof imageSource === "string") {
-        // 如果是URL字符串，创建新的Image元素并加载图片
-        imageElement = new Image()
-        imageElement.crossOrigin = "anonymous" // 处理跨域图片
-        await new Promise((resolve, reject) => {
-          imageElement.onload = resolve
-          imageElement.onerror = reject
-          imageElement.src = imageSource
-        })
-      } else if (imageSource instanceof HTMLImageElement) {
-        // 如果已经是Image元素，直接使用
-        imageElement = imageSource
-      } else if (imageSource instanceof HTMLCanvasElement) {
-        // 如果是Canvas元素，创建Image并从Canvas获取数据
-        imageElement = new Image()
-        imageElement.src = imageSource.toDataURL()
-        await new Promise((resolve) => {
-          imageElement.onload = resolve
-        })
-      } else {
-        throw new Error("不支持的图片源类型")
-      }
-
-      // 获取图像数据
-      const canvas = document.createElement("canvas")
-      canvas.width = imageElement.naturalWidth
-      canvas.height = imageElement.naturalHeight
-      const ctx = canvas.getContext("2d")
-
-      if (!ctx) {
-        throw new Error("无法创建Canvas上下文")
-      }
-
-      ctx.drawImage(imageElement, 0, 0)
-      const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height)
-
-      // 使用Barcode模块处理图像
-      return this.qrModule.processBarcodeImage(imageData)
-    } catch (error) {
-      this.handleError(error as Error)
-      throw error
-    }
+  public getIDCardModule(): IDCardModule | undefined {
+    return this.moduleManager.getModule<IDCardModule>('id-card');
   }
-
+  
   /**
-   * 处理图片中的身份证
-   * @param imageSource 图片源，可以是Image元素、Canvas元素或URL字符串
-   * @returns 返回Promise，解析为身份证信息
+   * 获取二维码模块实例
+   * @returns 二维码模块
    */
-  async processIDCardImage(
-    imageSource: HTMLImageElement | HTMLCanvasElement | string | File
-  ): Promise<IDCardInfo> {
-    if (!this.isOCRModuleLoaded) {
-      await this.initOCRModule()
-    }
-
-    try {
-      // 处理不同类型的图片源
-      let imageElement: HTMLImageElement
-
-      if (imageSource instanceof File) {
-        // 如果是File对象，先进行压缩
-        const compressedFile = await ImageProcessor.compressImage(imageSource, {
-          maxSizeMB: 2, // 最大2MB
-          maxWidthOrHeight: 1800, // 最大尺寸
-          useWebWorker: true,
-        })
-
-        // 创建新的Image元素并加载图片
-        imageElement = new Image()
-        imageElement.crossOrigin = "anonymous" // 处理跨域图片
-        const url = URL.createObjectURL(compressedFile)
-        await new Promise((resolve, reject) => {
-          imageElement.onload = resolve
-          imageElement.onerror = reject
-          imageElement.src = url
-        })
-        // 使用后释放URL对象
-        URL.revokeObjectURL(url)
-      } else if (typeof imageSource === "string") {
-        // 如果是URL字符串，创建新的Image元素并加载图片
-        imageElement = new Image()
-        imageElement.crossOrigin = "anonymous" // 处理跨域图片
-        await new Promise((resolve, reject) => {
-          imageElement.onload = resolve
-          imageElement.onerror = reject
-          imageElement.src = imageSource
-        })
-      } else if (imageSource instanceof HTMLImageElement) {
-        // 如果已经是Image元素，直接使用
-        imageElement = imageSource
-      } else if (imageSource instanceof HTMLCanvasElement) {
-        // 如果是Canvas元素，创建Image并从Canvas获取数据
-        imageElement = new Image()
-        imageElement.src = imageSource.toDataURL()
-        await new Promise((resolve) => {
-          imageElement.onload = resolve
-        })
-      } else {
-        throw new Error("不支持的图片源类型")
-      }
-
-      // 获取图像数据
-      const canvas = document.createElement("canvas")
-      canvas.width = imageElement.naturalWidth
-      canvas.height = imageElement.naturalHeight
-      const ctx = canvas.getContext("2d")
-
-      if (!ctx) {
-        throw new Error("无法创建Canvas上下文")
-      }
-
-      ctx.drawImage(imageElement, 0, 0)
-      const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height)
-
-      // 对图像进行预处理，提高识别率
-      const enhancedImageData = ImageProcessor.batchProcess(imageData, {
-        brightness: 10,
-        contrast: 15,
-        sharpen: true,
-      })
-
-      // 使用OCR模块处理图像
-      const idInfo = await this.ocrModule.processIDCard(enhancedImageData)
-
-      // 进行防伪检测并将结果添加到身份证信息中
-      if (this.isAntiFakeModuleLoaded && this.antiFakeDetector) {
-        try {
-          const result = await this.antiFakeDetector.detect(enhancedImageData)
-          // 将防伪检测结果添加到身份证信息对象中
-          const extendedInfo = idInfo as any
-          extendedInfo.antiFakeResult = result
-
-          // 触发防伪检测回调
-          if (this.options.onAntiFakeDetected) {
-            this.options.onAntiFakeDetected(result)
-          }
-        } catch (error) {
-          console.warn("身份证防伪检测失败:", error)
-        }
-      }
-
-      return idInfo
-    } catch (error) {
-      this.handleError(error as Error)
-      throw error
-    }
+  public getQRCodeModule(): QRCodeModule | undefined {
+    return this.moduleManager.getModule<QRCodeModule>('qrcode');
   }
-
+  
   /**
-   * 批量处理图像
-   * @param imageSource 图片源，可以是Image元素、Canvas元素、URL字符串或File对象
-   * @param options 图像处理选项
-   * @param outputFormat 输出格式，'imagedata'或'file'
-   * @returns 返回Promise，解析为处理后的ImageData或File
+   * 获取人脸识别模块实例
+   * @returns 人脸识别模块
    */
-  async processImage(
-    imageSource: HTMLImageElement | HTMLCanvasElement | string | File,
-    options: ImageProcessorOptions = {},
-    outputFormat: "imagedata" | "file" = "imagedata"
-  ): Promise<ImageData | File> {
-    try {
-      // 处理不同类型的图片源
-      let imageData: ImageData
-
-      if (imageSource instanceof File) {
-        // 如果是File对象，先进行压缩
-        const compressedFile = await ImageProcessor.compressImage(imageSource, {
-          maxSizeMB: 2, // 最大2MB
-          maxWidthOrHeight: 1920, // 最大尺寸
-          useWebWorker: true,
-        })
-
-        // 从File创建ImageData
-        imageData = await ImageProcessor.createImageDataFromFile(compressedFile)
-      } else if (typeof imageSource === "string") {
-        // 如果是URL字符串，创建新的Image元素并加载图片
-        const imageElement = new Image()
-        imageElement.crossOrigin = "anonymous" // 处理跨域图片
-        await new Promise((resolve, reject) => {
-          imageElement.onload = resolve
-          imageElement.onerror = reject
-          imageElement.src = imageSource
-        })
-
-        // 获取图像数据
-        const canvas = document.createElement("canvas")
-        canvas.width = imageElement.naturalWidth
-        canvas.height = imageElement.naturalHeight
-        const ctx = canvas.getContext("2d")
-
-        if (!ctx) {
-          throw new Error("无法创建Canvas上下文")
-        }
-
-        ctx.drawImage(imageElement, 0, 0)
-        imageData = ctx.getImageData(0, 0, canvas.width, canvas.height)
-      } else if (imageSource instanceof HTMLImageElement) {
-        // 如果是Image元素，从它创建ImageData
-        const canvas = document.createElement("canvas")
-        canvas.width = imageSource.naturalWidth
-        canvas.height = imageSource.naturalHeight
-        const ctx = canvas.getContext("2d")
-
-        if (!ctx) {
-          throw new Error("无法创建Canvas上下文")
-        }
-
-        ctx.drawImage(imageSource, 0, 0)
-        imageData = ctx.getImageData(0, 0, canvas.width, canvas.height)
-      } else if (imageSource instanceof HTMLCanvasElement) {
-        // 如果是Canvas元素，直接获取其ImageData
-        const ctx = imageSource.getContext("2d")
-
-        if (!ctx) {
-          throw new Error("无法获取Canvas上下文")
-        }
-
-        imageData = ctx.getImageData(
-          0,
-          0,
-          imageSource.width,
-          imageSource.height
-        )
-      } else {
-        throw new Error("不支持的图片源类型")
-      }
-
-      // 进行图像处理
-      const processedImageData = ImageProcessor.batchProcess(imageData, options)
-
-      // 根据需要的输出格式返回结果
-      if (outputFormat === "file") {
-        // 将ImageData转换为File
-        const file = await ImageProcessor.imageDataToFile(
-          processedImageData,
-          "processed_image.jpg",
-          "image/jpeg",
-          0.85
-        )
-
-        // 触发回调
-        if (this.options.onImageProcessed) {
-          this.options.onImageProcessed(file)
-        }
-
-        return file
-      } else {
-        // 触发回调
-        if (this.options.onImageProcessed) {
-          this.options.onImageProcessed(processedImageData)
-        }
-
-        return processedImageData
-      }
-    } catch (error) {
-      this.handleError(error as Error)
-      throw error
-    }
-  }
-
-  /**
-   * 压缩图片
-   * @param file 要压缩的图片文件
-   * @param options 压缩选项
-   * @returns 返回Promise，解析为压缩后的文件
-   */
-  async compressImage(
-    file: File,
-    options?: ImageCompressionOptions
-  ): Promise<File> {
-    try {
-      return await ImageProcessor.compressImage(file, options)
-    } catch (error) {
-      this.handleError(error as Error)
-      throw error
-    }
+  public getFaceModule(): FaceModule | undefined {
+    return this.moduleManager.getModule<FaceModule>('face');
   }
-
+  
   /**
-   * 身份证防伪检测
-   * @param imageSource 图片源
-   * @returns 防伪检测结果
+   * 释放所有资源
    */
-  async detectIDCardAntiFake(
-    imageSource: HTMLImageElement | HTMLCanvasElement | string | File
-  ): Promise<AntiFakeDetectionResult> {
-    if (!this.isAntiFakeModuleLoaded || !this.antiFakeDetector) {
-      await this.initialize()
-      if (!this.antiFakeDetector) {
-        throw new Error("防伪检测模块初始化失败")
-      }
+  public async dispose(): Promise<void> {
+    if (!this.initialized) {
+      return;
     }
-
+    
+    this.logger.info('IDScanner', '释放IDScanner资源');
+    
     try {
-      // 转换输入为ImageData
-      let imageData: ImageData
-
-      if (typeof imageSource === "string") {
-        // 处理URL或Base64
-        const img = new Image()
-        await new Promise<void>((resolve, reject) => {
-          img.onload = () => resolve()
-          img.onerror = () => reject(new Error("图像加载失败"))
-          img.src = imageSource
-        })
-
-        const canvas = document.createElement("canvas")
-        canvas.width = img.width
-        canvas.height = img.height
-        const ctx = canvas.getContext("2d")
-        if (!ctx) {
-          throw new Error("无法创建Canvas上下文")
-        }
-
-        ctx.drawImage(img, 0, 0)
-        imageData = ctx.getImageData(0, 0, canvas.width, canvas.height)
-      } else if (imageSource instanceof File) {
-        // 处理文件
-        imageData = await ImageProcessor.createImageDataFromFile(imageSource)
-      } else if (imageSource instanceof HTMLImageElement) {
-        // 处理Image元素
-        const canvas = document.createElement("canvas")
-        canvas.width = imageSource.width
-        canvas.height = imageSource.height
-        const ctx = canvas.getContext("2d")
-        if (!ctx) {
-          throw new Error("无法创建Canvas上下文")
-        }
-
-        ctx.drawImage(imageSource, 0, 0)
-        imageData = ctx.getImageData(0, 0, canvas.width, canvas.height)
-      } else {
-        // 处理Canvas元素
-        const ctx = (imageSource as HTMLCanvasElement).getContext("2d")
-        if (!ctx) {
-          throw new Error("无法获取Canvas上下文")
-        }
-
-        imageData = ctx.getImageData(
-          0,
-          0,
-          imageSource.width,
-          imageSource.height
-        )
-      }
-
-      // 执行防伪检测
-      const result = await this.antiFakeDetector.detect(imageData)
-
-      // 触发回调
-      if (this.options.onAntiFakeDetected) {
-        this.options.onAntiFakeDetected(result)
-      }
-
-      return result
+      await this.moduleManager.dispose();
+      
+      this.initialized = false;
+      this.logger.info('IDScanner', 'IDScanner资源已释放');
     } catch (error) {
-      this.handleError(error as Error)
-      throw error
-    }
-  }
-}
-
-// 导出工具类和类型
-export { Camera, CameraOptions } from "./utils/camera"
-export {
-  ImageProcessor,
-  ImageProcessorOptions,
-  ImageCompressionOptions,
-} from "./utils/image-processing"
-export { IDCardInfo, DetectionResult } from "./utils/types"
-
-// 导出防伪检测相关类型和类
-export { AntiFakeDetector, AntiFakeDetectionResult }
-
-// 为了向后兼容，我们创建一个演示类
-export class IDScannerDemo {
-  private scanner: IDScanner
-  private currentMode: "qr" | "idcard" = "qr"
-  private videoElement: HTMLVideoElement
-  private resultElement: HTMLElement
-
-  /**
-   * 创建演示类实例
-   * @param videoElementId 视频元素ID
-   * @param resultElementId 结果显示元素ID
-   * @param switchButtonId 切换按钮ID
-   * @param imageInputId 图片输入元素ID
-   */
-  constructor(
-    videoElementId: string,
-    resultElementId: string,
-    switchButtonId?: string,
-    imageInputId?: string
-  ) {
-    this.videoElement = document.getElementById(
-      videoElementId
-    ) as HTMLVideoElement
-    this.resultElement = document.getElementById(resultElementId) as HTMLElement
-
-    // 创建扫描器实例
-    this.scanner = new IDScanner({
-      onQRCodeScanned: (result) => this.handleScanResult(result),
-      onIDCardScanned: (info) => this.handleIDCardResult(info),
-      onError: (error) => this.handleError(error),
-    })
-
-    // 设置切换按钮事件
-    if (switchButtonId) {
-      const switchButton = document.getElementById(switchButtonId)
-      if (switchButton) {
-        switchButton.addEventListener("click", () => this.toggleMode())
-      }
-    }
-
-    // 设置图片输入事件
-    if (imageInputId) {
-      const imageInput = document.getElementById(
-        imageInputId
-      ) as HTMLInputElement
-      if (imageInput) {
-        imageInput.addEventListener("change", (e) => this.handleImageInput(e))
-      }
-    }
+      this.logger.error('IDScanner', 'IDScanner资源释放失败', error as Error);
+      throw new Error(`IDScanner资源释放失败: ${error instanceof Error ? error.message : String(error)}`);
   }
-
-  /**
-   * 初始化扫描器
-   */
-  async initialize(): Promise<void> {
-    try {
-      // 初始化身份证识别引擎
-      await this.scanner.initialize()
-
-      // 默认启动二维码扫描
-      await this.startQRMode()
-    } catch (error) {
-      this.handleError(error as Error)
-    }
-  }
-
-  /**
-   * 切换扫描模式
-   */
-  async toggleMode(): Promise<void> {
-    try {
-      this.scanner.stop()
-
-      if (this.currentMode === "qr") {
-        this.currentMode = "idcard"
-        await this.startIDCardMode()
-      } else {
-        this.currentMode = "qr"
-        await this.startQRMode()
-      }
-    } catch (error) {
-      this.handleError(error as Error)
-    }
-  }
-
-  /**
-   * 启动二维码扫描模式
-   */
-  private async startQRMode(): Promise<void> {
-    try {
-      this.updateResultDisplay("等待扫描二维码...")
-      await this.scanner.startQRScanner(this.videoElement)
-    } catch (error) {
-      this.handleError(error as Error)
-    }
-  }
-
-  /**
-   * 启动身份证扫描模式
-   */
-  private async startIDCardMode(): Promise<void> {
-    try {
-      this.updateResultDisplay("等待扫描身份证...")
-      await this.scanner.startIDCardScanner(this.videoElement)
-    } catch (error) {
-      this.handleError(error as Error)
-    }
-  }
-
-  /**
-   * 处理图片输入
-   */
-  private async handleImageInput(event: Event): Promise<void> {
-    try {
-      const input = event.target as HTMLInputElement
-
-      if (!input.files || input.files.length === 0) {
-        return
-      }
-
-      const file = input.files[0]
-      this.updateResultDisplay("正在处理图片...")
-
-      // 根据当前模式处理图片
-      if (this.currentMode === "qr") {
-        const result = await this.scanner.processQRCodeImage(file)
-        this.handleScanResult(result)
-      } else {
-        const info = await this.scanner.processIDCardImage(file)
-        this.handleIDCardResult(info)
-      }
-    } catch (error) {
-      this.handleError(error as Error)
-    }
-  }
-
-  /**
-   * 处理扫描结果
-   */
-  private handleScanResult(result: string): void {
-    this.updateResultDisplay(`
-      <h3>扫描结果:</h3>
-      <p>${result}</p>
-    `)
-  }
-
-  /**
-   * 处理身份证识别结果
-   */
-  private handleIDCardResult(info: IDCardInfo): void {
-    // 格式化显示身份证信息
-    const infoHtml = Object.entries(info)
-      .filter(([key, value]) => value && key !== "antiFakeResult") // 过滤掉空值和防伪结果
-      .map(([key, value]) => {
-        // 转换键名为中文显示
-        const keyMap: { [key: string]: string } = {
-          name: "姓名",
-          gender: "性别",
-          nationality: "民族",
-          birthDate: "出生日期",
-          address: "地址",
-          idNumber: "身份证号",
-          issuingAuthority: "签发机关",
-          validPeriod: "有效期限",
-        }
-
-        const displayKey = keyMap[key] || key
-        return `<div><strong>${displayKey}:</strong> ${value}</div>`
-      })
-      .join("")
-
-    // 检查是否有防伪检测结果
-    let antiFakeHtml = ""
-    const anyInfo = info as any
-    if (anyInfo.antiFakeResult) {
-      const antiFakeResult = anyInfo.antiFakeResult
-      antiFakeHtml = `
-        <h3>防伪检测结果:</h3>
-        <div style="color: ${antiFakeResult.isAuthentic ? "green" : "red"}">
-          ${
-            antiFakeResult.isAuthentic
-              ? "✓ 身份证真实"
-              : "⚠ 警告：可能为伪造证件"
-          }
-        </div>
-        <div>置信度: ${(antiFakeResult.confidence * 100).toFixed(1)}%</div>
-        <div>检测到的特征: ${
-          antiFakeResult.detectedFeatures.join(", ") || "无"
-        }</div>
-        <div>${antiFakeResult.message}</div>
-      `
-    }
-
-    this.updateResultDisplay(`
-      <h3>身份证信息:</h3>
-      ${infoHtml}
-      ${antiFakeHtml}
-    `)
-  }
-
-  /**
-   * 处理错误
-   */
-  private handleError(error: Error): void {
-    console.error("识别错误:", error)
-    this.updateResultDisplay(`
-      <div class="error">
-        <h3>错误:</h3>
-        <p>${error.message}</p>
-      </div>
-    `)
-  }
-
-  /**
-   * 更新结果显示
-   */
-  private updateResultDisplay(html: string): void {
-    if (this.resultElement) {
-      this.resultElement.innerHTML = html
-    }
-  }
-
-  /**
-   * 停止扫描
-   */
-  stop(): void {
-    this.scanner.stop()
   }
 }
+
+// 导出核心模块
+export * from './core/loading-state';
+export * from './core/module-manager';
+export * from './core/logger';
+export * from './core/errors';
+
+// 导出功能模块 (明确导出以避免命名冲突)
+export { IDCardModule } from './modules/id-card';
+export { QRCodeModule } from './modules/qrcode';
+export { FaceModule } from './modules/face';
+
+// 导出类型
+export * from './utils/types';
+export { IDCardModuleOptions, IDCardInfo, IDCardType, IDCardVerificationResult } from './modules/id-card/types';
+export { QRCodeModuleOptions, QRCodeResult, BarcodeFormat, DEFAULT_FORMATS } from './modules/qrcode/types';
+export { FaceModuleOptions, FaceDetectionResult, FaceComparisonResult } from './modules/face/types';
+
+// 默认导出IDScanner类
+export default IDScanner;