@pisell/core 1.0.0 → 1.0.1

package/lib/socket/constants.js

@@ -0,0 +1,62 @@
+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/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  DEFAULT_HEARTBEAT_MESSAGE: () => DEFAULT_HEARTBEAT_MESSAGE,
+  DEFAULT_HEARTBEAT_RESPONSE: () => DEFAULT_HEARTBEAT_RESPONSE,
+  DEFAULT_SOCKET_OPTIONS: () => DEFAULT_SOCKET_OPTIONS,
+  MIN_HEARTBEAT_INTERVAL: () => MIN_HEARTBEAT_INTERVAL,
+  MIN_RECONNECTION_DELAY: () => MIN_RECONNECTION_DELAY,
+  WS_STATUS_MAP: () => WS_STATUS_MAP
+});
+module.exports = __toCommonJS(constants_exports);
+var DEFAULT_SOCKET_OPTIONS = {
+  autoConnect: true,
+  reconnection: true,
+  reconnectionAttempts: Infinity,
+  reconnectionDelay: 1e3,
+  reconnectionDelayMax: 5e3,
+  heartbeat: true,
+  heartbeatInterval: 3e4,
+  heartbeatTimeout: 1e4,
+  timeout: 2e4
+};
+var DEFAULT_HEARTBEAT_MESSAGE = {
+  type: "ping"
+};
+var DEFAULT_HEARTBEAT_RESPONSE = "pong";
+var MIN_HEARTBEAT_INTERVAL = 1e3;
+var MIN_RECONNECTION_DELAY = 500;
+var WS_STATUS_MAP = {
+  0: "连接中",
+  1: "已连接",
+  2: "关闭中",
+  3: "已关闭",
+  4: "重连中"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_HEARTBEAT_MESSAGE,
+  DEFAULT_HEARTBEAT_RESPONSE,
+  DEFAULT_SOCKET_OPTIONS,
+  MIN_HEARTBEAT_INTERVAL,
+  MIN_RECONNECTION_DELAY,
+  WS_STATUS_MAP
+});

package/lib/socket/events.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Socket标准事件类型
+ */
+export declare enum SocketEvents {
+    /** 连接成功事件 */
+    CONNECT = "connect",
+    /** 连接断开事件 */
+    DISCONNECT = "disconnect",
+    /** 连接错误事件 */
+    ERROR = "error",
+    /** 接收消息事件 */
+    MESSAGE = "message",
+    /** 发送消息事件 */
+    SEND = "send",
+    /** 重连中事件 */
+    RECONNECTING = "reconnecting",
+    /** 重连尝试事件 */
+    RECONNECT_ATTEMPT = "reconnect_attempt",
+    /** 重连成功事件 */
+    RECONNECT = "reconnect",
+    /** 重连失败事件 */
+    RECONNECT_ERROR = "reconnect_error",
+    /** 重连次数超限 */
+    RECONNECT_FAILED = "reconnect_failed",
+    /** 心跳发送事件 */
+    HEARTBEAT = "heartbeat",
+    /** 心跳响应事件 */
+    HEARTBEAT_RESPONSE = "heartbeat_response",
+    /** 心跳超时事件 */
+    HEARTBEAT_TIMEOUT = "heartbeat_timeout"
+}

package/lib/socket/events.js

@@ -0,0 +1,44 @@
+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/events.ts
+var events_exports = {};
+__export(events_exports, {
+  SocketEvents: () => SocketEvents
+});
+module.exports = __toCommonJS(events_exports);
+var SocketEvents = /* @__PURE__ */ ((SocketEvents2) => {
+  SocketEvents2["CONNECT"] = "connect";
+  SocketEvents2["DISCONNECT"] = "disconnect";
+  SocketEvents2["ERROR"] = "error";
+  SocketEvents2["MESSAGE"] = "message";
+  SocketEvents2["SEND"] = "send";
+  SocketEvents2["RECONNECTING"] = "reconnecting";
+  SocketEvents2["RECONNECT_ATTEMPT"] = "reconnect_attempt";
+  SocketEvents2["RECONNECT"] = "reconnect";
+  SocketEvents2["RECONNECT_ERROR"] = "reconnect_error";
+  SocketEvents2["RECONNECT_FAILED"] = "reconnect_failed";
+  SocketEvents2["HEARTBEAT"] = "heartbeat";
+  SocketEvents2["HEARTBEAT_RESPONSE"] = "heartbeat_response";
+  SocketEvents2["HEARTBEAT_TIMEOUT"] = "heartbeat_timeout";
+  return SocketEvents2;
+})(SocketEvents || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SocketEvents
+});

package/lib/socket/heartbeat.d.ts

@@ -0,0 +1,66 @@
+import { HeartbeatOptions, SocketMessage } from "./types";
+/**
+ * Socket心跳管理器
+ * 处理WebSocket连接的心跳检测
+ */
+export declare class HeartbeatManager {
+    private options;
+    private intervalTimer;
+    private timeoutTimer;
+    private lastHeartbeatTime;
+    private lastHeartbeatResponse;
+    private active;
+    private sendHeartbeat;
+    private onTimeout;
+    private onResponse;
+    /**
+     * 创建心跳管理器
+     * @param options 心跳配置选项
+     * @param sendHeartbeat 发送心跳的回调函数
+     * @param callbacks 回调函数集合
+     */
+    constructor(options: HeartbeatOptions, sendHeartbeat: (msg: SocketMessage) => void, callbacks?: {
+        onTimeout?: () => void;
+        onResponse?: () => void;
+    });
+    /**
+     * 启动心跳检测
+     */
+    start(): void;
+    /**
+     * 停止心跳检测
+     */
+    stop(): void;
+    /**
+     * 重启心跳检测
+     */
+    restart(): void;
+    /**
+     * 接收到心跳响应
+     */
+    receiveHeartbeatResponse(): void;
+    /**
+     * 获取上次心跳时间
+     */
+    getLastHeartbeatTime(): number;
+    /**
+     * 获取上次心跳响应时间
+     */
+    getLastHeartbeatResponseTime(): number;
+    /**
+     * 获取心跳是否活跃
+     */
+    isActive(): boolean;
+    /**
+     * 安排下一次心跳
+     */
+    private scheduleHeartbeat;
+    /**
+     * 发送心跳消息
+     */
+    private sendHeartbeatMessage;
+    /**
+     * 清除所有计时器
+     */
+    private clearTimers;
+}

package/lib/socket/heartbeat.js

@@ -0,0 +1,152 @@
+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 {
+  /**
+   * 创建心跳管理器
+   * @param options 心跳配置选项
+   * @param sendHeartbeat 发送心跳的回调函数
+   * @param callbacks 回调函数集合
+   */
+  constructor(options, sendHeartbeat, callbacks = {}) {
+    this.intervalTimer = null;
+    this.timeoutTimer = null;
+    this.lastHeartbeatTime = 0;
+    this.lastHeartbeatResponse = 0;
+    this.active = false;
+    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,200 @@
+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 {
+  constructor() {
+    this.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
+});