id-scanner-lib 1.1.1 → 1.2.0

package/src/utils/resource-manager.ts

@@ -0,0 +1,198 @@
+/**
+ * @file 资源管理器
+ * @description 提供资源自动管理功能，防止内存泄漏
+ * @module ResourceManager
+ */
+
+/**
+ * 可释放资源接口
+ */
+export interface Disposable {
+  dispose: () => void | Promise<void>;
+}
+
+/**
+ * 资源管理器
+ * 
+ * 用于管理和自动释放资源，防止内存泄漏
+ */
+export class ResourceManager {
+  private resources: Map<string, Disposable> = new Map();
+  private disposeTimeouts: Map<string, number> = new Map();
+  private autoDisposeDelay: number;
+  
+  /**
+   * 创建资源管理器
+   * @param autoDisposeDelay 自动释放延迟时间（毫秒），默认5分钟
+   */
+  constructor(autoDisposeDelay: number = 5 * 60 * 1000) {
+    this.autoDisposeDelay = autoDisposeDelay;
+    
+    // 添加页面卸载事件监听，确保在页面关闭时释放所有资源
+    if (typeof window !== 'undefined') {
+      window.addEventListener('beforeunload', () => {
+        this.disposeAll();
+      });
+    }
+  }
+  
+  /**
+   * 注册资源
+   * 
+   * @param id 资源标识符
+   * @param resource 可释放资源
+   * @param autoDispose 是否自动释放
+   * @returns 注册的资源
+   */
+  register<T extends Disposable>(id: string, resource: T, autoDispose: boolean = true): T {
+    // 如果已存在同ID资源，先释放它
+    if (this.resources.has(id)) {
+      this.dispose(id);
+    }
+    
+    this.resources.set(id, resource);
+    
+    // 如果启用自动释放，设置定时器
+    if (autoDispose) {
+      this.resetDisposeTimeout(id);
+    }
+    
+    return resource;
+  }
+  
+  /**
+   * 重置资源自动释放定时器
+   * 
+   * @param id 资源标识符
+   */
+  resetDisposeTimeout(id: string): void {
+    // 取消现有定时器
+    if (this.disposeTimeouts.has(id)) {
+      window.clearTimeout(this.disposeTimeouts.get(id)!);
+    }
+    
+    // 设置新定时器
+    const timeoutId = window.setTimeout(() => {
+      this.dispose(id);
+    }, this.autoDisposeDelay);
+    
+    this.disposeTimeouts.set(id, timeoutId);
+  }
+  
+  /**
+   * 获取资源
+   * 
+   * @param id 资源标识符
+   * @returns 资源对象或undefined
+   */
+  get<T extends Disposable>(id: string): T | undefined {
+    const resource = this.resources.get(id) as T | undefined;
+    
+    // 重置自动释放定时器（仅当资源存在且有定时器时）
+    if (resource && this.disposeTimeouts.has(id)) {
+      this.resetDisposeTimeout(id);
+    }
+    
+    return resource;
+  }
+  
+  /**
+   * 释放单个资源
+   * 
+   * @param id 资源标识符
+   * @returns 是否成功释放
+   */
+  async dispose(id: string): Promise<boolean> {
+    if (!this.resources.has(id)) {
+      return false;
+    }
+    
+    // 取消定时器
+    if (this.disposeTimeouts.has(id)) {
+      window.clearTimeout(this.disposeTimeouts.get(id)!);
+      this.disposeTimeouts.delete(id);
+    }
+    
+    // 释放资源
+    try {
+      const resource = this.resources.get(id)!;
+      const result = resource.dispose();
+      
+      // 处理可能的Promise结果
+      if (result instanceof Promise) {
+        await result;
+      }
+      
+      this.resources.delete(id);
+      return true;
+    } catch (error) {
+      console.error(`释放资源 ${id} 时发生错误:`, error);
+      // 尽管出错，仍然从管理器中移除
+      this.resources.delete(id);
+      return false;
+    }
+  }
+  
+  /**
+   * 释放所有资源
+   */
+  async disposeAll(): Promise<void> {
+    // 取消所有定时器
+    for (const timeoutId of this.disposeTimeouts.values()) {
+      window.clearTimeout(timeoutId);
+    }
+    this.disposeTimeouts.clear();
+    
+    // 并行释放所有资源
+    const disposePromises = [];
+    
+    for (const [id, resource] of this.resources.entries()) {
+      try {
+        const result = resource.dispose();
+        if (result instanceof Promise) {
+          disposePromises.push(result);
+        }
+      } catch (error) {
+        console.error(`释放资源 ${id} 时发生错误:`, error);
+      }
+    }
+    
+    // 等待所有异步释放完成
+    if (disposePromises.length > 0) {
+      await Promise.all(disposePromises);
+    }
+    
+    this.resources.clear();
+  }
+  
+  /**
+   * 释放不活跃资源
+   * 
+   * @param maxAge 资源最大年龄（毫秒）
+   */
+  disposeInactive(maxAge: number): void {
+    const now = Date.now();
+    
+    for (const [id, timeoutId] of this.disposeTimeouts.entries()) {
+      // 计算资源年龄：自动释放延迟时间 - 剩余时间
+      const remainingTime = this.getRemainingTime(timeoutId);
+      const age = this.autoDisposeDelay - remainingTime;
+      
+      if (age > maxAge) {
+        this.dispose(id);
+      }
+    }
+  }
+  
+  /**
+   * 获取定时器剩余时间
+   * 
+   * @param timeoutId 定时器ID
+   * @returns 剩余时间（毫秒）
+   */
+  private getRemainingTime(timeoutId: number): number {
+    // 注意：这是一个近似实现，因为JavaScript没有提供获取setTimeout剩余时间的API
+    // 可以在实际应用中使用更精确的测量方法
+    return 0; // 实际应用中应返回真实的剩余时间
+  }
+} 

