@pisell/core 0.0.2

package/lib/socket/monitor.js

@@ -0,0 +1,350 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/socket/monitor.ts
+var monitor_exports = {};
+__export(monitor_exports, {
+  SocketMonitor: () => SocketMonitor
+});
+module.exports = __toCommonJS(monitor_exports);
+var import_events = require("./events");
+var import_types = require("./types");
+var SocketMonitor = class {
+  socket;
+  options;
+  isMonitoring = false;
+  // 历史记录存储
+  messageHistory = [];
+  statusHistory = [];
+  // 统计数据
+  stats = {
+    totalSent: 0,
+    totalReceived: 0,
+    bytesSent: 0,
+    bytesReceived: 0,
+    connectionCount: 0,
+    reconnectionCount: 0,
+    errorCount: 0,
+    heartbeatCount: 0,
+    heartbeatTimeoutCount: 0,
+    firstConnectTime: null,
+    lastConnectTime: null,
+    currentConnectionDuration: null,
+    averageMessageSize: 0
+  };
+  // 用于计算连接持续时间
+  connectStartTime = null;
+  // 事件句柄映射
+  eventHandlers = /* @__PURE__ */ new Map();
+  /**
+   * 创建Socket监控器
+   * @param socket 要监控的Socket实例
+   * @param options 监控配置选项
+   */
+  constructor(socket, options = {}) {
+    this.socket = socket;
+    this.options = {
+      maxHistoryItems: 100,
+      maxStatusItems: 50,
+      recordMessageContent: true,
+      autoStart: true,
+      excludeEvents: ["ping", "pong", "heartbeat"],
+      ...options
+    };
+    if (this.options.autoStart) {
+      this.start();
+    }
+  }
+  /**
+   * 开始监控
+   */
+  start() {
+    if (this.isMonitoring) {
+      return;
+    }
+    this.isMonitoring = true;
+    this.setupEventListeners();
+    this.recordStatusChange(import_types.SocketStatus.CLOSED, this.socket.getStatus());
+  }
+  /**
+   * 停止监控
+   */
+  stop() {
+    if (!this.isMonitoring) {
+      return;
+    }
+    this.isMonitoring = false;
+    this.removeEventListeners();
+  }
+  /**
+   * 检查监控器是否处于活跃状态
+   */
+  isActive() {
+    return this.isMonitoring;
+  }
+  /**
+   * 清除历史记录
+   */
+  clearHistory() {
+    this.messageHistory = [];
+    this.statusHistory = [];
+  }
+  /**
+   * 重置统计数据
+   */
+  resetStats() {
+    this.stats = {
+      totalSent: 0,
+      totalReceived: 0,
+      bytesSent: 0,
+      bytesReceived: 0,
+      connectionCount: 0,
+      reconnectionCount: 0,
+      errorCount: 0,
+      heartbeatCount: 0,
+      heartbeatTimeoutCount: 0,
+      firstConnectTime: null,
+      lastConnectTime: null,
+      currentConnectionDuration: null,
+      averageMessageSize: 0
+    };
+    this.connectStartTime = null;
+  }
+  /**
+   * 获取消息历史记录
+   * @param limit 返回的最大记录数
+   * @param direction 消息方向过滤
+   */
+  getMessageHistory(limit, direction) {
+    let history = this.messageHistory;
+    if (direction) {
+      history = history.filter((item) => item.direction === direction);
+    }
+    if (limit && limit > 0) {
+      history = history.slice(-limit);
+    }
+    return history;
+  }
+  /**
+   * 获取状态变更历史
+   * @param limit 返回的最大记录数
+   */
+  getStatusHistory(limit) {
+    let history = this.statusHistory;
+    if (limit && limit > 0) {
+      history = history.slice(-limit);
+    }
+    return history;
+  }
+  /**
+   * 获取统计信息
+   */
+  getStats() {
+    if (this.socket.isConnected() && this.connectStartTime) {
+      this.stats.currentConnectionDuration = Date.now() - this.connectStartTime;
+    }
+    return { ...this.stats };
+  }
+  /**
+   * 设置监控事件监听
+   */
+  setupEventListeners() {
+    const onSend = (message) => {
+      this.recordMessageSent(message);
+    };
+    this.eventHandlers.set(import_events.SocketEvents.SEND, onSend);
+    this.socket.on(import_events.SocketEvents.SEND, onSend);
+    const onMessage = (message) => {
+      this.recordMessageReceived(message);
+    };
+    this.eventHandlers.set(import_events.SocketEvents.MESSAGE, onMessage);
+    this.socket.on(import_events.SocketEvents.MESSAGE, onMessage);
+    const onConnect = () => {
+      const now = Date.now();
+      this.connectStartTime = now;
+      if (!this.stats.firstConnectTime) {
+        this.stats.firstConnectTime = now;
+      }
+      this.stats.lastConnectTime = now;
+      this.stats.connectionCount++;
+      this.recordStatusChange(
+        this.socket.getStatus() === import_types.SocketStatus.RECONNECTING ? import_types.SocketStatus.RECONNECTING : import_types.SocketStatus.CONNECTING,
+        import_types.SocketStatus.OPEN,
+        import_events.SocketEvents.CONNECT
+      );
+    };
+    this.eventHandlers.set(import_events.SocketEvents.CONNECT, onConnect);
+    this.socket.on(import_events.SocketEvents.CONNECT, onConnect);
+    const onDisconnect = () => {
+      this.connectStartTime = null;
+      this.stats.currentConnectionDuration = null;
+      this.recordStatusChange(
+        this.socket.getStatus() === import_types.SocketStatus.CLOSING ? import_types.SocketStatus.CLOSING : import_types.SocketStatus.OPEN,
+        import_types.SocketStatus.CLOSED,
+        import_events.SocketEvents.DISCONNECT
+      );
+    };
+    this.eventHandlers.set(import_events.SocketEvents.DISCONNECT, onDisconnect);
+    this.socket.on(import_events.SocketEvents.DISCONNECT, onDisconnect);
+    const onReconnect = () => {
+      this.stats.reconnectionCount++;
+    };
+    this.eventHandlers.set(import_events.SocketEvents.RECONNECT, onReconnect);
+    this.socket.on(import_events.SocketEvents.RECONNECT, onReconnect);
+    const onReconnectAttempt = () => {
+      this.recordStatusChange(
+        import_types.SocketStatus.CLOSED,
+        import_types.SocketStatus.RECONNECTING,
+        import_events.SocketEvents.RECONNECT_ATTEMPT
+      );
+    };
+    this.eventHandlers.set(import_events.SocketEvents.RECONNECT_ATTEMPT, onReconnectAttempt);
+    this.socket.on(import_events.SocketEvents.RECONNECT_ATTEMPT, onReconnectAttempt);
+    const onError = (error) => {
+      this.stats.errorCount++;
+      this.recordStatusChange(
+        this.socket.getStatus(),
+        this.socket.getStatus(),
+        import_events.SocketEvents.ERROR,
+        error
+      );
+    };
+    this.eventHandlers.set(import_events.SocketEvents.ERROR, onError);
+    this.socket.on(import_events.SocketEvents.ERROR, onError);
+    const onHeartbeat = () => {
+      this.stats.heartbeatCount++;
+    };
+    this.eventHandlers.set(import_events.SocketEvents.HEARTBEAT, onHeartbeat);
+    this.socket.on(import_events.SocketEvents.HEARTBEAT, onHeartbeat);
+    const onHeartbeatTimeout = () => {
+      this.stats.heartbeatTimeoutCount++;
+    };
+    this.eventHandlers.set(import_events.SocketEvents.HEARTBEAT_TIMEOUT, onHeartbeatTimeout);
+    this.socket.on(import_events.SocketEvents.HEARTBEAT_TIMEOUT, onHeartbeatTimeout);
+  }
+  /**
+   * 移除监控事件监听
+   */
+  removeEventListeners() {
+    for (const [event, handler] of this.eventHandlers.entries()) {
+      this.socket.off(event, handler);
+    }
+    this.eventHandlers.clear();
+  }
+  /**
+   * 记录已发送的消息
+   */
+  recordMessageSent(message) {
+    var _a;
+    if ((_a = this.options.excludeEvents) == null ? void 0 : _a.includes(message.event)) {
+      return;
+    }
+    const messageStr = JSON.stringify(message);
+    const size = new Blob([messageStr]).size;
+    this.stats.totalSent++;
+    this.stats.bytesSent += size;
+    this.updateAverageMessageSize(size);
+    this.addToMessageHistory({
+      id: message.id || `out_${Date.now()}`,
+      timestamp: Date.now(),
+      direction: "out",
+      //@ts-ignore
+      message: this.options.recordMessageContent ? message : { event: message.event },
+      size
+    });
+  }
+  /**
+   * 记录已接收的消息
+   */
+  recordMessageReceived(message) {
+    var _a;
+    if ((_a = this.options.excludeEvents) == null ? void 0 : _a.includes(message.event)) {
+      return;
+    }
+    const messageStr = JSON.stringify(message);
+    const size = new Blob([messageStr]).size;
+    this.stats.totalReceived++;
+    this.stats.bytesReceived += size;
+    this.updateAverageMessageSize(size);
+    this.addToMessageHistory({
+      id: message.id || `in_${Date.now()}`,
+      timestamp: Date.now(),
+      direction: "in",
+      //@ts-ignore
+      message: this.options.recordMessageContent ? message : { event: message.event },
+      size
+    });
+  }
+  /**
+   * 记录状态变化
+   */
+  recordStatusChange(fromStatus, toStatus, event, info) {
+    if (fromStatus === toStatus && !event) {
+      return;
+    }
+    const statusItem = {
+      timestamp: Date.now(),
+      from: fromStatus,
+      to: toStatus,
+      event,
+      info
+    };
+    this.addToStatusHistory(statusItem);
+  }
+  /**
+   * 添加消息到历史记录，并控制记录数量
+   */
+  addToMessageHistory(item) {
+    this.messageHistory.push(item);
+    if (this.messageHistory.length > (this.options.maxHistoryItems || 100)) {
+      this.messageHistory.shift();
+    }
+  }
+  /**
+   * 添加状态到历史记录，并控制记录数量
+   */
+  addToStatusHistory(item) {
+    this.statusHistory.push(item);
+    if (this.statusHistory.length > (this.options.maxStatusItems || 50)) {
+      this.statusHistory.shift();
+    }
+  }
+  /**
+   * 更新平均消息大小
+   */
+  updateAverageMessageSize(newSize) {
+    const totalMessages = this.stats.totalSent + this.stats.totalReceived;
+    if (totalMessages <= 1) {
+      this.stats.averageMessageSize = newSize;
+    } else {
+      this.stats.averageMessageSize = (this.stats.averageMessageSize * (totalMessages - 1) + newSize) / totalMessages;
+    }
+  }
+  /**
+   * 释放资源
+   */
+  destroy() {
+    this.stop();
+    this.messageHistory = [];
+    this.statusHistory = [];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SocketMonitor
+});

