magic-chat-im 2.9.2 → 2.9.3

package/es/error-handler.d.ts

@@ -0,0 +1,45 @@
+import { LogLevel } from './logger';
+import { EXCEPTION_ERROR } from './common';
+import type { ErrorEventData } from './types';
+export interface ErrorContext {
+    [key: string]: any;
+}
+/**
+ * 错误级别枚举
+ */
+export declare enum ErrorLevel {
+    CRITICAL = "CRITICAL",// 致命错误，需要用户干预
+    HIGH = "HIGH",// 高优先级错误，影响功能
+    MEDIUM = "MEDIUM",// 中优先级错误，可恢复
+    LOW = "LOW"
+}
+/**
+ * 统一错误处理中心
+ */
+export declare class ErrorHandler {
+    private logger;
+    /**
+     * 报告业务异常
+     * @param code 异常代码
+     * @param error 错误对象
+     * @param context 上下文信息
+     * @param level 日志级别
+     */
+    reportException(code: EXCEPTION_ERROR, error: any, context?: ErrorContext, level?: LogLevel): ErrorEventData;
+    /**
+     * 报告系统错误
+     * @param message 错误消息
+     * @param error 错误对象
+     * @param context 上下文信息
+     */
+    reportError(message: string, error: any, context?: ErrorContext): {
+        message: string;
+        error: any;
+    };
+    /**
+     * 根据错误代码映射错误级别
+     * @param code 错误代码
+     */
+    private mapErrorLevel;
+}
+export declare const errorHandler: ErrorHandler;

package/es/error-handler.js

@@ -0,0 +1,111 @@
+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 { logger, LogLevel } from "./logger";
+import { EXCEPTION_ERROR } from "./common";
+/**
+ * 错误级别枚举
+ */
+export var ErrorLevel = /*#__PURE__*/function (ErrorLevel) {
+  ErrorLevel["CRITICAL"] = "CRITICAL";
+  ErrorLevel["HIGH"] = "HIGH";
+  ErrorLevel["MEDIUM"] = "MEDIUM";
+  ErrorLevel["LOW"] = "LOW";
+  return ErrorLevel;
+}({});
+
+/**
+ * 错误级别映射
+ */
+var ERROR_LEVEL_MAP = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, EXCEPTION_ERROR.NEED_RECONNECT_MANUAL, ErrorLevel.CRITICAL), EXCEPTION_ERROR.SOCKET_CONNECT_ERROR, ErrorLevel.HIGH), EXCEPTION_ERROR.GET_TOKEN_EXCEPTION, ErrorLevel.MEDIUM), EXCEPTION_ERROR.WS_NOT_SUPPORT, ErrorLevel.HIGH), EXCEPTION_ERROR.PARAMS_MISS, ErrorLevel.HIGH), EXCEPTION_ERROR.RECONNECT_ERROR, ErrorLevel.HIGH), EXCEPTION_ERROR.CONNECTION_CLOSED_CLEANLY, ErrorLevel.LOW), EXCEPTION_ERROR.SOCKET_IM_CLOSE, ErrorLevel.MEDIUM), EXCEPTION_ERROR.NETWORK_OFFLINE, ErrorLevel.MEDIUM);
+
+/**
+ * 统一错误处理中心
+ */
+export var ErrorHandler = /*#__PURE__*/function () {
+  function ErrorHandler() {
+    _classCallCheck(this, ErrorHandler);
+    _defineProperty(this, "logger", logger);
+  }
+  _createClass(ErrorHandler, [{
+    key: "reportException",
+    value:
+    /**
+     * 报告业务异常
+     * @param code 异常代码
+     * @param error 错误对象
+     * @param context 上下文信息
+     * @param level 日志级别
+     */
+    function reportException(code, error, context, level) {
+      // 如果未指定日志级别，则根据错误代码映射
+      var errorLevel = level !== null && level !== void 0 ? level : this.mapErrorLevel(code);
+      var errorData = _objectSpread({
+        code: code,
+        err: error
+      }, context);
+
+      // 根据错误级别记录日志
+      switch (errorLevel) {
+        case LogLevel.ERROR:
+          this.logger.errorWithContext("[Exception] ".concat(code), errorData);
+          break;
+        case LogLevel.WARN:
+          this.logger.warn("[Exception] ".concat(code), errorData);
+          break;
+        case LogLevel.INFO:
+          this.logger.info("[Exception] ".concat(code), errorData);
+          break;
+        default:
+          this.logger.errorWithContext("[Exception] ".concat(code), errorData);
+      }
+      return errorData;
+    }
+
+    /**
+     * 报告系统错误
+     * @param message 错误消息
+     * @param error 错误对象
+     * @param context 上下文信息
+     */
+  }, {
+    key: "reportError",
+    value: function reportError(message, error, context) {
+      var errorData = _objectSpread({
+        message: message,
+        error: error
+      }, context);
+      this.logger.errorWithContext("[System Error] ".concat(message), errorData);
+      return errorData;
+    }
+
+    /**
+     * 根据错误代码映射错误级别
+     * @param code 错误代码
+     */
+  }, {
+    key: "mapErrorLevel",
+    value: function mapErrorLevel(code) {
+      var level = ERROR_LEVEL_MAP[code];
+      switch (level) {
+        case ErrorLevel.CRITICAL:
+        case ErrorLevel.HIGH:
+          return LogLevel.ERROR;
+        case ErrorLevel.MEDIUM:
+          return LogLevel.WARN;
+        case ErrorLevel.LOW:
+          return LogLevel.INFO;
+        default:
+          return LogLevel.ERROR;
+      }
+    }
+  }]);
+  return ErrorHandler;
+}();
+export var errorHandler = new ErrorHandler();