package/src/utils/worker.ts

@@ -0,0 +1,173 @@
+/**
+ * @file Web Worker辅助工具类
+ * @description 提供Worker线程管理功能，用于将计算密集型任务移至后台线程
+ * @module WorkerUtils
+ */
+
+/**
+ * 创建Worker线程并处理消息通信
+ * 
+ * @param workerFunction 要在Worker中执行的函数
+ * @returns 返回包含发送消息方法的Worker控制对象
+ */
+export function createWorker<T, R>(workerFunction: Function): {
+  postMessage: (data: T) => Promise<R>;
+  terminate: () => void;
+} {
+  // 将函数转换为字符串，然后创建一个Blob URL
+  const workerCode = `
+    self.onmessage = async function(e) {
+      try {
+        const result = await (${workerFunction.toString()})(e.data);
+        self.postMessage({ success: true, result });
+      } catch (error) {
+        self.postMessage({ 
+          success: false, 
+          error: { message: error.message, stack: error.stack }
+        });
+      }
+    }
+  `;
+  
+  const blob = new Blob([workerCode], { type: 'application/javascript' });
+  const workerUrl = URL.createObjectURL(blob);
+  const worker = new Worker(workerUrl);
+  
+  // 创建一个映射来存储待解析的Promise
+  const promiseMap = new Map<number, {
+    resolve: (value: R) => 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;
+    
+    const promiseHandlers = promiseMap.get(id);
+    if (promiseHandlers) {
+      promiseMap.delete(id);
+      
+      if (success) {
+        promiseHandlers.resolve(result);
+      } else {
+        const workerError = new Error(error.message);
+        workerError.stack = error.stack;
+        promiseHandlers.reject(workerError);
+      }
+    }
+  };
+  
+  return {
+    postMessage: (data: T): Promise<R> => {
+      return new Promise((resolve, reject) => {
+        const id = messageCounter++;
+        promiseMap.set(id, { resolve, reject });
+        worker.postMessage({ id, data });
+      });
+    },
+    terminate: () => {
+      worker.terminate();
+      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;
+  }> = [];
+  
+  /**
+   * 创建工作线程池
+   * 
+   * @param workerFunction 要在Worker中执行的函数
+   * @param size 池中Worker的数量
+   */
+  constructor(private workerFunction: Function, private size: number = navigator.hardwareConcurrency || 4) {
+    // 预创建Workers
+    for (let i = 0; i < size; i++) {
+      this.workers.push({
+        worker: createWorker<T, R>(workerFunction),
+        busy: false
+      });
+    }
+  }
+  
+  /**
+   * 获取一个可用的Worker
+   * 
+   * @returns Worker包装对象
+   */
+  private getAvailableWorker(): ReturnType<typeof createWorker<T, R>> {
+    // 找到第一个空闲的Worker
+    const availableWorker = this.workers.find(w => !w.busy);
+    
+    if (availableWorker) {
+      availableWorker.busy = true;
+      return availableWorker.worker;
+    }
+    
+    // 如果没有空闲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();
+    
+    try {
+      const result = await worker.postMessage(data);
+      // 标记Worker为空闲
+      const workerEntry = this.workers.find(w => w.worker === worker);
+      if (workerEntry) {
+        workerEntry.busy = false;
+      }
+      return result;
+    } catch (error) {
+      // 出错时也标记为空闲
+      const workerEntry = this.workers.find(w => w.worker === worker);
+      if (workerEntry) {
+        workerEntry.busy = false;
+      }
+      throw error;
+    }
+  }
+  
+  /**
+   * 终止所有Worker
+   */
+  terminate(): void {
+    this.workers.forEach(({ worker }) => {
+      worker.terminate();
+    });
+    this.workers = [];
+  }
+}