package/lib/socket/reconnect.d.ts

@@ -0,0 +1,61 @@
+import { ReconnectOptions } from "./types";
+/**
+ * Socket重连管理器
+ * 处理断线重连逻辑
+ */
+export declare class ReconnectManager {
+    private options;
+    private attempts;
+    private timer;
+    private isReconnecting;
+    private reconnectCallback;
+    private onAttempt;
+    private onSuccess;
+    private onFail;
+    private onMaxAttemptsExceeded;
+    /**
+     * 创建重连管理器实例
+     * @param options 重连配置
+     * @param reconnectCallback 重连执行函数
+     * @param callbacks 回调函数集合
+     */
+    constructor(options: ReconnectOptions, reconnectCallback: () => Promise<boolean>, callbacks?: {
+        onAttempt?: (attempt: number) => void;
+        onSuccess?: () => void;
+        onFail?: (error: Error) => void;
+        onMaxAttemptsExceeded?: () => void;
+    });
+    /**
+     * 启动重连过程
+     */
+    startReconnect(): void;
+    /**
+     * 停止重连过程
+     */
+    stopReconnect(): void;
+    /**
+     * 获取当前重连尝试次数
+     */
+    getReconnectAttempts(): number;
+    /**
+     * 获取当前是否正在重连
+     */
+    isActive(): boolean;
+    /**
+     * 重置重连状态
+     */
+    reset(): void;
+    /**
+     * 安排下一次重连尝试
+     */
+    private scheduleReconnect;
+    /**
+     * 执行重连操作
+     */
+    private executeReconnect;
+    /**
+     * 计算重连延迟时间
+     * 支持指数退避算法，增加随机抖动
+     */
+    private getReconnectDelay;
+}

