@pisell/core 0.0.2

package/lib/socket/heartbeat.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/heartbeat.ts
+var heartbeat_exports = {};
+__export(heartbeat_exports, {
+  HeartbeatManager: () => HeartbeatManager
+});
+module.exports = __toCommonJS(heartbeat_exports);
+var import_constants = require("./constants");
+var HeartbeatManager = class {
+  options;
+  intervalTimer = null;
+  timeoutTimer = null;
+  lastHeartbeatTime = 0;
+  lastHeartbeatResponse = 0;
+  active = false;
+  // 心跳回调函数
+  sendHeartbeat;
+  onTimeout;
+  onResponse;
+  /**
+   * 创建心跳管理器
+   * @param options 心跳配置选项
+   * @param sendHeartbeat 发送心跳的回调函数
+   * @param callbacks 回调函数集合
+   */
+  constructor(options, sendHeartbeat, callbacks = {}) {
+    this.options = {
+      ...options,
+      interval: Math.max(options.interval, import_constants.MIN_HEARTBEAT_INTERVAL),
+      message: options.message || import_constants.DEFAULT_HEARTBEAT_MESSAGE
+    };
+    this.sendHeartbeat = sendHeartbeat;
+    this.onTimeout = callbacks.onTimeout || (() => {
+    });
+    this.onResponse = callbacks.onResponse || (() => {
+    });
+  }
+  /**
+   * 启动心跳检测
+   */
+  start() {
+    if (this.active) {
+      return;
+    }
+    this.active = true;
+    this.scheduleHeartbeat();
+  }
+  /**
+   * 停止心跳检测
+   */
+  stop() {
+    this.active = false;
+    this.clearTimers();
+  }
+  /**
+   * 重启心跳检测
+   */
+  restart() {
+    this.stop();
+    this.start();
+  }
+  /**
+   * 接收到心跳响应
+   */
+  receiveHeartbeatResponse() {
+    this.lastHeartbeatResponse = Date.now();
+    if (this.timeoutTimer) {
+      clearTimeout(this.timeoutTimer);
+      this.timeoutTimer = null;
+    }
+    this.onResponse();
+  }
+  /**
+   * 获取上次心跳时间
+   */
+  getLastHeartbeatTime() {
+    return this.lastHeartbeatTime;
+  }
+  /**
+   * 获取上次心跳响应时间
+   */
+  getLastHeartbeatResponseTime() {
+    return this.lastHeartbeatResponse;
+  }
+  /**
+   * 获取心跳是否活跃
+   */
+  isActive() {
+    return this.active;
+  }
+  /**
+   * 安排下一次心跳
+   */
+  scheduleHeartbeat() {
+    if (!this.active) {
+      return;
+    }
+    this.clearTimers();
+    this.intervalTimer = setInterval(() => {
+      this.sendHeartbeatMessage();
+    }, this.options.interval);
+    this.sendHeartbeatMessage();
+  }
+  /**
+   * 发送心跳消息
+   */
+  sendHeartbeatMessage() {
+    if (!this.active) {
+      return;
+    }
+    this.lastHeartbeatTime = Date.now();
+    if (this.timeoutTimer) {
+      clearTimeout(this.timeoutTimer);
+      this.timeoutTimer = null;
+    }
+    this.sendHeartbeat(this.options.message);
+    this.timeoutTimer = setTimeout(() => {
+      if (this.active) {
+        this.onTimeout();
+      }
+    }, this.options.timeout);
+  }
+  /**
+   * 清除所有计时器
+   */
+  clearTimers() {
+    if (this.intervalTimer) {
+      clearInterval(this.intervalTimer);
+      this.intervalTimer = null;
+    }
+    if (this.timeoutTimer) {
+      clearTimeout(this.timeoutTimer);
+      this.timeoutTimer = null;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HeartbeatManager
+});

package/lib/socket/index.d.ts

@@ -0,0 +1,61 @@
+import { Socket } from './socket';
+import { SocketOptions, SocketStatus, SocketMessage } from './types';
+import { SocketEvents } from './events';
+import { SocketMonitor, SocketMonitorOptions, SocketHistoryItem, SocketStatusItem, SocketStats } from './monitor';
+import * as components from './components';
+/**
+ * 创建Socket实例
+ * @param url WebSocket连接URL
+ * @param options Socket配置选项
+ */
+export declare function createSocket(url: string, options?: Partial<Omit<SocketOptions, 'url'>>): Socket;
+declare const _default: {
+    /**
+     * 创建新的Socket实例
+     */
+    create: (url: string, options?: Partial<Omit<SocketOptions, "url">>, key?: string | undefined) => Socket;
+    /**
+     * 获取指定键的Socket实例
+     */
+    get: (key: string) => Socket | undefined;
+    /**
+     * 移除Socket实例
+     */
+    remove: (key: string) => boolean;
+    /**
+     * 关闭并移除所有Socket实例
+     */
+    closeAll: () => void;
+    /**
+     * 检查指定键的Socket是否存在
+     */
+    has: (key: string) => boolean;
+    /**
+     * 获取所有Socket标识键
+     */
+    getKeys: () => string[];
+    /**
+     * 获取所有Socket实例
+     */
+    getAllSockets: () => Socket[];
+    /**
+     * 为指定的Socket启用监控
+     */
+    enableMonitoring: (key: string, options?: SocketMonitorOptions | undefined) => SocketMonitor | null;
+    /**
+     * 获取指定Socket的监控器
+     */
+    getMonitor: (key: string) => SocketMonitor | null;
+    /**
+     * 获取所有Socket的监控信息
+     */
+    getAllMonitors: () => Map<string, SocketMonitor | null>;
+    /**
+     * 监控组件
+     */
+    components: typeof components;
+};
+export default _default;
+export { Socket, SocketMonitor };
+export type { SocketOptions, SocketMessage, SocketMonitorOptions, SocketHistoryItem, SocketStatusItem, SocketStats };
+export { SocketStatus, SocketEvents };

package/lib/socket/index.js

@@ -0,0 +1,198 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/socket/index.ts
+var socket_exports = {};
+__export(socket_exports, {
+  Socket: () => import_socket.Socket,
+  SocketEvents: () => import_events.SocketEvents,
+  SocketMonitor: () => import_monitor.SocketMonitor,
+  SocketStatus: () => import_types.SocketStatus,
+  createSocket: () => createSocket,
+  default: () => socket_default
+});
+module.exports = __toCommonJS(socket_exports);
+var import_socket = require("./socket");
+var import_types = require("./types");
+var import_events = require("./events");
+var import_monitor = require("./monitor");
+var components = __toESM(require("./components"));
+function createSocket(url, options = {}) {
+  return new import_socket.Socket({ url, ...options });
+}
+var SocketFactory = class {
+  sockets = /* @__PURE__ */ new Map();
+  /**
+   * 创建新的Socket实例
+   * @param url WebSocket连接URL
+   * @param options Socket配置选项
+   * @param key 可选的标识键，用于后续获取该Socket实例
+   */
+  create(url, options = {}, key) {
+    const socket = new import_socket.Socket({ url, ...options });
+    if (key) {
+      this.sockets.set(key, socket);
+    }
+    return socket;
+  }
+  /**
+   * 获取Socket实例
+   * @param key Socket标识键
+   */
+  get(key) {
+    return this.sockets.get(key);
+  }
+  /**
+   * 移除Socket实例
+   * @param key Socket标识键
+   */
+  remove(key) {
+    const socket = this.sockets.get(key);
+    if (socket) {
+      socket.destroy();
+      return this.sockets.delete(key);
+    }
+    return false;
+  }
+  /**
+   * 关闭并移除所有Socket实例
+   */
+  closeAll() {
+    for (const socket of this.sockets.values()) {
+      socket.destroy();
+    }
+    this.sockets.clear();
+  }
+  /**
+   * 检查指定键的Socket是否存在
+   * @param key Socket标识键
+   */
+  has(key) {
+    return this.sockets.has(key);
+  }
+  /**
+   * 获取所有Socket实例的标识键
+   */
+  getKeys() {
+    return Array.from(this.sockets.keys());
+  }
+  /**
+   * 获取所有Socket实例
+   */
+  getAllSockets() {
+    return Array.from(this.sockets.values());
+  }
+  /**
+   * 为指定的Socket启用监控
+   * @param key Socket标识键
+   * @param options 监控配置选项
+   */
+  enableMonitoring(key, options) {
+    const socket = this.get(key);
+    if (socket) {
+      return socket.enableMonitoring(options);
+    }
+    return null;
+  }
+  /**
+   * 获取指定Socket的监控器
+   * @param key Socket标识键
+   */
+  getMonitor(key) {
+    const socket = this.get(key);
+    if (socket) {
+      return socket.getMonitor();
+    }
+    return null;
+  }
+  /**
+   * 获取所有Socket的监控信息
+   */
+  getAllMonitors() {
+    const result = /* @__PURE__ */ new Map();
+    for (const [key, socket] of this.sockets.entries()) {
+      result.set(key, socket.getMonitor());
+    }
+    return result;
+  }
+};
+var socketFactory = new SocketFactory();
+var socket_default = {
+  /**
+   * 创建新的Socket实例
+   */
+  create: socketFactory.create.bind(socketFactory),
+  /**
+   * 获取指定键的Socket实例
+   */
+  get: socketFactory.get.bind(socketFactory),
+  /**
+   * 移除Socket实例
+   */
+  remove: socketFactory.remove.bind(socketFactory),
+  /**
+   * 关闭并移除所有Socket实例
+   */
+  closeAll: socketFactory.closeAll.bind(socketFactory),
+  /**
+   * 检查指定键的Socket是否存在
+   */
+  has: socketFactory.has.bind(socketFactory),
+  /**
+   * 获取所有Socket标识键
+   */
+  getKeys: socketFactory.getKeys.bind(socketFactory),
+  /**
+   * 获取所有Socket实例
+   */
+  getAllSockets: socketFactory.getAllSockets.bind(socketFactory),
+  /**
+   * 为指定的Socket启用监控
+   */
+  enableMonitoring: socketFactory.enableMonitoring.bind(socketFactory),
+  /**
+   * 获取指定Socket的监控器
+   */
+  getMonitor: socketFactory.getMonitor.bind(socketFactory),
+  /**
+   * 获取所有Socket的监控信息
+   */
+  getAllMonitors: socketFactory.getAllMonitors.bind(socketFactory),
+  /**
+   * 监控组件
+   */
+  components
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Socket,
+  SocketEvents,
+  SocketMonitor,
+  SocketStatus,
+  createSocket
+});

