id-scanner-lib 1.3.3 → 1.6.2

package/src/utils/image-processing.ts

@@ -6,6 +6,7 @@
  */
 
 import imageCompression from "browser-image-compression"
+import { Point, Rect, ImageProcessingOptions } from './types';
 
 /**
  * 图像处理器配置选项
@@ -481,68 +482,86 @@ export class ImageProcessor {
   }
 
   /**
-   * 调整图像大小
-   *
-   * @param imageData 原始图像数据
+   * 将图像调整到指定大小
+   * @param image 输入图像
    * @param maxWidth 最大宽度
    * @param maxHeight 最大高度
-   * @param maintainAspectRatio 是否保持宽高比
-   * @returns ImageData 调整大小后的图像数据
+   * @param keepAspectRatio 是否保持宽高比
+   * @returns 调整后的图像
    */
-  static resizeImage(
-    imageData: ImageData,
+  public static resizeImage(
+    image: ImageData | HTMLImageElement | HTMLCanvasElement,
     maxWidth: number,
     maxHeight: number,
-    maintainAspectRatio: boolean = true
+    keepAspectRatio: boolean = true
   ): ImageData {
-    const { width, height } = imageData
-
-    // 如果图像已经小于指定大小，则不需要调整
-    if (width <= maxWidth && height <= maxHeight) {
-      return imageData
+    // 创建canvas元素
+    const canvas = document.createElement('canvas');
+    const ctx = canvas.getContext('2d');
+    
+    if (!ctx) {
+      throw new Error('无法创建Canvas上下文');
     }
-
-    let newWidth = maxWidth
-    let newHeight = maxHeight
-
-    // 计算新的尺寸，保持宽高比
-    if (maintainAspectRatio) {
-      const ratio = Math.min(maxWidth / width, maxHeight / height)
-      newWidth = Math.floor(width * ratio)
-      newHeight = Math.floor(height * ratio)
+    
+    // 获取图像尺寸
+    let width: number;
+    let height: number;
+    
+    if (image instanceof ImageData) {
+      width = image.width;
+      height = image.height;
+    } else {
+      width = image.width;
+      height = image.height;
     }
-
-    // 创建用于调整大小的Canvas
-    const canvas = document.createElement("canvas")
-    canvas.width = newWidth
-    canvas.height = newHeight
-
-    const ctx = canvas.getContext("2d")
-    if (!ctx) {
-      throw new Error("无法创建2D上下文")
+    
+    // 计算调整后的尺寸
+    let newWidth = width;
+    let newHeight = height;
+    
+    if (keepAspectRatio) {
+      if (width > height) {
+        if (width > maxWidth) {
+          newHeight = Math.round(height * (maxWidth / width));
+          newWidth = maxWidth;
+        }
+      } else {
+        if (height > maxHeight) {
+          newWidth = Math.round(width * (maxHeight / height));
+          newHeight = maxHeight;
+        }
+      }
+    } else {
+      newWidth = Math.min(width, maxWidth);
+      newHeight = Math.min(height, maxHeight);
     }
-
-    // 创建临时Canvas绘制原始ImageData
-    const tempCanvas = document.createElement("canvas")
-    tempCanvas.width = width
-    tempCanvas.height = height
-
-    const tempCtx = tempCanvas.getContext("2d")
+    
+    // 设置canvas尺寸
+    canvas.width = newWidth;
+    canvas.height = newHeight;
+    
+    // 绘制调整后的图像
+    if (image instanceof ImageData) {
+      // 创建临时canvas存储ImageData
+      const tempCanvas = document.createElement('canvas');
+      const tempCtx = tempCanvas.getContext('2d');
+      
     if (!tempCtx) {
-      throw new Error("无法创建临时2D上下文")
+        throw new Error('无法创建临时Canvas上下文');
     }
 
-    tempCtx.putImageData(imageData, 0, 0)
-
-    // 使用缩放平滑算法
-    ctx.imageSmoothingEnabled = true
-    ctx.imageSmoothingQuality = "high"
-
-    // 绘制调整大小的图像
-    ctx.drawImage(tempCanvas, 0, 0, width, height, 0, 0, newWidth, newHeight)
+      tempCanvas.width = image.width;
+      tempCanvas.height = image.height;
+      tempCtx.putImageData(image, 0, 0);
+      
+      // 绘制调整后的图像
+      ctx.drawImage(tempCanvas, 0, 0, width, height, 0, 0, newWidth, newHeight);
+    } else {
+      ctx.drawImage(image, 0, 0, width, height, 0, 0, newWidth, newHeight);
+    }
 
-    // 获取新的ImageData
-    return ctx.getImageData(0, 0, newWidth, newHeight)
+    // 返回调整后的ImageData
+    return ctx.getImageData(0, 0, newWidth, newHeight);
   }
   
   /**

package/src/utils/index.test.ts

@@ -0,0 +1,186 @@
+/**
+ * @file 通用工具测试
+ * @description 测试通用工具函数
+ */
+
+import {
+  delay,
+  throttle,
+  debounce,
+  formatBytes,
+  generateUUID,
+  chunk,
+  safeParseJSON,
+  clamp,
+  isValidUrl,
+  browserCapabilities
+} from './index';
+
+describe('delay', () => {
+  it('should delay for specified milliseconds', async () => {
+    const start = Date.now();
+    await delay(50);
+    const elapsed = Date.now() - start;
+    
+    expect(elapsed).toBeGreaterThanOrEqual(45);
+  });
+});
+
+describe('throttle', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('should throttle function calls', () => {
+    let count = 0;
+    const fn = throttle(() => count++, 100);
+    
+    fn();
+    fn();
+    fn();
+    
+    expect(count).toBe(1);
+    
+    jest.advanceTimersByTime(100);
+    
+    fn();
+    expect(count).toBe(2);
+  });
+});
+
+describe('debounce', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('should debounce function calls', () => {
+    let count = 0;
+    const fn = debounce(() => count++, 100);
+    
+    fn();
+    fn();
+    fn();
+    
+    expect(count).toBe(0);
+    
+    jest.advanceTimersByTime(100);
+    
+    expect(count).toBe(1);
+  });
+
+  it('should execute immediately when immediate is true', () => {
+    let count = 0;
+    const fn = debounce(() => count++, 100, true);
+    
+    fn();
+    // Immediate should execute once
+    expect(count).toBe(1);
+    
+    // Advance time and check if it runs again
+    jest.advanceTimersByTime(100);
+    // Depending on implementation, this may vary
+    expect(count).toBeGreaterThanOrEqual(1);
+  });
+});
+
+describe('formatBytes', () => {
+  it('should format bytes correctly', () => {
+    expect(formatBytes(0)).toBe('0 Bytes');
+    expect(formatBytes(1024)).toBe('1 KB');
+    expect(formatBytes(1024 * 1024)).toBe('1 MB');
+    expect(formatBytes(1024 * 1024 * 1024)).toBe('1 GB');
+  });
+
+  it('should handle decimals', () => {
+    expect(formatBytes(1536, 2)).toBe('1.5 KB');
+  });
+});
+
+describe('generateUUID', () => {
+  it('should generate valid UUID', () => {
+    const uuid = generateUUID();
+    
+    expect(uuid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
+  });
+
+  it('should generate unique UUIDs', () => {
+    const uuids = new Set<string>();
+    for (let i = 0; i < 100; i++) {
+      uuids.add(generateUUID());
+    }
+    
+    expect(uuids.size).toBe(100);
+  });
+});
+
+describe('chunk', () => {
+  it('should split array into chunks', () => {
+    const arr = [1, 2, 3, 4, 5, 6, 7];
+    const chunks = chunk(arr, 3);
+    
+    expect(chunks).toEqual([[1, 2, 3], [4, 5, 6], [7]]);
+  });
+
+  it('should throw error for invalid chunk size', () => {
+    expect(() => chunk([1, 2, 3], 0)).toThrow();
+  });
+});
+
+describe('safeParseJSON', () => {
+  it('should parse valid JSON', () => {
+    const result = safeParseJSON('{"a": 1}', { default: true });
+    expect(result).toEqual({ a: 1 });
+  });
+
+  it('should return fallback for invalid JSON', () => {
+    const result = safeParseJSON<boolean>('invalid', true);
+    expect(result).toBe(true);
+  });
+});
+
+describe('clamp', () => {
+  it('should clamp value within range', () => {
+    expect(clamp(5, 0, 10)).toBe(5);
+    expect(clamp(-5, 0, 10)).toBe(0);
+    expect(clamp(15, 0, 10)).toBe(10);
+  });
+});
+
+describe('isValidUrl', () => {
+  it('should validate URLs', () => {
+    expect(isValidUrl('https://example.com')).toBe(true);
+    expect(isValidUrl('http://test.com/path')).toBe(true);
+    expect(isValidUrl('invalid')).toBe(false);
+    expect(isValidUrl('not a url')).toBe(false);
+  });
+});
+
+describe('browserCapabilities', () => {
+  it('should check camera support', () => {
+    expect(typeof browserCapabilities.hasCamera).toBe('function');
+  });
+
+  it('should check WebAssembly support', () => {
+    expect(typeof browserCapabilities.hasWasm).toBe('function');
+  });
+
+  it('should check WebWorker support', () => {
+    expect(typeof browserCapabilities.hasWebWorker).toBe('function');
+  });
+
+  it('should check WebGL support', () => {
+    expect(typeof browserCapabilities.hasWebGL).toBe('function');
+  });
+
+  it('should use supports method', () => {
+    expect(typeof browserCapabilities.supports).toBe('function');
+  });
+});