@pisell/core 0.0.2

package/es/socket/constants.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Socket模块常量
+ */
+/** 默认配置选项 */
+export declare const DEFAULT_SOCKET_OPTIONS: {
+    autoConnect: boolean;
+    reconnection: boolean;
+    reconnectionAttempts: number;
+    reconnectionDelay: number;
+    reconnectionDelayMax: number;
+    heartbeat: boolean;
+    heartbeatInterval: number;
+    heartbeatTimeout: number;
+    timeout: number;
+};
+/** 默认心跳消息 */
+export declare const DEFAULT_HEARTBEAT_MESSAGE: {
+    type: string;
+};
+/** 默认心跳响应事件 */
+export declare const DEFAULT_HEARTBEAT_RESPONSE = "pong";
+/** 最小心跳间隔（毫秒） */
+export declare const MIN_HEARTBEAT_INTERVAL = 1000;
+/** 最小重连延迟（毫秒） */
+export declare const MIN_RECONNECTION_DELAY = 500;
+/** 连接状态码映射 */
+export declare const WS_STATUS_MAP: {
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+};

package/es/socket/constants.js

@@ -0,0 +1,39 @@
+/**
+ * Socket模块常量
+ */
+
+/** 默认配置选项 */
+export var DEFAULT_SOCKET_OPTIONS = {
+  autoConnect: true,
+  reconnection: true,
+  reconnectionAttempts: Infinity,
+  reconnectionDelay: 1000,
+  reconnectionDelayMax: 5000,
+  heartbeat: true,
+  heartbeatInterval: 30000,
+  heartbeatTimeout: 10000,
+  timeout: 20000
+};
+
+/** 默认心跳消息 */
+export var DEFAULT_HEARTBEAT_MESSAGE = {
+  type: "ping"
+};
+
+/** 默认心跳响应事件 */
+export var DEFAULT_HEARTBEAT_RESPONSE = "pong";
+
+/** 最小心跳间隔（毫秒） */
+export var MIN_HEARTBEAT_INTERVAL = 1000;
+
+/** 最小重连延迟（毫秒） */
+export var MIN_RECONNECTION_DELAY = 500;
+
+/** 连接状态码映射 */
+export var WS_STATUS_MAP = {
+  0: "连接中",
+  1: "已连接",
+  2: "关闭中",
+  3: "已关闭",
+  4: "重连中"
+};

package/es/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/es/socket/events.js

@@ -0,0 +1,19 @@
+/**
+ * Socket标准事件类型
+ */
+export var SocketEvents = /*#__PURE__*/function (SocketEvents) {
+  SocketEvents["CONNECT"] = "connect";
+  SocketEvents["DISCONNECT"] = "disconnect";
+  SocketEvents["ERROR"] = "error";
+  SocketEvents["MESSAGE"] = "message";
+  SocketEvents["SEND"] = "send";
+  SocketEvents["RECONNECTING"] = "reconnecting";
+  SocketEvents["RECONNECT_ATTEMPT"] = "reconnect_attempt";
+  SocketEvents["RECONNECT"] = "reconnect";
+  SocketEvents["RECONNECT_ERROR"] = "reconnect_error";
+  SocketEvents["RECONNECT_FAILED"] = "reconnect_failed";
+  SocketEvents["HEARTBEAT"] = "heartbeat";
+  SocketEvents["HEARTBEAT_RESPONSE"] = "heartbeat_response";
+  SocketEvents["HEARTBEAT_TIMEOUT"] = "heartbeat_timeout";
+  return SocketEvents;
+}({});

package/es/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/es/socket/heartbeat.js

