@qy_better_lib/hooks 0.1.9 → 0.2.0

package/__tests__/use-image/index.test.ts

@@ -0,0 +1,230 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { use_image } from '../../src/use-image';
+import { EImageType } from '../../src/use-image/type';
+
+// 模拟@qy_better_lib/core中的工具函数
+vi.mock('@qy_better_lib/core', () => {
+  // 在vi.mock内部定义MockFile类
+  class MockFile extends Blob {
+    name: string;
+    size: number;
+    type: string;
+
+    constructor(name: string, size: number, type: string) {
+      super([], { type });
+      this.name = name;
+      this.size = size;
+      this.type = type;
+    }
+  }
+
+  return {
+    __esModule: true,
+    to_base64: vi.fn().mockResolvedValue('data:image/jpeg;base64,test'),
+    download_file: vi.fn(),
+    compress_image: vi.fn().mockResolvedValue(new MockFile('compressed.jpg', 512, 'image/jpeg')),
+  };
+});
+
+// 模拟File对象
+class MockFile extends Blob {
+  name: string;
+  size: number;
+  type: string;
+
+  constructor(name: string, size: number, type: string) {
+    super([], { type });
+    this.name = name;
+    this.size = size;
+    this.type = type;
+  }
+}
+
+// 模拟Image对象
+class MockImage {
+  private _src: string = '';
+  onload: ((this: HTMLImageElement, ev: Event) => any) | null = null;
+  onerror: ((this: HTMLImageElement, ev: ErrorEvent) => any) | null = null;
+  width: number = 100;
+  height: number = 100;
+
+  constructor() {
+    // 模拟Image构造函数
+  }
+
+  // 模拟设置src时自动触发onload
+  set src(url: string) {
+    this._src = url;
+    // 延迟一点时间触发onload，模拟真实的图片加载
+    setTimeout(() => {
+      if (this.onload) {
+        this.onload.call(this as any, new Event('load'));
+      }
+    }, 0);
+  }
+
+  get src() {
+    return this._src;
+  }
+
+  // 模拟加载成功
+  simulateLoad() {
+    if (this.onload) {
+      this.onload.call(this as any, new Event('load'));
+    }
+  }
+
+  // 模拟加载失败
+  simulateError() {
+    if (this.onerror) {
+      this.onerror.call(this as any, new ErrorEvent('error', { error: new Error('Image load failed') }));
+    }
+  }
+}
+
+// 模拟Image构造函数
+vi.stubGlobal('Image', MockImage);
+
+// 模拟fetch
+const mockFetch: any = vi.fn().mockResolvedValue({
+  ok: true,
+  blob: vi.fn().mockResolvedValue(new Blob(['test'], { type: 'image/jpeg' })),
+});
+
+// 模拟document
+const mockDocument: any = {
+  createElement: vi.fn().mockReturnValue({
+    getContext: vi.fn().mockReturnValue({
+      scale: vi.fn(),
+      drawImage: vi.fn(),
+      clearRect: vi.fn(),
+      fillText: vi.fn(),
+      fillStyle: '',
+      font: '',
+      textAlign: '',
+      textBaseline: '',
+      rotate: vi.fn(),
+    }),
+    toDataURL: vi.fn().mockReturnValue('data:image/jpeg;base64,test'),
+    width: 100,
+    height: 100,
+  }),
+};
+
+// 模拟全局对象
+beforeEach(() => {
+  vi.clearAllMocks();
+  global.Image = MockImage as any;
+  global.fetch = mockFetch;
+  global.document = mockDocument as Document;
+});
+
+afterEach(() => {
+  vi.resetModules();
+});
+
+describe('use_image', () => {
+  it('should initialize with all methods', () => {
+    const imageMethods = use_image();
+    
+    expect(typeof imageMethods.compress).toBe('function');
+    expect(typeof imageMethods.compress_accurately).toBe('function');
+    expect(typeof imageMethods.compress_image).toBe('function');
+    expect(typeof imageMethods.canvas_to_data_url).toBe('function');
+    expect(typeof imageMethods.canvas_to_file).toBe('function');
+    expect(typeof imageMethods.data_url_to_file).toBe('function');
+    expect(typeof imageMethods.data_url_to_image).toBe('function');
+    expect(typeof imageMethods.file_to_data_url).toBe('function');
+    expect(typeof imageMethods.image_to_canvas).toBe('function');
+    expect(typeof imageMethods.url_to_blob).toBe('function');
+    expect(typeof imageMethods.url_to_image).toBe('function');
+    expect(typeof imageMethods.download_file).toBe('function');
+  });
+
+  it('should compress image successfully', async () => {
+    const { compress } = use_image();
+    
+    const mockFile = new MockFile('test.jpg', 1024, 'image/jpeg');
+    const result = await compress(mockFile, { quality: 0.8 });
+    
+    expect(result).toBeInstanceOf(Blob);
+  });
+
+  it('should compress image accurately', async () => {
+    const { compress_accurately } = use_image();
+    
+    const mockFile = new MockFile('test.jpg', 1024, 'image/jpeg');
+    const result = await compress_accurately(mockFile, { size: 0.5 });
+    
+    expect(result).toBeInstanceOf(Blob);
+  });
+
+  it('should use core compress image', async () => {
+    const { compress_image } = use_image();
+    
+    const mockFile = new MockFile('test.jpg', 1024, 'image/jpeg');
+    const result = await compress_image(mockFile);
+    
+    // 不检查是否是MockFile的实例，而是检查返回值是否具有正确的属性
+    expect(result).toBeInstanceOf(Blob);
+    expect(result.type).toBe('image/jpeg');
+  });
+
+  it('should convert file to data url', async () => {
+    const { file_to_data_url } = use_image();
+    
+    const mockFile = new MockFile('test.jpg', 1024, 'image/jpeg');
+    const result = await file_to_data_url(mockFile);
+    
+    expect(typeof result).toBe('string');
+    expect(result.startsWith('data:image')).toBe(true);
+  });
+
+  it('should convert url to blob', async () => {
+    const { url_to_blob } = use_image();
+    
+    const result = await url_to_blob('https://example.com/test.jpg');
+    
+    expect(result).toBeInstanceOf(Blob);
+  });
+
+  it('should convert url to image', async () => {
+    const { url_to_image } = use_image();
+    
+    const result = await url_to_image('https://example.com/test.jpg');
+    
+    expect(result).toBeInstanceOf(MockImage);
+  });
+
+  it('should download file', () => {
+    const { download_file } = use_image();
+    
+    const mockBlob = new Blob(['test'], { type: 'image/jpeg' });
+    download_file(mockBlob, 'test.jpg');
+  });
+
+  it('should handle invalid image type', async () => {
+    const { compress } = use_image();
+    
+    const mockFile = new MockFile('test.jpg', 1024, 'image/jpeg');
+    const result = await compress(mockFile, { type: 'invalid-type' as any });
+    
+    expect(result).toBeInstanceOf(Blob);
+  });
+
+  it('should return original file if compression fails', async () => {
+    const { compress } = use_image();
+    
+    const mockFile = new MockFile('test.jpg', 1024, 'image/jpeg');
+    // 模拟压缩后文件更大
+    const mockCompressedFile = new MockFile('compressed.jpg', 2048, 'image/jpeg');
+    
+    // 模拟canvas.toDataURL返回更大的文件
+    const canvas = mockDocument.createElement('canvas');
+    canvas.toDataURL = vi.fn().mockReturnValue('data:image/jpeg;base64,' + 'a'.repeat(3000));
+    
+    const result = await compress(mockFile, { quality: 0.8 });
+    
+    expect(result).toBeInstanceOf(Blob);
+  });
+});

