qy-better-lib 0.0.1

package/packages/hooks/__tests__/use-websocket/index.test.ts

@@ -0,0 +1,402 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { use_web_socket } from '../../src/use-websocket';
+
+// 模拟WebSocket对象
+class MockWebSocket {
+  readyState: number;
+  url: string;
+  onopen: ((event: Event) => void) | null;
+  onerror: ((event: Event) => void) | null;
+  onclose: ((event: CloseEvent) => void) | null;
+  onmessage: ((event: MessageEvent) => void) | null;
+
+  constructor(url: string) {
+    this.url = url;
+    this.readyState = WebSocket.CONNECTING;
+    this.onopen = null;
+    this.onerror = null;
+    this.onclose = null;
+    this.onmessage = null;
+  }
+
+  send(data: string) {
+    // 模拟发送消息
+  }
+
+  close() {
+    this.readyState = WebSocket.CLOSED;
+    if (this.onclose) {
+      const closeEvent = new CloseEvent('close', { code: 1000, reason: 'Normal closure' });
+      this.onclose(closeEvent);
+    }
+  }
+
+  // 模拟连接成功
+  simulateOpen() {
+    this.readyState = WebSocket.OPEN;
+    if (this.onopen) {
+      this.onopen(new Event('open'));
+    }
+  }
+
+  // 模拟连接错误
+  simulateError() {
+    if (this.onerror) {
+      this.onerror(new Event('error'));
+    }
+  }
+
+  // 模拟接收消息
+  simulateMessage(data: any) {
+    if (this.onmessage) {
+      const messageEvent = new MessageEvent('message', { data });
+      this.onmessage(messageEvent);
+    }
+  }
+}
+
+// 模拟WebSocket构造函数
+const mockWebSocketClass = vi.fn().mockImplementation((url: string) => new MockWebSocket(url));
+
+// 模拟全局对象
+beforeEach(() => {
+  vi.clearAllMocks();
+  global.WebSocket = mockWebSocketClass as any;
+  // 模拟setTimeout和clearTimeout
+  vi.useFakeTimers();
+});
+
+afterEach(() => {
+  vi.resetModules();
+  vi.useRealTimers();
+});
+
+describe('use_web_socket', () => {
+  it('should initialize with default values', () => {
+    const mockReceive = vi.fn();
+    const { ws, create, close, send_message, get_status, reconnect, start_heartbeat, stop_heartbeat } = use_web_socket({
+      server: 'ws://localhost:8080',
+      receive: mockReceive,
+    });
+    
+    expect(ws).toBeUndefined();
+    expect(typeof create).toBe('function');
+    expect(typeof close).toBe('function');
+    expect(typeof send_message).toBe('function');
+    expect(typeof get_status).toBe('function');
+    expect(typeof reconnect).toBe('function');
+    expect(typeof start_heartbeat).toBe('function');
+    expect(typeof stop_heartbeat).toBe('function');
+  });
+
+  it('should create and connect WebSocket successfully', () => {
+    const mockReceive = vi.fn();
+    const mockOnOpen = vi.fn();
+    
+    const { create, get_status } = use_web_socket({
+      server: 'ws://localhost:8080',
+      receive: mockReceive,
+      on_open: mockOnOpen,
+      auto_connect: false,
+    });
+    
+    // 创建连接
+    create();
+    
+    expect(mockWebSocketClass).toHaveBeenCalledWith('ws://localhost:8080');
+    
+    // 模拟连接成功
+    const wsInstance = (global.WebSocket as any).mock.instances[0];
+    if (wsInstance) {
+      wsInstance.simulateOpen();
+      expect(mockOnOpen).toHaveBeenCalled();
+    }
+  });
+
+  it('should handle WebSocket error', () => {
+    const mockReceive = vi.fn();
+    const mockOnError = vi.fn();
+    
+    const { create } = use_web_socket({
+      server: 'ws://localhost:8080',
+      receive: mockReceive,
+      on_error: mockOnError,
+      auto_connect: false,
+    });
+    
+    // 创建连接
+    create();
+    
+    // 模拟连接错误
+    const wsInstance = (global.WebSocket as any).mock.instances[0];
+    if (wsInstance) {
+      wsInstance.simulateError();
+      expect(mockOnError).toHaveBeenCalled();
+    }
+  });
+
+  it('should handle WebSocket close', () => {
+    const mockReceive = vi.fn();
+    const mockOnClose = vi.fn();
+    
+    const { create } = use_web_socket({
+      server: 'ws://localhost:8080',
+      receive: mockReceive,
+      on_close: mockOnClose,
+      auto_connect: false,
+    });
+    
+    // 创建连接
+    create();
+    
+    // 模拟连接成功
+    const wsInstance = (global.WebSocket as any).mock.instances[0];
+    if (wsInstance) {
+      wsInstance.simulateOpen();
+      
+      // 关闭连接
+      wsInstance.close();
+      
+      expect(mockOnClose).toHaveBeenCalled();
+    }
+  });
+
+  it('should send message successfully', () => {
+    const mockReceive = vi.fn();
+    
+    const { create, send_message } = use_web_socket({
+      server: 'ws://localhost:8080',
+      receive: mockReceive,
+      auto_connect: false,
+    });
+    
+    // 创建连接
+    create();
+    
+    // 模拟连接成功
+    const wsInstance = (global.WebSocket as any).mock.instances[0];
+    if (wsInstance) {
+      wsInstance.simulateOpen();
+      
+      // 发送消息
+      const sendSpy = vi.spyOn(wsInstance, 'send');
+      const result = send_message('test message');
+      
+      expect(result).toBe(true);
+      expect(sendSpy).toHaveBeenCalledWith('test message');
+    }
+  });
+
+  it('should handle send message when not connected', () => {
+    const mockReceive = vi.fn();
+    
+    const { send_message } = use_web_socket({
+      server: 'ws://localhost:8080',
+      receive: mockReceive,
+      auto_connect: false,
+    });
+    
+    // 未连接时发送消息
+    const result = send_message('test message');
+    
+    expect(result).toBe(false);
+  });
+
+  it('should receive message', () => {
+    const mockReceive = vi.fn();
+    
+    const { create } = use_web_socket({
+      server: 'ws://localhost:8080',
+      receive: mockReceive,
+      auto_connect: false,
+    });
+    
+    // 创建连接
+    create();
+    
+    // 模拟连接成功
+    const wsInstance = (global.WebSocket as any).mock.instances[0];
+    if (wsInstance) {
+      wsInstance.simulateOpen();
+      
+      // 模拟接收消息
+      wsInstance.simulateMessage('test message');
+      
+      expect(mockReceive).toHaveBeenCalled();
+    }
+  });
+
+  it('should reconnect automatically', () => {
+    const mockReceive = vi.fn();
+    
+    const { create } = use_web_socket({
+      server: 'ws://localhost:8080',
+      receive: mockReceive,
+      auto_reconnect: true,
+      reconnect_interval: 1000,
+      auto_connect: false,
+    });
+    
+    // 创建连接
+    create();
+    expect(mockWebSocketClass).toHaveBeenCalledTimes(1);
+    
+    // 模拟连接成功
+    const wsInstance1 = (global.WebSocket as any).mock.instances[0];
+    if (wsInstance1) {
+      wsInstance1.simulateOpen();
+      
+      // 关闭连接（非干净关闭）
+      wsInstance1.close();
+      
+      // 快进时间，触发重连
+      vi.advanceTimersByTime(1000);
+      
+      expect(mockWebSocketClass).toHaveBeenCalledTimes(2);
+    }
+  });
+
+  it('should start and stop heartbeat', () => {
+    const mockReceive = vi.fn();
+    
+    const { create, start_heartbeat, stop_heartbeat } = use_web_socket({
+      server: 'ws://localhost:8080',
+      receive: mockReceive,
+      heartbeat_interval: 5000,
+      auto_connect: false,
+    });
+    
+    // 创建连接
+    create();
+    
+    // 模拟连接成功
+    const wsInstance = (global.WebSocket as any).mock.instances[0];
+    if (wsInstance) {
+      wsInstance.simulateOpen();
+      
+      // 启动心跳
+      start_heartbeat();
+      
+      // 快进时间，触发心跳
+      const sendSpy = vi.spyOn(wsInstance, 'send');
+      vi.advanceTimersByTime(5000);
+      
+      expect(sendSpy).toHaveBeenCalledWith('ping');
+      
+      // 停止心跳
+      stop_heartbeat();
+      
+      // 快进时间，不应再触发心跳
+      sendSpy.mockClear();
+      vi.advanceTimersByTime(5000);
+      
+      expect(sendSpy).not.toHaveBeenCalled();
+    }
+  });
+
+  it('should get correct connection status', () => {
+    const mockReceive = vi.fn();
+    
+    const { create, get_status, close } = use_web_socket({
+      server: 'ws://localhost:8080',
+      receive: mockReceive,
+      auto_connect: false,
+    });
+    
+    // 初始状态
+    expect(get_status()).toBe('CLOSED');
+    
+    // 创建连接
+    create();
+    
+    // 模拟连接成功
+    const wsInstance = (global.WebSocket as any).mock.instances[0];
+    if (wsInstance) {
+      wsInstance.simulateOpen();
+    }
+    
+    // 关闭连接
+    close();
+    expect(get_status()).toBe('CLOSED');
+  });
+
+  it('should handle connection with auto_connect', () => {
+    const mockReceive = vi.fn();
+    
+    use_web_socket({
+      server: 'ws://localhost:8080',
+      receive: mockReceive,
+      auto_connect: true,
+    });
+    
+    expect(mockWebSocketClass).toHaveBeenCalledWith('ws://localhost:8080');
+  });
+
+  it('should handle connection error with auto_reconnect', () => {
+    const mockReceive = vi.fn();
+    
+    use_web_socket({
+      server: 'ws://localhost:8080',
+      receive: mockReceive,
+      auto_reconnect: true,
+      reconnect_interval: 1000,
+      auto_connect: true,
+    });
+    
+    expect(mockWebSocketClass).toHaveBeenCalledTimes(1);
+    
+    // 模拟连接错误
+    const wsInstance = (global.WebSocket as any).mock.instances[0];
+    if (wsInstance) {
+      wsInstance.simulateError();
+      
+      // 快进时间，触发重连
+      vi.advanceTimersByTime(1000);
+      
+      expect(mockWebSocketClass).toHaveBeenCalledTimes(2);
+    }
+  });
+
+  it('should handle message queue when not connected', () => {
+    const mockReceive = vi.fn();
+    
+    const { send_message, create } = use_web_socket({
+      server: 'ws://localhost:8080',
+      receive: mockReceive,
+      auto_connect: false,
+    });
+    
+    // 未连接时发送消息
+    send_message('message 1');
+    send_message('message 2');
+    
+    // 创建连接
+    create();
+    
+    // 模拟连接成功
+    const wsInstance = (global.WebSocket as any).mock.instances[0];
+    if (wsInstance) {
+      const sendSpy = vi.spyOn(wsInstance, 'send');
+      wsInstance.simulateOpen();
+      
+      // 验证队列中的消息是否被发送
+      expect(sendSpy).toHaveBeenCalledTimes(2);
+    }
+  });
+
+  it('should limit message queue size', () => {
+    const mockReceive = vi.fn();
+    
+    const { send_message } = use_web_socket({
+      server: 'ws://localhost:8080',
+      receive: mockReceive,
+      auto_connect: false,
+      max_message_queue_size: 2,
+    });
+    
+    // 未连接时发送多条消息
+    send_message('message 1');
+    send_message('message 2');
+    send_message('message 3'); // 这应该替换最旧的消息
+  });
+});