@@ -0,0 +1,184 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { DEFAULT_HEARTBEAT_MESSAGE, MIN_HEARTBEAT_INTERVAL } from "./constants";
+
+/**
+ * Socket心跳管理器
+ * 处理WebSocket连接的心跳检测
+ */
+export var HeartbeatManager = /*#__PURE__*/function () {
+  /**
+   * 创建心跳管理器
+   * @param options 心跳配置选项
+   * @param sendHeartbeat 发送心跳的回调函数
+   * @param callbacks 回调函数集合
+   */
+  function HeartbeatManager(options, sendHeartbeat) {
+    var callbacks = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    _classCallCheck(this, HeartbeatManager);
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "intervalTimer", null);
+    _defineProperty(this, "timeoutTimer", null);
+    _defineProperty(this, "lastHeartbeatTime", 0);
+    _defineProperty(this, "lastHeartbeatResponse", 0);
+    _defineProperty(this, "active", false);
+    // 心跳回调函数
+    _defineProperty(this, "sendHeartbeat", void 0);
+    _defineProperty(this, "onTimeout", void 0);
+    _defineProperty(this, "onResponse", void 0);
+    this.options = _objectSpread(_objectSpread({}, options), {}, {
+      interval: Math.max(options.interval, MIN_HEARTBEAT_INTERVAL),
+      message: options.message || DEFAULT_HEARTBEAT_MESSAGE
+    });
+    this.sendHeartbeat = sendHeartbeat;
+    this.onTimeout = callbacks.onTimeout || function () {};
+    this.onResponse = callbacks.onResponse || function () {};
+  }
+
+  /**
+   * 启动心跳检测
+   */
+  _createClass(HeartbeatManager, [{
+    key: "start",
+    value: function start() {
+      if (this.active) {
+        return;
+      }
+      this.active = true;
+      this.scheduleHeartbeat();
+    }
+
+    /**
+     * 停止心跳检测
+     */
+  }, {
+    key: "stop",
+    value: function stop() {
+      this.active = false;
+      this.clearTimers();
+    }
+
+    /**
+     * 重启心跳检测
+     */
+  }, {
+    key: "restart",
+    value: function restart() {
+      this.stop();
+      this.start();
+    }
+
+    /**
+     * 接收到心跳响应
+     */
+  }, {
+    key: "receiveHeartbeatResponse",
+    value: function receiveHeartbeatResponse() {
+      this.lastHeartbeatResponse = Date.now();
+
+      // 清除超时计时器
+      if (this.timeoutTimer) {
+        clearTimeout(this.timeoutTimer);
+        this.timeoutTimer = null;
+      }
+      this.onResponse();
+    }
+
+    /**
+     * 获取上次心跳时间
+     */
+  }, {
+    key: "getLastHeartbeatTime",
+    value: function getLastHeartbeatTime() {
+      return this.lastHeartbeatTime;
+    }
+
+    /**
+     * 获取上次心跳响应时间
+     */
+  }, {
+    key: "getLastHeartbeatResponseTime",
+    value: function getLastHeartbeatResponseTime() {
+      return this.lastHeartbeatResponse;
+    }
+
+    /**
+     * 获取心跳是否活跃
+     */
+  }, {
+    key: "isActive",
+    value: function isActive() {
+      return this.active;
+    }
+
+    /**
+     * 安排下一次心跳
+     */
+  }, {
+    key: "scheduleHeartbeat",
+    value: function scheduleHeartbeat() {
+      var _this = this;
+      if (!this.active) {
+        return;
+      }
+      this.clearTimers();
+      this.intervalTimer = setInterval(function () {
+        _this.sendHeartbeatMessage();
+      }, this.options.interval);
+
+      // 立即发送一次心跳
+      this.sendHeartbeatMessage();
+    }
+
+    /**
+     * 发送心跳消息
+     */
+  }, {
+    key: "sendHeartbeatMessage",
+    value: function sendHeartbeatMessage() {
+      var _this2 = this;
+      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(function () {
+        if (_this2.active) {
+          _this2.onTimeout();
+        }
+      }, this.options.timeout);
+    }
+
+    /**
+     * 清除所有计时器
+     */
+  }, {
+    key: "clearTimers",
+    value: function clearTimers() {
+      if (this.intervalTimer) {
+        clearInterval(this.intervalTimer);
+        this.intervalTimer = null;
+      }
+      if (this.timeoutTimer) {
+        clearTimeout(this.timeoutTimer);
+        this.timeoutTimer = null;
+      }
+    }
+  }]);
+  return HeartbeatManager;
+}();

package/es/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/es/socket/index.js

