ly-utils-lib 2.4.0 → 2.6.0

package/dist/index.cjs

@@ -3329,6 +3329,341 @@ var pbkdf2 = (password, salt, iterations = 1e3, keySize = 32) => {
 var uuid2 = () => {
   return CryptoJS__namespace.lib.WordArray.random(16).toString();
 };
+
+// src/modules/websocket/index.ts
+var websocket_exports = {};
+__export(websocket_exports, {
+  WebSocketClient: () => WebSocketClient,
+  WebSocketState: () => WebSocketState,
+  createWebSocket: () => createWebSocket,
+  default: () => websocket_default,
+  quickConnect: () => quickConnect
+});
+var WebSocketState = /* @__PURE__ */ ((WebSocketState2) => {
+  WebSocketState2[WebSocketState2["CONNECTING"] = 0] = "CONNECTING";
+  WebSocketState2[WebSocketState2["OPEN"] = 1] = "OPEN";
+  WebSocketState2[WebSocketState2["CLOSING"] = 2] = "CLOSING";
+  WebSocketState2[WebSocketState2["CLOSED"] = 3] = "CLOSED";
+  return WebSocketState2;
+})(WebSocketState || {});
+var WebSocketClient = class {
+  constructor(options) {
+    this.ws = null;
+    this.handlers = {};
+    this.reconnectTimer = null;
+    this.heartbeatTimer = null;
+    this.heartbeatTimeoutTimer = null;
+    this.reconnectCount = 0;
+    this.isManualDisconnect = false;
+    this.messageQueue = [];
+    this.connectResolve = null;
+    this.connectReject = null;
+    this.options = {
+      url: options.url,
+      protocol: options.protocol || (options.url.startsWith("https") ? "wss" : "ws"),
+      protocols: options.protocols || [],
+      autoReconnect: options.autoReconnect ?? true,
+      reconnectAttempts: options.reconnectAttempts ?? 3,
+      reconnectInterval: options.reconnectInterval ?? 3e3,
+      heartbeatInterval: options.heartbeatInterval ?? 3e4,
+      heartbeatMessage: options.heartbeatMessage ?? "ping",
+      heartbeatTimeout: options.heartbeatTimeout ?? 5e3,
+      connectTimeout: options.connectTimeout ?? 1e4,
+      debug: options.debug ?? true
+    };
+    if (options.autoReconnect !== false) {
+      this.connect();
+    }
+  }
+  /**
+   * 连接 WebSocket
+   */
+  connect() {
+    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
+      this.log("WebSocket already connected or connecting");
+      return;
+    }
+    this.isManualDisconnect = false;
+    this.reconnectCount = 0;
+    const protocol = this.options.url.startsWith("ws://") || this.options.url.startsWith("wss://") ? "" : `${this.options.protocol}://`;
+    const wsUrl = protocol ? `${protocol}${this.options.url}` : this.options.url;
+    this.log(`Connecting to ${wsUrl}`);
+    try {
+      this.ws = new WebSocket(wsUrl, this.options.protocols);
+      this.setupEventHandlers();
+      setTimeout(() => {
+        if (this.ws && this.ws.readyState === WebSocket.CONNECTING) {
+          this.ws.close();
+          this.log("Connection timeout");
+          if (this.connectReject) {
+            this.connectReject(new Error("Connection timeout"));
+            this.connectResolve = null;
+            this.connectReject = null;
+          }
+        }
+      }, this.options.connectTimeout);
+    } catch (error) {
+      this.log("Connection failed:", error);
+      this.handleError(error);
+    }
+  }
+  /**
+   * 断开连接
+   */
+  disconnect() {
+    this.isManualDisconnect = true;
+    this.cleanup();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.log("Disconnected manually");
+  }
+  /**
+   * 发送消息（异步）
+   */
+  async send(data) {
+    if (!this.isConnected()) {
+      return new Promise((resolve, reject) => {
+        this.messageQueue.push(data);
+        const checkConnection = () => {
+          if (this.isConnected()) {
+            this.sendSync(data);
+            resolve();
+          } else if (!this.ws) {
+            reject(new Error("WebSocket is not connected"));
+          } else {
+            setTimeout(checkConnection, 100);
+          }
+        };
+        checkConnection();
+      });
+    }
+    this.sendSync(data);
+  }
+  /**
+   * 发送消息（同步）
+   */
+  sendSync(data) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.log("WebSocket is not connected, message queued");
+      this.messageQueue.push(data);
+      return;
+    }
+    try {
+      const message = typeof data === "object" ? JSON.stringify(data) : data;
+      this.ws.send(message);
+      this.log("Message sent:", message);
+    } catch (error) {
+      this.log("Send error:", error);
+      this.handleError(error);
+    }
+  }
+  /**
+   * 获取连接状态
+   */
+  getState() {
+    return this.ws?.readyState ?? 3 /* CLOSED */;
+  }
+  /**
+   * 是否已连接
+   */
+  isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  /**
+   * 获取 WebSocket 实例
+   */
+  getInstance() {
+    return this.ws;
+  }
+  /**
+   * 设置事件处理器
+   */
+  on(event, handler) {
+    this.handlers[event] = handler;
+  }
+  /**
+   * 移除事件处理器
+   */
+  off(event, handler) {
+    if (!handler || this.handlers[event] === handler) {
+      delete this.handlers[event];
+    }
+  }
+  /**
+   * 重新连接
+   */
+  reconnect() {
+    this.disconnect();
+    this.reconnectCount = 0;
+    this.isManualDisconnect = false;
+    this.connect();
+  }
+  /**
+   * 设置事件处理器
+   */
+  setupEventHandlers() {
+    if (!this.ws) return;
+    this.ws.onopen = (event) => {
+      this.log("Connected");
+      this.reconnectCount = 0;
+      while (this.messageQueue.length > 0) {
+        const message = this.messageQueue.shift();
+        if (message) {
+          this.sendSync(message);
+        }
+      }
+      this.startHeartbeat();
+      if (this.handlers.onOpen) {
+        this.handlers.onOpen(event);
+      }
+      if (this.connectResolve) {
+        this.connectResolve();
+        this.connectResolve = null;
+        this.connectReject = null;
+      }
+    };
+    this.ws.onmessage = (event) => {
+      this.log("Message received:", event.data);
+      let data = event.data;
+      if (typeof event.data === "string") {
+        try {
+          data = JSON.parse(event.data);
+        } catch {
+        }
+      }
+      if (this.handlers.onMessage) {
+        this.handlers.onMessage(data, event);
+      }
+    };
+    this.ws.onclose = (event) => {
+      this.log("Connection closed:", event.code, event.reason);
+      this.cleanup();
+      if (this.handlers.onClose) {
+        this.handlers.onClose(event);
+      }
+      if (!this.isManualDisconnect && this.options.autoReconnect) {
+        this.attemptReconnect();
+      }
+    };
+    this.ws.onerror = (event) => {
+      this.log("Error:", event);
+      if (this.handlers.onError) {
+        this.handlers.onError(event);
+      }
+    };
+  }
+  /**
+   * 尝试重连
+   */
+  attemptReconnect() {
+    if (this.reconnectCount >= this.options.reconnectAttempts) {
+      this.log("Reconnect failed, max attempts reached");
+      this.cleanup();
+      if (this.handlers.onReconnectFailed) {
+        this.handlers.onReconnectFailed();
+      }
+      if (this.connectReject) {
+        this.connectReject(new Error("Reconnect failed"));
+        this.connectResolve = null;
+        this.connectReject = null;
+      }
+      return;
+    }
+    this.reconnectCount++;
+    this.log(`Reconnecting... Attempt ${this.reconnectCount}/${this.options.reconnectAttempts}`);
+    if (this.handlers.onReconnect) {
+      this.handlers.onReconnect(this.reconnectCount);
+    }
+    this.reconnectTimer = setTimeout(() => {
+      this.connect();
+    }, this.options.reconnectInterval);
+  }
+  /**
+   * 启动心跳
+   */
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.isConnected()) {
+        const message = this.options.heartbeatMessage;
+        this.log("Sending heartbeat");
+        if (this.handlers.onHeartbeat) {
+          this.handlers.onHeartbeat();
+        }
+        this.sendSync(message);
+        this.heartbeatTimeoutTimer = setTimeout(() => {
+          this.log("Heartbeat timeout");
+          if (this.handlers.onHeartbeatTimeout) {
+            this.handlers.onHeartbeatTimeout();
+          }
+          if (this.ws) {
+            this.ws.close();
+          }
+        }, this.options.heartbeatTimeout);
+      }
+    }, this.options.heartbeatInterval);
+  }
+  /**
+   * 停止心跳
+   */
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.heartbeatTimeoutTimer) {
+      clearTimeout(this.heartbeatTimeoutTimer);
+      this.heartbeatTimeoutTimer = null;
+    }
+  }
+  /**
+   * 清理资源
+   */
+  cleanup() {
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  /**
+   * 处理错误
+   */
+  handleError(error) {
+    this.log("Error:", error.message);
+    if (this.handlers.onError) {
+      this.handlers.onError(new ErrorEvent("error", { error }));
+    }
+  }
+  /**
+   * 日志输出
+   */
+  log(...args) {
+    if (this.options.debug) {
+      console.log("[WebSocket]", ...args);
+    }
+  }
+};
+function createWebSocket(options) {
+  return new WebSocketClient(options);
+}
+function quickConnect(url, handlers) {
+  const client = new WebSocketClient({ url, autoReconnect: true });
+  if (handlers) {
+    Object.entries(handlers).forEach(([event, handler]) => {
+      client.on(event, handler);
+    });
+  }
+  return client;
+}
+var websocket_default = {
+  WebSocketClient,
+  createWebSocket,
+  quickConnect,
+  WebSocketState
+};
 /**
  * Utils Toolkit
  * 一个功能强大的 JavaScript/TypeScript 工具函数库
@@ -3351,5 +3686,6 @@ exports.pdf = pdf_exports;
 exports.storage = storage_exports;
 exports.string = string_exports;
 exports.utils = utils_exports;
+exports.websocket = websocket_exports;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map