id-scanner-lib 1.3.3 → 1.5.0

package/src/utils/performance.ts

@@ -1,210 +1,247 @@
 /**
- * @file 性能优化工具类
- * @description 提供节流、防抖、缓存等性能优化功能
- * @module PerformanceUtils
+ * @file 性能优化工具
+ * @description 提供性能优化相关的工具函数
+ * @module utils/performance
  */
 
 /**
- * 节流函数：限制函数在一定时间内只能执行一次
- * 
- * @param fn 需要节流的函数
- * @param delay 延迟时间（毫秒）
- * @returns 节流处理后的函数
- */
-export function throttle<T extends (...args: any[]) => any>(
-  fn: T, 
-  delay: number
-): (...args: Parameters<T>) => void {
-  let lastCall = 0;
-  let timeoutId: number | null = null;
-  
-  return function(this: any, ...args: Parameters<T>) {
-    const now = Date.now();
-    const remaining = delay - (now - lastCall);
-    
-    if (remaining <= 0) {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-        timeoutId = null;
-      }
-      lastCall = now;
-      fn.apply(this, args);
-    } else if (!timeoutId) {
-      timeoutId = window.setTimeout(() => {
-        lastCall = Date.now();
-        timeoutId = null;
-        fn.apply(this, args);
-      }, remaining);
-    }
-  };
-}
-
-/**
- * 防抖函数：函数在最后一次调用后延迟指定时间执行
- * 
- * @param fn 需要防抖的函数
- * @param delay 延迟时间（毫秒）
- * @returns 防抖处理后的函数
- */
-export function debounce<T extends (...args: any[]) => any>(
-  fn: T, 
-  delay: number
-): (...args: Parameters<T>) => void {
-  let timeoutId: number | null = null;
-  
-  return function(this: any, ...args: Parameters<T>) {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-    
-    timeoutId = window.setTimeout(() => {
-      fn.apply(this, args);
-      timeoutId = null;
-    }, delay);
-  };
-}
-
-/**
- * LRU缓存类 - 使用最近最少使用策略的缓存实现
+ * LRU缓存实现
  */
 export class LRUCache<K, V> {
-  private cache = new Map<K, V>();
-  
+  private capacity: number;
+  private cache: Map<K, V>;
+
   /**
-   * 构造LRU缓存
-   * @param maxSize 缓存最大容量
+   * 构造函数
+   * @param capacity 缓存容量
    */
-  constructor(private maxSize: number = 100) {}
-  
+  constructor(capacity: number = 100) {
+    this.capacity = capacity;
+    this.cache = new Map<K, V>();
+  }
+
   /**
    * 获取缓存项
-   * @param key 缓存键
-   * @returns 缓存值或undefined
+   * @param key 键
+   * @returns 值，如果不存在则返回undefined
    */
   get(key: K): V | undefined {
     if (!this.cache.has(key)) {
       return undefined;
     }
-    
+
     // 获取值
     const value = this.cache.get(key)!;
     
-    // 将项移至最新位置（删除后重新添加）
+    // 删除旧位置
     this.cache.delete(key);
+
+    // 添加到最新位置
     this.cache.set(key, value);
-    
+
     return value;
   }
-  
+
   /**
    * 设置缓存项
-   * @param key 缓存键
-   * @param value 缓存值
+   * @param key 键
+   * @param value 值
    */
   set(key: K, value: V): void {
-    // 如果键已存在，需要先删除
+    // 如果已存在，先删除
     if (this.cache.has(key)) {
       this.cache.delete(key);
     }
-    
-    // 如果缓存已满，移除最老的项
-    if (this.cache.size >= this.maxSize) {
-      const oldestKey = this.cache.keys().next().value;
-      if (oldestKey !== undefined) {
-        this.cache.delete(oldestKey);
-      }
+    // 如果缓存已满，删除最旧的项
+    else if (this.cache.size >= this.capacity) {
+      this.cache.delete(this.cache.keys().next().value as K);
     }
-    
+
     // 添加新项
     this.cache.set(key, value);
   }
   
+  /**
+   * 检查键是否存在
+   * @param key 键
+   * @returns 是否存在
+   */
+  has(key: K): boolean {
+    return this.cache.has(key);
+  }
+
   /**
    * 删除缓存项
-   * @param key 缓存键
+   * @param key 键
    * @returns 是否成功删除
    */
   delete(key: K): boolean {
     return this.cache.delete(key);
   }
-  
+
   /**
    * 清空缓存
    */
   clear(): void {
     this.cache.clear();
   }
-  
+
   /**
-   * 获取当前缓存大小
+   * 获取缓存大小
    */
   get size(): number {
     return this.cache.size;
   }
+
+  /**
+   * 获取所有键
+   */
+  keys(): IterableIterator<K> {
+    return this.cache.keys();
+  }
   
   /**
-   * 检查键是否存在
-   * @param key 缓存键
+   * 获取所有值
    */
-  has(key: K): boolean {
-    return this.cache.has(key);
+  values(): IterableIterator<V> {
+    return this.cache.values();
+  }
+  
+  /**
+   * 获取所有项
+   */
+  entries(): IterableIterator<[K, V]> {
+    return this.cache.entries();
   }
 }
 
 /**
- * 图像指纹计算函数 - 用于检测相同或相似图像
- * 
+ * 计算图像指纹
  * @param imageData 图像数据
- * @param size 指纹尺寸（默认8x8）
- * @returns 图像指纹字符串
+ * @returns 图像指纹
  */
-export function calculateImageFingerprint(imageData: ImageData, size: number = 8): string {
-  // 1. 缩小图像到指定尺寸
+export function calculateImageFingerprint(imageData: ImageData): string {
+  const { width, height, data } = imageData;
+  
+  // 缩小图像以加快计算速度
+  const scale = Math.min(1, 32 / Math.max(width, height));
+  const scaledWidth = Math.max(8, Math.floor(width * scale));
+  const scaledHeight = Math.max(8, Math.floor(height * scale));
+  
+  // 创建缩小的图像
   const canvas = document.createElement('canvas');
-  canvas.width = size;
-  canvas.height = size;
   const ctx = canvas.getContext('2d');
-  
+
   if (!ctx) {
-    return '';
+    throw new Error('无法创建Canvas上下文');
   }
   
-  // 创建一个临时canvas来绘制原始imageData
+  // 设置canvas尺寸
+  canvas.width = scaledWidth;
+  canvas.height = scaledHeight;
+
+  // 创建临时canvas存储原始ImageData
   const tempCanvas = document.createElement('canvas');
-  tempCanvas.width = imageData.width;
-  tempCanvas.height = imageData.height;
   const tempCtx = tempCanvas.getContext('2d');
-  
+
   if (!tempCtx) {
-    return '';
+    throw new Error('无法创建临时Canvas上下文');
   }
-  
+
+  tempCanvas.width = width;
+  tempCanvas.height = height;
   tempCtx.putImageData(imageData, 0, 0);
   
-  // 缩小到目标尺寸
-  ctx.drawImage(tempCanvas, 0, 0, imageData.width, imageData.height, 0, 0, size, size);
+  // 绘制缩小的图像
+  ctx.drawImage(tempCanvas, 0, 0, width, height, 0, 0, scaledWidth, scaledHeight);
   
-  // 2. 转换为灰度
-  const smallImgData = ctx.getImageData(0, 0, size, size);
-  const grayValues = [];
+  // 获取缩小的图像数据
+  const scaledImageData = ctx.getImageData(0, 0, scaledWidth, scaledHeight);
   
-  for (let i = 0; i < smallImgData.data.length; i += 4) {
-    const r = smallImgData.data[i];
-    const g = smallImgData.data[i + 1];
-    const b = smallImgData.data[i + 2];
-    // 转为灰度: 0.299r + 0.587g + 0.114b
-    const gray = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
-    grayValues.push(gray);
+  // 计算灰度值
+  const grayValues = new Uint8Array(scaledWidth * scaledHeight);
+
+  for (let i = 0; i < scaledWidth * scaledHeight; i++) {
+    const idx = i * 4;
+    grayValues[i] = Math.round(
+      0.299 * scaledImageData.data[idx] +
+      0.587 * scaledImageData.data[idx + 1] +
+      0.114 * scaledImageData.data[idx + 2]
+    );
   }
   
-  // 3. 计算平均值
-  const avg = grayValues.reduce((sum, val) => sum + val, 0) / grayValues.length;
+  // 计算平均值
+  let sum = 0;
+  for (let i = 0; i < grayValues.length; i++) {
+    sum += grayValues[i];
+  }
+  const avg = sum / grayValues.length;
   
-  // 4. 比较每个像素与平均值，生成二进制指纹
-  let fingerprint = '';
-  for (const gray of grayValues) {
-    fingerprint += gray >= avg ? '1' : '0';
+  // 计算哈希值
+  let hash = '';
+  for (let i = 0; i < grayValues.length; i++) {
+    hash += grayValues[i] >= avg ? '1' : '0';
   }
   
-  return fingerprint;
-} 
+  return hash;
+  }
+
+/**
+ * 防抖函数
+ * @param func 要执行的函数
+ * @param wait 等待时间（毫秒）
+ * @returns 防抖处理后的函数
+ */
+export function debounce<T extends (...args: any[]) => any>(
+  func: T,
+  wait: number
+): (...args: Parameters<T>) => void {
+  let timeout: number | null = null;
+  
+  return function(this: any, ...args: Parameters<T>): void {
+    const later = () => {
+      timeout = null;
+      func.apply(this, args);
+    };
+    
+    if (timeout !== null) {
+      clearTimeout(timeout);
+    }
+    
+    timeout = window.setTimeout(later, wait) as unknown as number;
+  };
+}
+
+/**
+ * 节流函数
+ * @param func 要执行的函数
+ * @param limit 时间限制（毫秒）
+ * @returns 节流处理后的函数
+ */
+export function throttle<T extends (...args: any[]) => any>(
+  func: T,
+  limit: number
+): (...args: Parameters<T>) => void {
+  let inThrottle = false;
+  let lastFunc: number | null = null;
+  let lastRan: number | null = null;
+  
+  return function(this: any, ...args: Parameters<T>): void {
+    if (!inThrottle) {
+      func.apply(this, args);
+      lastRan = Date.now();
+      inThrottle = true;
+    } else {
+      if (lastFunc !== null) {
+        clearTimeout(lastFunc);
+      }
+      
+      lastFunc = window.setTimeout(() => {
+        if (lastRan !== null && Date.now() - lastRan >= limit) {
+          func.apply(this, args);
+          lastRan = Date.now();
+        }
+      }, limit - (lastRan !== null ? Date.now() - lastRan : 0)) as unknown as number;
+    }
+  };
+}

package/src/utils/resource-manager.ts

@@ -1,198 +1,117 @@
 /**
  * @file 资源管理器
- * @description 提供资源自动管理功能，防止内存泄漏
- * @module ResourceManager
+ * @description 提供资源管理和释放功能
+ * @module utils/resource-manager
  */
 
 /**
  * 可释放资源接口
  */
 export interface Disposable {
-  dispose: () => void | Promise<void>;
+  /** 释放资源 */
+  dispose(): Promise<void> | 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();
-      });
-    }
-  }
+  private resources: Disposable[] = [];
   
   /**
    * 注册资源
-   * 
-   * @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
+   * @returns 资源本身，便于链式调用
    */
-  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);
-    }
-    
+  register<T extends Disposable>(resource: T): T {
+    this.resources.push(resource);
     return resource;
   }
   
   /**
-   * 释放单个资源
-   * 
-   * @param id 资源标识符
+   * 释放指定资源
+   * @param resource 要释放的资源
    * @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);
+  async release(resource: Disposable): Promise<boolean> {
+    const index = this.resources.indexOf(resource);
+    if (index !== -1) {
+      try {
+        await resource.dispose();
+        this.resources.splice(index, 1);
       return true;
     } catch (error) {
-      console.error(`释放资源 ${id} 时发生错误:`, error);
-      // 尽管出错，仍然从管理器中移除
-      this.resources.delete(id);
+        console.error('释放资源失败:', error);
       return false;
+      }
     }
+    return false;
   }
   
   /**
    * 释放所有资源
    */