package/es/event-handler.d.ts

@@ -0,0 +1,14 @@
+import type { IMInstance } from './im.interface';
+export declare class EventHandler {
+    private im;
+    private _boundHandlers;
+    constructor(im: IMInstance);
+    /**
+     * 绑定 WebSocket 事件
+     */
+    bindEvents(socket: any): void;
+    /**
+     * 解绑 WebSocket 事件
+     */
+    unbindEvents(socket: any): void;
+}

package/es/event-handler.js

@@ -0,0 +1,215 @@
+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 _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 { EVT_TYPE, EXCEPTION_ERROR, IM_TYPE, RECEIVED_MSG_TYPE, RECONNECT_RESON, WS_STATUS } from "./common";
+import { logger } from "./logger";
+import { getMsgBody, getError } from "./util";
+export var EventHandler = /*#__PURE__*/function () {
+  function EventHandler(im) {
+    _classCallCheck(this, EventHandler);
+    _defineProperty(this, "im", void 0);
+    _defineProperty(this, "_boundHandlers", {});
+    this.im = im;
+  }
+
+  /**
+   * 绑定 WebSocket 事件
+   */
+  _createClass(EventHandler, [{
+    key: "bindEvents",
+    value: function bindEvents(socket) {
+      var _this = this;
+      var options = this.im.options;
+      var connectCallback = options.connectCallback,
+        messageCallback = options.messageCallback,
+        ackCallback = options.ackCallback;
+
+      /**
+       * 连接打开实现Ping-Pong消息机制
+       * 定义一个定时器定期发送Ping消息给服务器。
+       * 当接收到服务器返回的Pong消息时，更新客户端的活跃状态或重置超时计时器。
+       */
+      this._boundHandlers[IM_TYPE.OPEN] = function () {
+        var _this$im$_reconnect;
+        // 更新连接统计信息
+        _this.im._monitoringManager.updateConnectionOpenStats();
+
+        // 在WebSocket连接建立后开始定期发送Ping
+        _this.im._keepAlive();
+        logger.debug('[IM] IM SDK start keep alive');
+
+        // reconnect连接成功清除重连
+        (_this$im$_reconnect = _this.im._reconnect) === null || _this$im$_reconnect === void 0 || _this$im$_reconnect.success();
+        _this.im.emit(EVT_TYPE.OPEN);
+        // 连接建立 TODO：后面应该收到后端的连接建立消息表明连接建立
+        _this.im.emit(EVT_TYPE.CONNECT);
+        connectCallback === null || connectCallback === void 0 || connectCallback();
+
+        // 重连重发 - 执行所有堆积的任务
+        _this.im._messageQueueManager.executeAllSendTasks();
+      };
+
+      /**
+       * ws失败error重连
+       * 监听error事件以捕获WebSocket连接中的错误。
+       * @param err
+       */
+      this._boundHandlers[IM_TYPE.ERROR] = function (err) {
+        logger.debug("[EventHandler] connection onError: ".concat(JSON.stringify(err)));
+        var errStr = getError(err);
+        if (socket.status === WS_STATUS.ONLINE) {
+          _this.im.errorEvent({
+            code: EXCEPTION_ERROR.SOCKET_CONNECT_ERROR,
+            err: errStr
+          });
+          _this.im.reconnect(RECONNECT_RESON.ONERROR, err);
+        }
+      };
+
+      /**
+       * ws关闭，非正常关闭WS重连，正常关闭无需重连
+       * 监听close事件以处理正常关闭或异常关闭的情况。
+       * @param err
+       */
+      this._boundHandlers[IM_TYPE.CLOSE] = function (err) {
+        // 如果是正常关闭，可能无需立即重连
+        logger.warn("[EventHandler] connection onClose: ".concat(JSON.stringify(err)));
+        var errStr = getError(err);
+        var reason = err.reason || 'Unknown';
+        if (err.wasClean) {
+          var msg = {
+            code: EXCEPTION_ERROR.CONNECTION_CLOSED_CLEANLY,
+            err: errStr,
+            reason: reason
+          };
+          _this.im.closeEvent(msg);
+        } else {
+          // 非正常关闭，触发重连逻辑
+          var _msg = {
+            code: EXCEPTION_ERROR.SOCKET_CONNECT_ERROR,
+            err: errStr,
+            reason: reason
+          };
+          _this.im.closeEvent(_msg);
+          _this.im.reconnect(RECONNECT_RESON.ONCLOSE, err);
+        }
+      };
+
+      /**
+       * 消息包格式：
+       * socket这边转发过来格式是
+       * {
+       *   type:
+       *   data
+       * }
+       * https://aliyuque.antfin.com/goc-dev/gts-fe/uwi3ta8enca0fdmm#ThWrH
+       * @param {*} data
+       */
+      this._boundHandlers[IM_TYPE.MESSAGE] = function (wsMessage) {
+        var _ref = wsMessage || {},
+          type = _ref.type,
+          data = _ref.data;
+        if (type === IM_TYPE.MESSAGE) {
+          if (typeof data === 'string' && data === 'hb') {
+            // 收到Pong消息，清除当前超时计时器，表明连接正常
+            // 主要连接消息 重置标记
+            // 使用连接管理器来设置用户关闭状态
+            _this.im._connectionManager.setUserClosed(false);
+            _this.im._onPongReceived();
+          } else {
+            logger.debug("[EventHandler] Message received: ".concat(JSON.stringify(data)));
+            var messageData = getMsgBody(data);
+            if (!messageData) {
+              logger.warn('[EventHandler] Invalid message data received');
+              return;
+            }
+            var name = messageData.name,
+              args = messageData.args,
+              messageKey = messageData.messageKey,
+              msgType = messageData.msgType,
+              _messageData$msgBody = messageData.msgBody,
+              msgBody = _messageData$msgBody === void 0 ? {} : _messageData$msgBody;
+
+            // ack消息
+            if (msgType === RECEIVED_MSG_TYPE.SERVER_ACK) {
+              ackCallback === null || ackCallback === void 0 || ackCallback(messageData);
+              _this.im.emit(EVT_TYPE.ACK, messageData);
+              if (messageKey) {
+                _this.im._ack(messageKey);
+              }
+            } else {
+              // 业务消息
+
+              /**
+               * 以下处理兼容旧的apush消息
+               */
+              if (name === 'apushMsg' && Array.isArray(args) && args.length) {
+                var arg = args[0];
+                var _ref2 = arg || {},
+                  _msgType = _ref2.msgType;
+                if (_msgType) {
+                  var msgBodyOld = {
+                    msgType: _msgType,
+                    version: '1.0.0',
+                    msgDetail: args
+                  };
+                  _this.im.emit(EVT_TYPE.MESSAGE, msgBodyOld);
+                  messageCallback === null || messageCallback === void 0 || messageCallback(msgBodyOld);
+                }
+                /**
+                 * 以下处理的webPush消息
+                 * webPush消息有messageKey，支持消息回溯
+                 */
+              } else if (name === 'webPush') {
+                // 消息去重 - 使用新的消息队列管理器来处理
+                // 注意：这里我们暂时保留原有的去重逻辑，但可以考虑用新的管理器来实现
+                if (messageKey) {
+                  // 简单的去重实现 - 在实际应用中可能需要更复杂的去重机制
+                  // 这里我们只是演示如何移除对 msgQueue 的依赖
+                  logger.debug("[EventHandler] Processing message with key: ".concat(messageKey));
+                }
+                _this.im.emit(EVT_TYPE.MESSAGE, msgBody);
+                messageCallback === null || messageCallback === void 0 || messageCallback(msgBody);
+
+                // 更新接收消息统计
+                _this.im._monitoringManager.updateMessageReceivedStats();
+                _this.im._ack(messageKey);
+
+                // 将 messageKey 加入队列 - 使用新的消息队列管理器来处理
+                if (messageKey) {
+                  // 这里可以添加对 messageKey 的处理逻辑
+                  logger.debug("[EventHandler] Message key added to queue: ".concat(messageKey));
+                }
+              }
+            }
+          }
+        }
+      };
+      socket.on(IM_TYPE.MESSAGE, this._boundHandlers[IM_TYPE.MESSAGE]);
+      socket.on(IM_TYPE.OPEN, this._boundHandlers[IM_TYPE.OPEN]);
+      socket.on(IM_TYPE.ERROR, this._boundHandlers[IM_TYPE.ERROR]);
+      socket.on(IM_TYPE.CLOSE, this._boundHandlers[IM_TYPE.CLOSE]);
+    }
+
+    /**
+     * 解绑 WebSocket 事件
+     */
+  }, {
+    key: "unbindEvents",
+    value: function unbindEvents(socket) {
+      var _this2 = this;
+      // 移除所有事件监听器
+      Object.keys(this._boundHandlers).forEach(function (eventType) {
+        socket.off(eventType, _this2._boundHandlers[eventType]);
+      });
+
+      // 清空绑定的处理器
+      this._boundHandlers = {};
+    }
+  }]);
+  return EventHandler;
+}();