@@ -0,0 +1,246 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { Socket } from "./socket";
+import { SocketStatus } from "./types";
+import { SocketEvents } from "./events";
+import { SocketMonitor } from "./monitor";
+import * as components from "./components";
+
+/**
+ * 创建Socket实例
+ * @param url WebSocket连接URL
+ * @param options Socket配置选项
+ */
+export function createSocket(url) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return new Socket(_objectSpread({
+    url: url
+  }, options));
+}
+
+/**
+ * Socket工厂类
+ * 提供创建和管理Socket实例的方法
+ */
+var SocketFactory = /*#__PURE__*/function () {
+  function SocketFactory() {
+    _classCallCheck(this, SocketFactory);
+    _defineProperty(this, "sockets", new Map());
+  }
+  _createClass(SocketFactory, [{
+    key: "create",
+    value:
+    /**
+     * 创建新的Socket实例
+     * @param url WebSocket连接URL
+     * @param options Socket配置选项
+     * @param key 可选的标识键，用于后续获取该Socket实例
+     */
+    function create(url) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var key = arguments.length > 2 ? arguments[2] : undefined;
+      var socket = new Socket(_objectSpread({
+        url: url
+      }, options));
+      if (key) {
+        this.sockets.set(key, socket);
+      }
+      return socket;
+    }
+
+    /**
+     * 获取Socket实例
+     * @param key Socket标识键
+     */
+  }, {
+    key: "get",
+    value: function get(key) {
+      return this.sockets.get(key);
+    }
+
+    /**
+     * 移除Socket实例
+     * @param key Socket标识键
+     */
+  }, {
+    key: "remove",
+    value: function remove(key) {
+      var socket = this.sockets.get(key);
+      if (socket) {
+        socket.destroy();
+        return this.sockets.delete(key);
+      }
+      return false;
+    }
+
+    /**
+     * 关闭并移除所有Socket实例
+     */
+  }, {
+    key: "closeAll",
+    value: function closeAll() {
+      var _iterator = _createForOfIteratorHelper(this.sockets.values()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var socket = _step.value;
+          socket.destroy();
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      this.sockets.clear();
+    }
+
+    /**
+     * 检查指定键的Socket是否存在
+     * @param key Socket标识键
+     */
+  }, {
+    key: "has",
+    value: function has(key) {
+      return this.sockets.has(key);
+    }
+
+    /**
+     * 获取所有Socket实例的标识键
+     */
+  }, {
+    key: "getKeys",
+    value: function getKeys() {
+      return Array.from(this.sockets.keys());
+    }
+
+    /**
+     * 获取所有Socket实例
+     */
+  }, {
+    key: "getAllSockets",
+    value: function getAllSockets() {
+      return Array.from(this.sockets.values());
+    }
+
+    /**
+     * 为指定的Socket启用监控
+     * @param key Socket标识键
+     * @param options 监控配置选项
+     */
+  }, {
+    key: "enableMonitoring",
+    value: function enableMonitoring(key, options) {
+      var socket = this.get(key);
+      if (socket) {
+        return socket.enableMonitoring(options);
+      }
+      return null;
+    }
+
+    /**
+     * 获取指定Socket的监控器
+     * @param key Socket标识键
+     */
+  }, {
+    key: "getMonitor",
+    value: function getMonitor(key) {
+      var socket = this.get(key);
+      if (socket) {
+        return socket.getMonitor();
+      }
+      return null;
+    }
+
+    /**
+     * 获取所有Socket的监控信息
+     */
+  }, {
+    key: "getAllMonitors",
+    value: function getAllMonitors() {
+      var result = new Map();
+      var _iterator2 = _createForOfIteratorHelper(this.sockets.entries()),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _step2$value = _slicedToArray(_step2.value, 2),
+            key = _step2$value[0],
+            socket = _step2$value[1];
+          result.set(key, socket.getMonitor());
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return result;
+    }
+  }]);
+  return SocketFactory;
+}(); // 创建单例实例
+var socketFactory = new SocketFactory();
+
+// 默认导出
+export 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: components
+};
+
+// 导出类型和常量
+export { Socket, SocketMonitor };
+export { SocketStatus, SocketEvents };