package/lib/socket/monitor.d.ts

@@ -0,0 +1,169 @@
+import { Socket } from './socket';
+import { SocketMessage, SocketStatus } from './types';
+/**
+ * Socket历史消息记录项
+ */
+export interface SocketHistoryItem {
+    /** 消息ID */
+    id: string;
+    /** 消息时间戳 */
+    timestamp: number;
+    /** 消息方向（发送/接收） */
+    direction: 'in' | 'out';
+    /** 消息内容 */
+    message: SocketMessage;
+    /** 消息大小（字节） */
+    size?: number;
+}
+/**
+ * Socket状态记录项
+ */
+export interface SocketStatusItem {
+    /** 状态变更时间戳 */
+    timestamp: number;
+    /** 变更前状态 */
+    from: SocketStatus;
+    /** 变更后状态 */
+    to: SocketStatus;
+    /** 相关事件（如果有） */
+    event?: string;
+    /** 附加信息 */
+    info?: any;
+}
+/**
+ * Socket监控配置选项
+ */
+export interface SocketMonitorOptions {
+    /** 最大历史消息记录数 */
+    maxHistoryItems?: number;
+    /** 最大状态变更记录数 */
+    maxStatusItems?: number;
+    /** 是否记录消息内容 */
+    recordMessageContent?: boolean;
+    /** 是否自动开始监控 */
+    autoStart?: boolean;
+    /** 过滤掉的消息类型（不记录） */
+    excludeEvents?: string[];
+}
+/**
+ * Socket监控统计信息
+ */
+export interface SocketStats {
+    /** 总发送消息数 */
+    totalSent: number;
+    /** 总接收消息数 */
+    totalReceived: number;
+    /** 总发送字节数 */
+    bytesSent: number;
+    /** 总接收字节数 */
+    bytesReceived: number;
+    /** 连接次数 */
+    connectionCount: number;
+    /** 重连次数 */
+    reconnectionCount: number;
+    /** 错误次数 */
+    errorCount: number;
+    /** 心跳发送次数 */
+    heartbeatCount: number;
+    /** 心跳超时次数 */
+    heartbeatTimeoutCount: number;
+    /** 首次连接时间 */
+    firstConnectTime: number | null;
+    /** 最后连接时间 */
+    lastConnectTime: number | null;
+    /** 当前连接持续时间（毫秒，连接状态下有效） */
+    currentConnectionDuration: number | null;
+    /** 平均消息大小（字节） */
+    averageMessageSize: number;
+}
+/**
+ * Socket监控器
+ * 用于监控Socket的连接状态和消息历史
+ */
+export declare class SocketMonitor {
+    private socket;
+    private options;
+    private isMonitoring;
+    private messageHistory;
+    private statusHistory;
+    private stats;
+    private connectStartTime;
+    private eventHandlers;
+    /**
+     * 创建Socket监控器
+     * @param socket 要监控的Socket实例
+     * @param options 监控配置选项
+     */
+    constructor(socket: Socket, options?: SocketMonitorOptions);
+    /**
+     * 开始监控
+     */
+    start(): void;
+    /**
+     * 停止监控
+     */
+    stop(): void;
+    /**
+     * 检查监控器是否处于活跃状态
+     */
+    isActive(): boolean;
+    /**
+     * 清除历史记录
+     */
+    clearHistory(): void;
+    /**
+     * 重置统计数据
+     */
+    resetStats(): void;
+    /**
+     * 获取消息历史记录
+     * @param limit 返回的最大记录数
+     * @param direction 消息方向过滤
+     */
+    getMessageHistory(limit?: number, direction?: 'in' | 'out'): SocketHistoryItem[];
+    /**
+     * 获取状态变更历史
+     * @param limit 返回的最大记录数
+     */
+    getStatusHistory(limit?: number): SocketStatusItem[];
+    /**
+     * 获取统计信息
+     */
+    getStats(): SocketStats;
+    /**
+     * 设置监控事件监听
+     */
+    private setupEventListeners;
+    /**
+     * 移除监控事件监听
+     */
+    private removeEventListeners;
+    /**
+     * 记录已发送的消息
+     */
+    private recordMessageSent;
+    /**
+     * 记录已接收的消息
+     */
+    private recordMessageReceived;
+    /**
+     * 记录状态变化
+     */
+    private recordStatusChange;
+    /**
+     * 添加消息到历史记录，并控制记录数量
+     */
+    private addToMessageHistory;
+    /**
+     * 添加状态到历史记录，并控制记录数量
+     */
+    private addToStatusHistory;
+    /**
+     * 更新平均消息大小
+     */
+    private updateAverageMessageSize;
+    /**
+     * 释放资源
+     */
+    destroy(): void;
+}