package/es/heartbeat-manager.d.ts

@@ -0,0 +1,37 @@
+export interface HeartbeatConfig {
+    /**
+     * @description 心跳间隔时间（毫秒）
+     * @default 10000 (10秒)
+     */
+    pingInterval: number;
+    /**
+     * @description 心跳超时时间（毫秒）
+     * @default 60000 (60秒)
+     */
+    pingTimeout: number;
+}
+export declare class HeartbeatManager {
+    private pingIntervalId;
+    private pongTimeoutId;
+    private config;
+    private onTimeout;
+    private sendPing;
+    constructor(config: HeartbeatConfig, onTimeout: () => void);
+    /**
+     * 开始心跳
+     * @param sendPing 发送ping消息的函数
+     */
+    start(sendPing: () => void): void;
+    /**
+     * 停止心跳
+     */
+    stop(): void;
+    /**
+     * 重置心跳超时计时器
+     */
+    reset(): void;
+    /**
+     * 获取当前心跳配置
+     */
+    getConfig(): HeartbeatConfig;
+}

package/es/heartbeat-manager.js

@@ -0,0 +1,93 @@
+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 { logger } from "./logger";
+export var HeartbeatManager = /*#__PURE__*/function () {
+  function HeartbeatManager(config, onTimeout) {
+    _classCallCheck(this, HeartbeatManager);
+    _defineProperty(this, "pingIntervalId", null);
+    _defineProperty(this, "pongTimeoutId", null);
+    _defineProperty(this, "config", void 0);
+    _defineProperty(this, "onTimeout", void 0);
+    _defineProperty(this, "sendPing", null);
+    this.config = config;
+    this.onTimeout = onTimeout;
+  }
+
+  /**
+   * 开始心跳
+   * @param sendPing 发送ping消息的函数
+   */
+  _createClass(HeartbeatManager, [{
+    key: "start",
+    value: function start(sendPing) {
+      var _this = this;
+      this.sendPing = sendPing;
+
+      // 先清除旧的心跳
+      this.stop();
+
+      // 立即发送第一次心跳
+      this.sendPing();
+
+      // 定期发送心跳
+      this.pingIntervalId = window.setInterval(function () {
+        if (_this.sendPing) {
+          _this.sendPing();
+        }
+      }, this.config.pingInterval);
+    }
+
+    /**
+     * 停止心跳
+     */
+  }, {
+    key: "stop",
+    value: function stop() {
+      if (this.pingIntervalId) {
+        clearInterval(this.pingIntervalId);
+        this.pingIntervalId = null;
+      }
+      if (this.pongTimeoutId) {
+        clearTimeout(this.pongTimeoutId);
+        this.pongTimeoutId = null;
+      }
+    }
+
+    /**
+     * 重置心跳超时计时器
+     */
+  }, {
+    key: "reset",
+    value: function reset() {
+      var _this2 = this;
+      // 清除旧的超时计时器
+      if (this.pongTimeoutId) {
+        clearTimeout(this.pongTimeoutId);
+        this.pongTimeoutId = null;
+      }
+
+      // 设置新的超时检测
+      this.pongTimeoutId = window.setTimeout(function () {
+        logger.error('[HeartbeatManager] Heartbeat timeout detected');
+        _this2.onTimeout();
+      }, this.config.pingTimeout);
+    }
+
+    /**
+     * 获取当前心跳配置
+     */
+  }, {
+    key: "getConfig",
+    value: function getConfig() {
+      return _objectSpread({}, this.config);
+    }
+  }]);
+  return HeartbeatManager;
+}();