package/__tests__/use-layout-flow/index.test.ts

@@ -0,0 +1,382 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { use_layout_flow } from '../../src/use-layout-flow';
+
+// 模拟@antv/x6库
+const mockGraph: any = {
+  getNodes: vi.fn().mockReturnValue([]),
+  getEdges: vi.fn().mockReturnValue([]),
+  resetCells: vi.fn(),
+  createNode: vi.fn().mockReturnValue({ id: 'test-node' }),
+  createEdge: vi.fn().mockReturnValue({ id: 'test-edge' }),
+  on: vi.fn(),
+  clearCells: vi.fn(),
+  zoomToFit: vi.fn(),
+  centerContent: vi.fn(),
+  getCellById: vi.fn().mockReturnValue(null),
+};
+
+// 模拟Graph构造函数
+class MockGraphClass {
+  constructor(options: any) {
+    return mockGraph;
+  }
+}
+
+const mockGraphClass: any = vi.fn(MockGraphClass);
+
+// 模拟dagre库
+const mockDagreGraph: any = {
+  setGraph: vi.fn(),
+  setDefaultEdgeLabel: vi.fn(),
+  setNode: vi.fn(),
+  setEdge: vi.fn(),
+  nodes: vi.fn().mockReturnValue([]),
+  node: vi.fn().mockReturnValue({ x: 0, y: 0 }),
+};
+
+const mockDagre: any = {
+  graphlib: {
+    Graph: vi.fn().mockImplementation(() => mockDagreGraph),
+  },
+  layout: vi.fn(),
+};
+
+// 模拟动态导入
+vi.mock('@antv/x6', () => {
+  return {
+    __esModule: true,
+    Graph: mockGraphClass,
+  };
+});
+
+vi.mock('dagre', () => {
+  return {
+    __esModule: true,
+    default: mockDagre,
+  };
+});
+
+// 确保mockGraph的getNodes和getEdges方法返回有效的数组
+mockGraph.getNodes = vi.fn().mockReturnValue([{ id: 'node1' }]);
+mockGraph.getEdges = vi.fn().mockReturnValue([{
+  getSource: vi.fn().mockReturnValue({ cell: 'node1' }),
+  getTarget: vi.fn().mockReturnValue({ cell: 'node2' }),
+  getSourceNode: vi.fn().mockReturnValue({ getBBox: vi.fn().mockReturnValue({ x: 0, y: 0, width: 100, height: 60, center: { x: 50, y: 30 } }) }),
+  getTargetNode: vi.fn().mockReturnValue({ getBBox: vi.fn().mockReturnValue({ x: 200, y: 0, width: 100, height: 60, center: { x: 250, y: 30 } }) }),
+  setVertices: vi.fn(),
+}]);
+
+// 模拟deep_assign函数
+vi.mock('@qy_better_lib/core', () => {
+  return {
+    __esModule: true,
+    deep_assign: vi.fn().mockImplementation((...args) => Object.assign({}, ...args)),
+  };
+});
+
+// 模拟容器元素
+const mockContainer: any = {
+  id: 'test-container',
+  clientWidth: 800,
+  clientHeight: 600,
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+afterEach(() => {
+  vi.resetModules();
+});
+
+describe('use_layout_flow', () => {
+  it('should initialize and return all methods', () => {
+    const layoutFlow = use_layout_flow({});
+    
+    expect(typeof layoutFlow.init).toBe('function');
+    expect(typeof layoutFlow.add_graph_elements).toBe('function');
+    expect(typeof layoutFlow.layout).toBe('function');
+    expect(typeof layoutFlow.center_content).toBe('function');
+    expect(typeof layoutFlow.create_nodes).toBe('function');
+    expect(typeof layoutFlow.create_edges).toBe('function');
+    expect(typeof layoutFlow.register_event).toBe('function');
+    expect(typeof layoutFlow.register_custom_elements).toBe('function');
+    expect(typeof layoutFlow.get_nodes).toBe('function');
+    expect(typeof layoutFlow.clear).toBe('function');
+  });
+
+  it('should initialize graph successfully', async () => {
+    const layoutFlow = use_layout_flow({});
+    
+    const result = await layoutFlow.init(mockContainer);
+    
+    expect(result).toBe(true);
+    expect(mockGraphClass).toHaveBeenCalled();
+  });
+
+  it('should handle init with null container', async () => {
+    const layoutFlow = use_layout_flow({});
+    
+    await expect(layoutFlow.init(null as any)).rejects.toThrow('init(): 容器元素不能为空');
+  });
+
+  it('should add graph elements', async () => {
+    const layoutFlow = use_layout_flow({});
+    
+    // 先初始化
+    await layoutFlow.init(mockContainer);
+    
+    const testElements = [{ id: 'node1' }, { id: 'edge1' }];
+    layoutFlow.add_graph_elements(testElements);
+    
+    expect(mockGraph.resetCells).toHaveBeenCalledWith(testElements);
+  });
+
+  it('should handle add_graph_elements without initialization', () => {
+    const layoutFlow = use_layout_flow({});
+    
+    const testElements = [{ id: 'node1' }];
+    layoutFlow.add_graph_elements(testElements);
+    
+    expect(mockGraph.resetCells).not.toHaveBeenCalled();
+  });
+
+  it('should handle add_graph_elements with non-array elements', async () => {
+    const layoutFlow = use_layout_flow({});
+    
+    // 先初始化
+    await layoutFlow.init(mockContainer);
+    
+    layoutFlow.add_graph_elements('not-an-array' as any);
+    
+    expect(mockGraph.resetCells).not.toHaveBeenCalled();
+  });
+
+  it('should layout successfully', async () => {
+    const layoutFlow = use_layout_flow({});
+    
+    // 先初始化
+    await layoutFlow.init(mockContainer);
+    
+    const layoutConfig = {
+      node_w: 100,
+      node_h: 60,
+      nodesep: 20,
+      ranksep: 40,
+    };
+    
+    const result = await layoutFlow.layout(layoutConfig, 'LR');
+    
+    expect(result).toBe(true);
+    expect(mockDagre.layout).toHaveBeenCalled();
+  });
+
+  it('should handle layout without initialization', async () => {
+    const layoutFlow = use_layout_flow({});
+    
+    const layoutConfig = {
+      node_w: 100,
+      node_h: 60,
+      nodesep: 20,
+      ranksep: 40,
+    };
+    
+    const result = await layoutFlow.layout(layoutConfig, 'LR');
+    
+    expect(result).toBe(false);
+  });
+
+  it('should handle layout with invalid config', async () => {
+    const layoutFlow = use_layout_flow({});
+    
+    // 先初始化
+    await layoutFlow.init(mockContainer);
+    
+    const invalidConfig = {
+      node_w: -100, // 无效值
+      node_h: 60,
+      nodesep: 20,
+      ranksep: 40,
+    };
+    
+    const result = await layoutFlow.layout(invalidConfig as any, 'LR');
+    
+    expect(result).toBe(false);
+  });
+
+  it('should handle layout with invalid direction', async () => {
+    const layoutFlow = use_layout_flow({});
+    
+    // 先初始化
+    await layoutFlow.init(mockContainer);
+    
+    const layoutConfig = {
+      node_w: 100,
+      node_h: 60,
+      nodesep: 20,
+      ranksep: 40,
+    };
+    
+    const result = await layoutFlow.layout(layoutConfig, 'invalid-direction' as any);
+    
+    expect(result).toBe(false);
+  });
+
+  it('should center content', async () => {
+    const layoutFlow = use_layout_flow({});
+    
+    // 先初始化
+    await layoutFlow.init(mockContainer);
+    
+    layoutFlow.center_content(20);
+    
+    expect(mockGraph.zoomToFit).toHaveBeenCalledWith({ padding: 20, maxScale: 1.2 });
+    expect(mockGraph.centerContent).toHaveBeenCalled();
+  });
+
+  it('should handle center_content without initialization', () => {
+    const layoutFlow = use_layout_flow({});
+    
+    layoutFlow.center_content(20);
+    
+    expect(mockGraph.zoomToFit).not.toHaveBeenCalled();
+  });
+
+  it('should create nodes', async () => {
+    const layoutFlow = use_layout_flow({});
+    
+    // 先初始化
+    await layoutFlow.init(mockContainer);
+    
+    const nodeOptions = [{ id: 'node1' }, { id: 'node2' }];
+    const nodes = layoutFlow.create_nodes(nodeOptions);
+    
+    expect(nodes.length).toBe(2);
+    expect(mockGraph.createNode).toHaveBeenCalledTimes(2);
+  });
+
+  it('should handle create_nodes without initialization', () => {
+    const layoutFlow = use_layout_flow({});
+    
+    const nodeOptions = [{ id: 'node1' }];
+    const nodes = layoutFlow.create_nodes(nodeOptions);
+    
+    expect(nodes.length).toBe(0);
+  });
+
+  it('should create edges', async () => {
+    const layoutFlow = use_layout_flow({});
+    
+    // 先初始化
+    await layoutFlow.init(mockContainer);
+    
+    const edgeOptions = [
+      { source_id: 'node1', target_id: 'node2' },
+      { source_id: 'node2', target_id: 'node3' },
+    ];
+    const edges = layoutFlow.create_edges(edgeOptions);
+    
+    expect(edges.length).toBe(2);
+    expect(mockGraph.createEdge).toHaveBeenCalledTimes(2);
+  });
+
+  it('should handle create_edges without initialization', () => {
+    const layoutFlow = use_layout_flow({});
+    
+    const edgeOptions = [{ source_id: 'node1', target_id: 'node2' }];
+    const edges = layoutFlow.create_edges(edgeOptions);
+    
+    expect(edges.length).toBe(0);
+  });
+
+  it('should register events', async () => {
+    const layoutFlow = use_layout_flow({});
+    
+    // 先初始化
+    await layoutFlow.init(mockContainer);
+    
+    const eventOptions = {
+      'node:click': vi.fn(),
+      'edge:click': vi.fn(),
+    };
+    
+    layoutFlow.register_event(eventOptions);
+    
+    expect(mockGraph.on).toHaveBeenCalledTimes(2);
+  });
+
+  it('should handle register_event without initialization', () => {
+    const layoutFlow = use_layout_flow({});
+    
+    const eventOptions = {
+      'node:click': vi.fn(),
+    };
+    
+    layoutFlow.register_event(eventOptions);
+    
+    expect(mockGraph.on).not.toHaveBeenCalled();
+  });
+
+  it('should register custom elements', async () => {
+    const layoutFlow = use_layout_flow({});
+    
+    const customElements = {
+      nodes: {
+        'custom-node': { shape: 'rect' },
+      },
+      edges: {
+        'custom-edge': { shape: 'polyline' },
+      },
+    };
+    
+    // 模拟Graph.registerNode和Graph.registerEdge
+    mockGraphClass.registerNode = vi.fn();
+    mockGraphClass.registerEdge = vi.fn();
+    
+    const result = await layoutFlow.register_custom_elements(customElements);
+    
+    expect(result).toBe(true);
+    expect(mockGraphClass.registerNode).toHaveBeenCalledWith('custom-node', { shape: 'rect' }, true);
+    expect(mockGraphClass.registerEdge).toHaveBeenCalledWith('custom-edge', { shape: 'polyline' }, true);
+  });
+
+  it('should get nodes', async () => {
+    const layoutFlow = use_layout_flow({});
+    
+    // 先初始化
+    await layoutFlow.init(mockContainer);
+    
+    const nodes = layoutFlow.get_nodes();
+    
+    expect(mockGraph.getNodes).toHaveBeenCalled();
+    // 期望返回我们mock的节点数组
+    expect(nodes).toEqual([{ id: 'node1' }]);
+  });
+
+  it('should handle get_nodes without initialization', () => {
+    const layoutFlow = use_layout_flow({});
+    
+    const nodes = layoutFlow.get_nodes();
+    
+    expect(nodes).toEqual([]);
+  });
+
+  it('should clear graph', async () => {
+    const layoutFlow = use_layout_flow({});
+    
+    // 先初始化
+    await layoutFlow.init(mockContainer);
+    
+    layoutFlow.clear();
+    
+    expect(mockGraph.clearCells).toHaveBeenCalled();
+  });
+
+  it('should handle clear without initialization', () => {
+    const layoutFlow = use_layout_flow({});
+    
+    layoutFlow.clear();
+    
+    // 应该不会抛出错误
+  });
+});