-  async disposeAll(): Promise<void> {
-    // 取消所有定时器
-    for (const timeoutId of this.disposeTimeouts.values()) {
-      window.clearTimeout(timeoutId);
-    }
-    this.disposeTimeouts.clear();
-    
-    // 并行释放所有资源
-    const disposePromises = [];
+  async releaseAll(): Promise<void> {
+    const promises: Promise<void>[] = [];
     
-    for (const [id, resource] of this.resources.entries()) {
+    for (const resource of this.resources) {
       try {
         const result = resource.dispose();
         if (result instanceof Promise) {
-          disposePromises.push(result);
+          promises.push(result);
         }
       } catch (error) {
-        console.error(`释放资源 ${id} 时发生错误:`, error);
+        console.error('释放资源失败:', error);
       }
     }
     
-    // 等待所有异步释放完成
-    if (disposePromises.length > 0) {
-      await Promise.all(disposePromises);
-    }
-    
-    this.resources.clear();
+    await Promise.all(promises);
+    this.resources = [];
   }
   
   /**
-   * 释放不活跃资源
-   * 
-   * @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);
-      }
+  get count(): number {
+    return this.resources.length;
     }
   }
   
   /**
-   * 获取定时器剩余时间
-   * 
-   * @param timeoutId 定时器ID
-   * @returns 剩余时间（毫秒）
-   */
-  private getRemainingTime(timeoutId: number): number {
-    // 注意：这是一个近似实现，因为JavaScript没有提供获取setTimeout剩余时间的API
-    // 可以在实际应用中使用更精确的测量方法
-    return 0; // 实际应用中应返回真实的剩余时间
+ * 创建一个自动释放的资源
+ * @param factory 资源工厂函数
+ * @param disposeCallback 释放回调函数
+ * @returns 创建的资源
+ */
+export function createDisposable<T>(
+  factory: () => T,
+  disposeCallback: (resource: T) => Promise<void> | void
+): T & Disposable {
+  const resource = factory();
+  
+  // 添加dispose方法
+  (resource as any).dispose = async () => {
+    await disposeCallback(resource);
+  };
+  
+  return resource as T & Disposable;
+}
+
+/**
+ * 使用资源并自动释放
+ * @param resource 可释放资源
+ * @param callback 使用资源的回调函数
+ * @returns 回调函数的返回值
+ */
+export async function using<T extends Disposable, R>(
+  resource: T,
+  callback: (resource: T) => Promise<R> | R
+): Promise<R> {
+  try {
+    const result = await callback(resource);
+    return result;
+  } finally {
+    await resource.dispose();
   }
 }