package/packages/hooks/package.json

@@ -0,0 +1,104 @@
+{
+  "name": "@qy_better_lib/hooks",
+  "private": false,
+  "version": "0.2.9",
+  "description": "qy better lib hooks",
+  "author": "luhuiming",
+  "license": "MIT",
+  "scripts": {
+    "build:lib": "vite build --config vite.lib.config.ts",
+    "build:dist-min": "vite build --config vite.dist.min.config.ts",
+    "build": "yarn build:lib && yarn build:dist-min",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "main": "lib/index.mjs",
+  "module": "lib/index.mjs",
+  "types": "lib/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "lib/index.mjs": [
+        "lib/index.d.ts"
+      ],
+      "@qy-better-lib/hooks": [
+        "lib/index.d.ts"
+      ],
+      "*": [
+        "*",
+        "dist/*",
+        "lib/*",
+        "lib/*.d.ts",
+        "lib/*/index.d.ts"
+      ]
+    }
+  },
+  "exports": {
+    ".": {
+      "import": "./lib/index.mjs",
+      "types": "./lib/index.d.ts"
+    },
+    "./*": {
+      "import": "./lib/*/index.mjs",
+      "types": "./lib/*/index.d.ts"
+    },
+    "./use-chart": {
+      "import": "./lib/use-chart/index.mjs",
+      "types": "./lib/use-chart/index.d.ts"
+    },
+    "./use-layout-flow": {
+      "import": "./lib/use-layout-flow/index.mjs",
+      "types": "./lib/use-layout-flow/index.d.ts"
+    },
+    "./use-mqtt": {
+      "import": "./lib/use-mqtt/index.mjs",
+      "types": "./lib/use-mqtt/index.d.ts"
+    }
+  },
+  "devDependencies": {
+    "@antv/x6": "^2.18.1",
+    "@qy_better_lib/core": "^0.2.8",
+    "@types/dagre": "^0.7.53",
+    "@types/node": "^24.5.2",
+    "@vitejs/plugin-vue": "^6.0.1",
+    "dagre": "^0.8.5",
+    "echarts": "5.6.0",
+    "mitt": "^3.0.1",
+    "mqtt": "^5.14.1",
+    "vite": "^7.1.7",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.0.18",
+    "vue": "^3.5.22"
+  },
+  "peerDependencies": {
+    "@antv/x6": "^2.18.1",
+    "@qy_better_lib/core": "^0.2.0",
+    "dagre": "^0.8.5",
+    "echarts": "5.6.0",
+    "mitt": "^3.0.1",
+    "mqtt": "^5.14.1",
+    "vue": "^3.5.22"
+  },
+  "peerDependenciesMeta": {
+    "@antv/x6": {
+      "optional": true
+    },
+    "dagre": {
+      "optional": true
+    },
+    "echarts": {
+      "optional": true
+    },
+    "mitt": {
+      "optional": true
+    },
+    "mqtt": {
+      "optional": true
+    },
+    "@qy_better_lib/core": {
+      "optional": false
+    }
+  },
+  "dependencies": {
+    "@qy_better_lib/hooks": "^0.2.6"
+  }
+}

package/packages/hooks/types/index.d.ts

@@ -0,0 +1 @@
+declare type $TODO = any

package/packages/hooks/types/json.d.ts

@@ -0,0 +1,4 @@
+declare module "*.json" {
+    const value: any;
+    export default value;
+}

package/packages/hooks/types/vue.shim.d.ts

@@ -0,0 +1,5 @@
+declare module '*.vue' {
+  import { ComponentOptions } from 'vue'
+  const Component: ComponentOptions
+  export default Component
+}