package/lib/socket/reconnect.js

@@ -0,0 +1,157 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/socket/reconnect.ts
+var reconnect_exports = {};
+__export(reconnect_exports, {
+  ReconnectManager: () => ReconnectManager
+});
+module.exports = __toCommonJS(reconnect_exports);
+var import_constants = require("./constants");
+var ReconnectManager = class {
+  options;
+  attempts = 0;
+  timer = null;
+  isReconnecting = false;
+  // 重连回调函数
+  reconnectCallback;
+  onAttempt;
+  onSuccess;
+  onFail;
+  onMaxAttemptsExceeded;
+  /**
+   * 创建重连管理器实例
+   * @param options 重连配置
+   * @param reconnectCallback 重连执行函数
+   * @param callbacks 回调函数集合
+   */
+  constructor(options, reconnectCallback, callbacks = {}) {
+    this.options = {
+      ...options,
+      delay: Math.max(options.delay, import_constants.MIN_RECONNECTION_DELAY)
+    };
+    this.reconnectCallback = reconnectCallback;
+    this.onAttempt = callbacks.onAttempt || (() => {
+    });
+    this.onSuccess = callbacks.onSuccess || (() => {
+    });
+    this.onFail = callbacks.onFail || (() => {
+    });
+    this.onMaxAttemptsExceeded = callbacks.onMaxAttemptsExceeded || (() => {
+    });
+  }
+  /**
+   * 启动重连过程
+   */
+  startReconnect() {
+    if (this.isReconnecting || !this.options.enabled) {
+      return;
+    }
+    this.isReconnecting = true;
+    this.attempts = 0;
+    this.scheduleReconnect();
+  }
+  /**
+   * 停止重连过程
+   */
+  stopReconnect() {
+    this.isReconnecting = false;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  /**
+   * 获取当前重连尝试次数
+   */
+  getReconnectAttempts() {
+    return this.attempts;
+  }
+  /**
+   * 获取当前是否正在重连
+   */
+  isActive() {
+    return this.isReconnecting;
+  }
+  /**
+   * 重置重连状态
+   */
+  reset() {
+    this.stopReconnect();
+    this.attempts = 0;
+  }
+  /**
+   * 安排下一次重连尝试
+   */
+  scheduleReconnect() {
+    if (!this.isReconnecting) {
+      return;
+    }
+    if (this.options.attempts !== void 0 && this.attempts >= this.options.attempts) {
+      this.isReconnecting = false;
+      this.onMaxAttemptsExceeded();
+      return;
+    }
+    const delay = this.getReconnectDelay();
+    this.timer = setTimeout(() => {
+      this.attempts++;
+      this.onAttempt(this.attempts);
+      this.executeReconnect().then((success) => {
+        if (success) {
+          this.isReconnecting = false;
+          this.onSuccess();
+        } else {
+          this.scheduleReconnect();
+        }
+      }).catch((error) => {
+        this.onFail(error);
+        this.scheduleReconnect();
+      });
+    }, delay);
+  }
+  /**
+   * 执行重连操作
+   */
+  async executeReconnect() {
+    try {
+      return await this.reconnectCallback();
+    } catch (error) {
+      this.onFail(error instanceof Error ? error : new Error("Reconnect failed"));
+      return false;
+    }
+  }
+  /**
+   * 计算重连延迟时间
+   * 支持指数退避算法，增加随机抖动
+   */
+  getReconnectDelay() {
+    const { delay, delayMax, jitter } = this.options;
+    let calculatedDelay = delay;
+    if (this.attempts > 0) {
+      calculatedDelay = Math.min(delayMax || Infinity, delay * Math.pow(1.5, this.attempts - 1));
+    }
+    if (jitter) {
+      calculatedDelay = Math.random() * calculatedDelay;
+    }
+    return Math.max(import_constants.MIN_RECONNECTION_DELAY, Math.floor(calculatedDelay));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReconnectManager
+});

package/lib/socket/socket.d.ts

@@ -0,0 +1,130 @@
+import { SocketOptions, SocketStatus } from "./types";
+import { SocketMonitor, SocketMonitorOptions } from "./monitor";
+/**
+ * Socket主类
+ * 负责管理WebSocket连接、消息收发、事件处理、心跳检测和断线重连
+ */
+export declare class Socket {
+    private ws;
+    private url;
+    private options;
+    private status;
+    private eventHandlers;
+    private heartbeatManager;
+    private reconnectManager;
+    private monitor;
+    private messageIdCounter;
+    /**
+     * 创建Socket实例
+     * @param options Socket配置选项
+     */
+    constructor(options: SocketOptions);
+    /**
+     * 建立WebSocket连接
+     */
+    connect(): Promise<void>;
+    /**
+     * 关闭WebSocket连接
+     * @param isManual 是否手动关闭
+     */
+    disconnect(isManual?: boolean): void;
+    /**
+     * 发送消息到服务器
+     * @param event 事件名称
+     * @param data 消息数据
+     * @param id 消息ID（可选，默认自动生成）
+     */
+    send(type: string, data?: any, id?: string): void;
+    /**
+     * 发送原始消息
+     * @param message 消息对象
+     */
+    private sendRaw;
+    /**
+     * 注册事件监听器
+     * @param event 事件名称
+     * @param handler 事件处理函数
+     */
+    on(event: string, handler: (...args: any[]) => void): void;
+    /**
+     * 移除事件监听器
+     * @param event 事件名称
+     * @param handler 事件处理函数（可选，不提供则移除所有该事件的处理函数）
+     */
+    off(event: string, handler?: (...args: any[]) => void): void;
+    /**
+     * 触发事件
+     * @param event 事件名称
+     * @param args 事件参数
+     */
+    private emit;
+    /**
+     * 获取当前连接状态
+     */
+    getStatus(): SocketStatus;
+    /**
+     * 获取当前状态描述
+     */
+    getStatusText(): string;
+    /**
+     * 检查是否已连接
+     */
+    isConnected(): boolean;
+    /**
+     * 设置连接状态
+     */
+    private setStatus;
+    /**
+     * 设置WebSocket事件监听器
+     */
+    private setupWebSocketListeners;
+    /**
+     * 处理接收到的消息
+     */
+    private handleMessage;
+    /**
+     * 处理连接关闭
+     */
+    private handleConnectionClosed;
+    /**
+     * 处理连接失败
+     */
+    private handleConnectionFailure;
+    /**
+     * 处理心跳响应
+     */
+    private handleHeartbeatResponse;
+    /**
+     * 初始化心跳检测
+     */
+    private initHeartbeat;
+    /**
+     * 初始化重连管理
+     */
+    private initReconnect;
+    /**
+     * 开始重连过程
+     */
+    private startReconnection;
+    /**
+     * 生成消息ID
+     */
+    private generateMessageId;
+    /**
+     * 启用监控功能
+     * @param options 监控配置选项
+     */
+    enableMonitoring(options?: SocketMonitorOptions): SocketMonitor;
+    /**
+     * 禁用监控功能
+     */
+    disableMonitoring(): void;
+    /**
+     * 获取监控器实例
+     */
+    getMonitor(): SocketMonitor | null;
+    /**
+     * 释放资源
+     */
+    destroy(): void;
+}