id-scanner-lib 1.3.3 → 1.5.0

package/src/utils/types.ts

@@ -70,12 +70,100 @@ export interface DetectionResult {
  * ```
  */
 export interface IDCardInfo {
+  /** 姓名 */
   name?: string;
+  /** 性别 */
   gender?: string;
-  nationality?: string;
+  /** 民族 */
+  ethnicity?: string;
+  /** 出生日期 */
   birthDate?: string;
+  /** 地址 */
   address?: string;
+  /** 身份证号码 */
   idNumber?: string;
-  issuingAuthority?: string;
+  /** 签发机关 */
+  issueAuthority?: string;
+  /** 有效期起始日期 */
+  validFrom?: string;
+  /** 有效期截止日期 */
+  validTo?: string;
+  /** 有效期限（完整文本） */
   validPeriod?: string;
+  /** 照片区域 */
+  photoRegion?: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  /** 类型 */
+  type?: string;
+  /** 置信度 */
+  confidence?: number;
+  /** 其他属性 */
+  [key: string]: any;
+}
+
+/**
+ * 点坐标
+ */
+export interface Point {
+  x: number;
+  y: number;
+}
+
+/**
+ * 矩形区域
+ */
+export interface Rect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+/**
+ * 可释放资源接口
+ */
+export interface Disposable {
+  /** 释放资源 */
+  dispose(): Promise<void>;
+}
+
+/**
+ * 图像处理选项
+ */
+export interface ImageProcessingOptions {
+  /** 亮度调整 (-100 到 100) */
+  brightness?: number;
+  /** 对比度调整 (-100 到 100) */
+  contrast?: number;
+  /** 饱和度调整 (-100 到 100) */
+  saturation?: number;
+  /** 锐化强度 (0 到 10) */
+  sharpen?: number | boolean;
+  /** 高斯模糊半径 (0 到 10) */
+  blur?: number;
+  /** 是否应用灰度转换 */
+  grayscale?: boolean;
+  /** 是否应用二值化 */
+  binarize?: boolean;
+  /** 二值化阈值 (0 到 255) */
+  threshold?: number;
+  /** 是否应用边缘检测 */
+  edgeDetection?: boolean;
+  /** 是否应用降噪 */
+  denoise?: boolean;
+  /** 是否应用直方图均衡化 */
+  histogramEqualization?: boolean;
+  /** 是否应用透视校正 */
+  perspectiveCorrection?: boolean;
+  /** 透视校正点 */
+  perspectivePoints?: {
+    topLeft: Point;
+    topRight: Point;
+    bottomRight: Point;
+    bottomLeft: Point;
+  };
 } 

package/src/utils/worker.ts

@@ -1,173 +1,212 @@
 /**
- * @file Web Worker辅助工具类
- * @description 提供Worker线程管理功能，用于将计算密集型任务移至后台线程
- * @module WorkerUtils
+ * @file Worker工具
+ * @description 提供Web Worker相关的工具函数
+ * @module utils/worker
  */
 
 /**
- * 创建Worker线程并处理消息通信
- * 
- * @param workerFunction 要在Worker中执行的函数
- * @returns 返回包含发送消息方法的Worker控制对象
+ * 检查是否支持Web Worker
+ * @returns 是否支持Web Worker
  */
-export function createWorker<T, R>(workerFunction: Function): {
-  postMessage: (data: T) => Promise<R>;
+export function isWorkerSupported(): boolean {
+  return typeof Worker !== 'undefined';
+}
+
+/**
+ * 创建Worker
+ * @param workerFunction Worker函数
+ * @returns Worker实例
+ */
+export function createWorker<TInput, TOutput>(
+  workerFunction: (input: TInput) => TOutput | Promise<TOutput>
+): {
+  postMessage: (input: TInput) => Promise<TOutput>;
   terminate: () => void;
 } {
-  // 将函数转换为字符串，然后创建一个Blob URL
-  const workerCode = `
-    self.onmessage = async function(e) {
+  // 检查是否支持Web Worker
+  if (!isWorkerSupported()) {
+    // 回退到主线程执行
+    return {
+      postMessage: async (input: TInput) => {
+        return await Promise.resolve(workerFunction(input));
+      },
+      terminate: () => {}
+    };
+  }
+  
+  // 将函数转换为字符串
+  const workerFunctionStr = workerFunction.toString();
+  
+  // 创建Worker脚本
+  const workerScript = `
+    // 定义Worker函数
+    const workerFunction = ${workerFunctionStr};
+    
+    // 监听消息
+    self.addEventListener('message', async (event) => {
       try {
-        const result = await (${workerFunction.toString()})(e.data);
+        const input = event.data;
+        const result = await workerFunction(input);
         self.postMessage({ success: true, result });
       } catch (error) {
         self.postMessage({ 
           success: false, 
-          error: { message: error.message, stack: error.stack }
+          error: error instanceof Error ? error.message : String(error)
         });
       }
-    }
+    });
   `;
   
-  const blob = new Blob([workerCode], { type: 'application/javascript' });
-  const workerUrl = URL.createObjectURL(blob);
-  const worker = new Worker(workerUrl);
+  // 创建Blob URL
+  const blob = new Blob([workerScript], { type: 'application/javascript' });
+  const url = URL.createObjectURL(blob);
   
-  // 创建一个映射来存储待解析的Promise
+  // 创建Worker
+  const worker = new Worker(url);
+
+  // 创建Promise映射
   const promiseMap = new Map<number, {
-    resolve: (value: R) => void;
+    resolve: (value: TOutput) => void;
     reject: (reason: any) => void;
   }>();
   
+  // 消息计数器
   let messageCounter = 0;
   
-  worker.onmessage = (e) => {
-    // 释放Blob URL
-    if (promiseMap.size === 0) {
-      URL.revokeObjectURL(workerUrl);
-    }
-    
-    const { id, success, result, error } = e.data;
+  // 监听Worker消息
+  worker.addEventListener('message', (event) => {
+    const { messageId, success, result, error } = event.data;
     
-    const promiseHandlers = promiseMap.get(id);
+    // 查找对应的Promise
+    const promiseHandlers = promiseMap.get(messageId);
     if (promiseHandlers) {
-      promiseMap.delete(id);
-      
       if (success) {
         promiseHandlers.resolve(result);
       } else {
-        const workerError = new Error(error.message);
-        workerError.stack = error.stack;
-        promiseHandlers.reject(workerError);
+        promiseHandlers.reject(new Error(error));
       }
+      
+      // 删除Promise映射
+      promiseMap.delete(messageId);
     }
-  };
-  
+  });
+
+  // 返回Worker接口
   return {
-    postMessage: (data: T): Promise<R> => {
-      return new Promise((resolve, reject) => {
-        const id = messageCounter++;
-        promiseMap.set(id, { resolve, reject });
-        worker.postMessage({ id, data });
+    postMessage: (input: TInput): Promise<TOutput> => {
+      return new Promise<TOutput>((resolve, reject) => {
+        // 生成消息ID
+        const messageId = messageCounter++;
+        
+        // 保存Promise处理函数
+        promiseMap.set(messageId, { resolve, reject });
+        
+        // 发送消息到Worker
+        worker.postMessage({ messageId, input });
       });
     },
     terminate: () => {
+      // 终止Worker
       worker.terminate();
+      
+      // 释放Blob URL
+      URL.revokeObjectURL(url);
+      
+      // 拒绝所有未完成的Promise
+      for (const [, { reject }] of promiseMap) {
+        reject(new Error('Worker已终止'));
+      }
+      
+      // 清空Promise映射
       promiseMap.clear();
-      URL.revokeObjectURL(workerUrl);
     }
   };
 }
 
-/**
- * 判断浏览器是否支持Web Workers
- * 
- * @returns 是否支持Web Workers
- */
-export function isWorkerSupported(): boolean {
-  return typeof Worker !== 'undefined';
-}
-
 /**
  * 工作线程池
  * 用于管理和重用Worker线程，避免频繁创建和销毁
  */
 export class WorkerPool<T, R> {
   private workers: Array<{
-    worker: ReturnType<typeof createWorker<T, R>>;
-    busy: boolean;
-  }> = [];
-  
+    worker: ReturnType<typeof createWorker<T, R>>
+    busy: boolean
+  }> = []
+
   /**
    * 创建工作线程池
-   * 
+   *
    * @param workerFunction 要在Worker中执行的函数
    * @param size 池中Worker的数量
    */
-  constructor(private workerFunction: Function, private size: number = navigator.hardwareConcurrency || 4) {
+  constructor(
+    private workerFunction: (data: T) => Promise<R> | R,
+    private size: number = navigator.hardwareConcurrency || 4
+  ) {
+    // 更精确的 workerFunction 类型
     // 预创建Workers
     for (let i = 0; i < size; i++) {
       this.workers.push({
         worker: createWorker<T, R>(workerFunction),
-        busy: false
-      });
+        busy: false,
+      })
     }
   }
-  
+
   /**
    * 获取一个可用的Worker
-   * 
+   *
    * @returns Worker包装对象
    */
   private getAvailableWorker(): ReturnType<typeof createWorker<T, R>> {
     // 找到第一个空闲的Worker
-    const availableWorker = this.workers.find(w => !w.busy);
-    
+    const availableWorker = this.workers.find((w) => !w.busy)
+
     if (availableWorker) {
-      availableWorker.busy = true;
-      return availableWorker.worker;
+      availableWorker.busy = true
+      return availableWorker.worker
     }
-    
+
     // 如果没有空闲Worker，创建一个新的
-    const worker = createWorker<T, R>(this.workerFunction);
-    this.workers.push({ worker, busy: true });
-    return worker;
+    const worker = createWorker<T, R>(this.workerFunction)
+    this.workers.push({ worker, busy: true })
+    return worker
   }
-  
+
   /**
    * 执行任务
-   * 
+   *
    * @param data 要处理的数据
    * @returns 处理结果的Promise
    */
   async execute(data: T): Promise<R> {
-    const worker = this.getAvailableWorker();
-    
+    const worker = this.getAvailableWorker()
+
     try {
-      const result = await worker.postMessage(data);
+      const result = await worker.postMessage(data)
       // 标记Worker为空闲
-      const workerEntry = this.workers.find(w => w.worker === worker);
+      const workerEntry = this.workers.find((w) => w.worker === worker)
       if (workerEntry) {
-        workerEntry.busy = false;
+        workerEntry.busy = false
       }
-      return result;
+      return result
     } catch (error) {
       // 出错时也标记为空闲
-      const workerEntry = this.workers.find(w => w.worker === worker);
+      const workerEntry = this.workers.find((w) => w.worker === worker)
       if (workerEntry) {
-        workerEntry.busy = false;
+        workerEntry.busy = false
       }
-      throw error;
+      throw error
     }
   }
-  
+
   /**
    * 终止所有Worker
    */
   terminate(): void {
     this.workers.forEach(({ worker }) => {
-      worker.terminate();
-    });
-    this.workers = [];
+      worker.terminate()
+    })
+    this.workers = []
   }
-} 
+}

package/src/version.ts

@@ -0,0 +1,11 @@
+/**
+ * @file 版本号文件
+ * @description 定义库的版本号
+ * @module Version
+ */
+
+// 当前版本号
+export const VERSION = '1.5.0';
+
+// 构建日期
+export const BUILD_DATE = new Date().toISOString();