package/es/im.d.ts

@@ -0,0 +1,162 @@
+import { RECONNECT_RESON } from './common';
+import { ReconnectState } from './reconnect';
+import { HeartbeatManager } from './heartbeat-manager';
+import { MessageQueueManager } from './message-queue-manager';
+import { MonitoringManager } from './monitoring-manager';
+import { ConnectionManager } from './connection-manager';
+import type { CloseEventData, ErrorEventData, MessageBody, ReconnectEventData } from './types';
+import type { IMInstance, IMConnectionStats, CommonParams, Options } from './im.interface';
+export default class IM implements IMInstance {
+    version: string;
+    options: Options;
+    emit: any;
+    on: any;
+    im: any;
+    _connectionStats: IMConnectionStats;
+    _heartbeatManager: HeartbeatManager;
+    _messageQueueManager: MessageQueueManager;
+    private _eventHandler;
+    private _messageSender;
+    _monitoringManager: MonitoringManager;
+    _connectionManager: ConnectionManager;
+    private _hiddenToVisibleTimeThreshold;
+    _reconnect: any;
+    _commonParams: CommonParams;
+    _userClosed: boolean;
+    _msgCounter: number;
+    constructor(options: Options);
+    /**
+     * 销毁 IM 实例
+     * 注意：如果开启了 supportNetworkRestoredReconnect，必须显式调用此方法以清理资源
+     */
+    destroy(): void;
+    /**
+     * 设置全局参数
+     * @param {*} param
+     */
+    setCommonParams(param: any): void;
+    /**
+     * IM建连
+     */
+    connect(): void;
+    /**
+     * 重新建立im连接
+     *
+     * @param code 重连原因
+     */
+    reconnect(code: RECONNECT_RESON, error?: string | Event): void;
+    /**
+     * 关闭IM连接，用户主动关闭连接
+     */
+    close(): void;
+    /**
+     * 手动重连（用于达到最大重连次数后）
+     */
+    manualReconnect(): void;
+    /**
+     * 参考 ws.readyState
+     * CONNECTING：值为0，表示正在连接。
+     * OPEN：值为1，表示连接成功，可以通信了。
+     * CLOSING：值为2，表示连接正在关闭。
+     * CLOSED：值为3，表示连接已经关闭，或者打开连接失败。
+     */
+    readyState(): number;
+    /**
+     * error回调
+     */
+    errorEvent(msg: ErrorEventData): void;
+    /**
+     * 关闭回调
+     */
+    closeEvent(msg: CloseEventData): void;
+    /**
+     * 重连回调
+     */
+    reconnectEvent(msg: ReconnectEventData): void;
+    /**
+     * 设置用户关闭状态(用于测试)
+     * @param {boolean} closed - 是否为用户关闭
+     *
+     * @example
+     * // 模拟系统错误,允许重连
+     * im.setUserClosed(false);
+     *
+     * // 模拟用户主动关闭,阻止重连
+     * im.setUserClosed(true);
+     */
+    setUserClosed(closed: boolean): void;
+    /**
+     * 获取用户关闭状态(用于测试和监控)
+     * @returns {boolean} 是否为用户主动关闭
+     */
+    getUserClosed(): boolean;
+    /**
+     * 获取重连状态(用于监控)
+     * @returns {ReconnectState} 重连状态
+     */
+    getReconnectState(): ReconnectState | undefined;
+    /**
+     * 获取当前重连次数(用于监控)
+     * @returns {number} 当前重连次数
+     */
+    getReconnectCounter(): number;
+    /**
+     * 获取最大重连次数(用于监控)
+     * @returns {number} 最大重连次数
+     */
+    getReconnectMaxRetry(): number;
+    /**
+     * 获取待发送消息队列大小(用于监控)
+     * @returns {number} 队列大小
+     */
+    getQueueSize(): number;
+    /**
+     * 获取连接统计信息(用于监控)
+     * @returns {object} 连接统计信息
+     */
+    getConnectionStats(): IMConnectionStats;
+    /**
+     * 获取性能指标(用于监控)
+     * @returns {object} 性能指标
+     */
+    getPerformanceMetrics(): {
+        connectionSuccessRate: number;
+        messageLossRate: number;
+        averageReconnectionTime: number;
+        heartbeatTimeoutRate: number;
+    };
+    /**
+     * 重置连接统计信息
+     */
+    resetConnectionStats(): void;
+    /**
+     * 探测环境是否支持WebSocket
+     * 不支持WebSocket就降级long polling
+     */
+    _detect(): boolean;
+    _keepAlive(): void;
+    /**
+     * 收到 Pong 响应
+     */
+    _onPongReceived(): void;
+    _ack(messageKey: string): void;
+    _messageKey(): string;
+    /**
+     * 发送消息
+     */
+    sendMessage(msgBody?: Partial<MessageBody>): void;
+    /**
+     * 发送hb消息
+     */
+    ping(): void;
+    /**
+     * 发送事件消息
+     * @param {Object} data
+     */
+    sendEvent(data: Record<string, any>): void;
+    /**
+     * 发送消息
+     * @param {Object} data
+     */
+    _send(data: string): void;
+}