magic-chat-im 2.9.2 → 2.9.3

package/es/im.interface.d.ts

@@ -0,0 +1,234 @@
+import type { RECONNECT_RESON } from './common';
+import type { MessageQueueManager } from './message-queue-manager';
+import type { HeartbeatManager } from './heartbeat-manager';
+import type { MonitoringManager } from './monitoring-manager';
+import type { ConnectionManager } from './connection-manager';
+import type { ReconnectState } from './reconnect';
+import type { MessageBody, MessageData, ReconnectEventData, CloseEventData, ErrorEventData } from './types';
+import type { LoggerConfig } from './logger';
+/**
+ * IM 公共参数接口
+ */
+export interface CommonParams {
+    /**
+     * @description 消息所属应用
+     * @default ''
+     */
+    appId?: string;
+    /**
+     * @description 消息所属topic
+     * @default ''
+     */
+    userId?: string;
+}
+/**
+ * IM 配置选项接口
+ */
+export interface Options {
+    /**
+     * @description webpush链接地址
+     * @default ''
+     */
+    url: string;
+    /**
+     * @description webpush appKey
+     * @default ''
+     */
+    appKey: string;
+    /**
+     * @description webpush token
+     * @default ''
+     */
+    token?: string;
+    /**
+     * @description getToken
+     * @default ''
+     */
+    getToken: () => Promise<string>;
+    /**
+     * @description 默认参数
+     * @default {}
+     */
+    commonParams?: CommonParams;
+    /**
+     * @description 最大重连次数
+     * @default 10 - 推荐值 (约 3 分钟)
+     *
+     * 推荐配置:
+     * - 5-10 次: 高实时性应用 (~1-3 分钟)
+     * - 10-15 次: 标准 IM 应用 (~3-5 分钟) [推荐]
+     * - 15-20 次: 保守配置 (~5-8 分钟)
+     *
+     * 指数退避算法: 1s → 2s → 4s → 8s → 16s → 30s(最大) × N
+     * 不推荐超过 20 次,以免长时间无意义的重连尝试
+     */
+    reconnectMaxRetry?: number;
+    /**
+     * @description 连接成功回调
+     * @default ''
+     */
+    connectCallback?: () => void;
+    /**
+     * @description 断连回调
+     * @default ''
+     */
+    disconnectCallback?: () => void;
+    /**
+     * @description 重连成功回调
+     * @default ''
+     */
+    reconnectCallback?: (msg: ReconnectEventData) => void;
+    /**
+     * @description 收到ack回调
+     * @default ''
+     */
+    ackCallback?: (msg: MessageData) => void;
+    /**
+     * @description 接收message数据回调
+     * @default ''
+     */
+    messageCallback?: (msg: MessageBody) => void;
+    /**
+     * @description webpush异常错误回调
+     * @default ''
+     */
+    errorCallback?: (err: ErrorEventData) => void;
+    /**
+     * @description webpush 长链接异常关闭回调，可以弹窗提醒用户刷新页面
+     * @default ''
+     */
+    closeCallback?: (err: CloseEventData) => void;
+    /**
+     * @description 支持监听网络状态变化重连, 注意如果开启这个模式，在im 销毁时需要显示调用destroy方法
+     * @default false
+     */
+    supportNetworkRestoredReconnect?: boolean;
+    /**
+     * @description 日志配置
+     * @default 开发环境: { level: LogLevel.DEBUG, enabled: true }, 生产环境: { level: LogLevel.WARN, enabled: false }
+     *
+     * @example
+     * ```typescript
+     * // 使用默认配置（推荐）
+     * const im = new IM({ url, appKey, getToken });
+     *
+     * // 自定义日志配置
+     * const im = new IM({
+     *   url,
+     *   appKey,
+     *   getToken,
+     *   loggerConfig: {
+     *     level: LogLevel.INFO,      // 日志级别
+     *     enabled: true,             // 是否启用
+     *     timestamp: true,           // 显示时间戳
+     *     prefix: '[我的应用]',       // 自定义前缀
+     *     handler: (level, message, ...args) => {
+     *       // 自定义处理器（如上报到服务器）
+     *       if (level === LogLevel.ERROR) {
+     *         reportToServer({ level, message, args });
+     *       }
+     *     },
+     *   },
+     * });
+     *
+     * // 禁用所有日志
+     * const im = new IM({
+     *   url,
+     *   appKey,
+     *   getToken,
+     *   loggerConfig: { enabled: false },
+     * });
+     * ```
+     */
+    loggerConfig?: Partial<LoggerConfig>;
+    /**
+     * @description 心跳超时时间（毫秒）
+     * @default 60000 (60秒) - 标准环境
+     * @default 30000 (30秒) - 移动端环境
+     */
+    pingTimeout?: number;
+    /**
+     * @description 心跳间隔时间（毫秒）
+     * @default 10000 (10秒) - 标准环境
+     * @default 5000 (5秒) - 移动端环境
+     */
+    pingInterval?: number;
+    /**
+     * @description 页面从隐藏到可见状态的时间阈值（毫秒），超过此时间将触发重连
+     * @default 30000 (30秒)
+     */
+    hiddenToVisibleTimeThreshold?: number;
+    /**
+     * @description 连接超时时间（毫秒），建议10-30秒
+     * @default 15000 (15秒)
+     */
+    connectionTimeout?: number;
+}
+/**
+ * IM 连接统计信息接口
+ */
+export interface IMConnectionStats {
+    totalConnections: number;
+    totalReconnections: number;
+    totalMessagesSent: number;
+    totalMessagesReceived: number;
+    totalHeartbeatTimeouts: number;
+    firstConnectionTime: number;
+    lastConnectTime: number;
+    lastDisconnectTime: number;
+    totalOnlineTime: number;
+    currentOnlineTime: number;
+}
+/**
+ * IM 实例接口
+ * 定义了 IM 类需要实现的所有公共方法和属性
+ */
+export interface IMInstance {
+    version: string;
+    options: any;
+    im: any;
+    _reconnect: any;
+    _commonParams: any;
+    _userClosed: boolean;
+    _msgCounter: number;
+    _connectionStats: IMConnectionStats;
+    _heartbeatManager: HeartbeatManager;
+    _messageQueueManager: MessageQueueManager;
+    _monitoringManager: MonitoringManager;
+    _connectionManager: ConnectionManager;
+    emit: (event: string, data?: any) => void;
+    on: (event: string, handler: (data?: any) => void) => void;
+    _keepAlive: () => void;
+    _onPongReceived: () => void;
+    _ack: (messageKey: string) => void;
+    _send: (data: string) => void;
+    _messageKey: () => string;
+    _detect: () => boolean;
+    connect: () => void;
+    reconnect: (code: RECONNECT_RESON, error?: any) => void;
+    close: () => void;
+    manualReconnect: () => void;
+    readyState: () => number;
+    sendMessage: (msgBody?: Partial<MessageBody>) => void;
+    ping: () => void;
+    sendEvent: (data: Record<string, any>) => void;
+    errorEvent: (msg: ErrorEventData) => void;
+    closeEvent: (msg: CloseEventData) => void;
+    reconnectEvent: (msg: ReconnectEventData) => void;
+    setUserClosed: (closed: boolean) => void;
+    getReconnectState: () => ReconnectState | undefined;
+    getReconnectCounter: () => number;
+    getReconnectMaxRetry: () => number;
+    getQueueSize: () => number;
+    getUserClosed: () => boolean;
+    getConnectionStats: () => IMConnectionStats;
+    getPerformanceMetrics: () => {
+        connectionSuccessRate: number;
+        messageLossRate: number;
+        averageReconnectionTime: number;
+        heartbeatTimeoutRate: number;
+    };
+    resetConnectionStats: () => void;
+    destroy: () => void;
+    setCommonParams: (param: any) => void;
+}

package/es/im.interface.js

@@ -0,0 +1 @@
+export {};

package/es/im.js

@@ -0,0 +1,444 @@
+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); }
+/* eslint-disable no-underscore-dangle */
+
+/* eslint-disable @typescript-eslint/member-ordering */
+
+/**
+ * IM 通讯层
+ * 这里需要适配 websocket
+ */
+import mitt from 'mitt';
+import { RECONNECT_RESON, WS_READYSTATE } from "./common";
+import { logger } from "./logger";
+import Reconnect from "./reconnect";
+import { HeartbeatManager } from "./heartbeat-manager";
+import { MessageQueueManager } from "./message-queue-manager";
+import { EventHandler } from "./event-handler";
+import { MessageSender } from "./message-sender";
+import { MonitoringManager } from "./monitoring-manager";
+import { ConnectionManager } from "./connection-manager";
+import { isMobile } from "./util";
+// 定义Ping-Pong超时时间默认值（例如60秒）
+var DEFAULT_PING_TIMEOUT = 60 * 1000;
+// 移动端特殊处理：更短的超时时间
+var DEFAULT_MOBILE_PING_TIMEOUT = 30 * 1000;
+
+// 定义定时发送Ping的间隔默认值（例如每10秒一次）
+var DEFAULT_PING_INTERVAL = 10 * 1000;
+// 移动端特殊处理：更频繁的心跳检测
+var DEFAULT_MOBILE_PING_INTERVAL = 5 * 1000;
+
+// 页面隐藏到再次可见的时间阈值默认值（例如30秒）
+var DEFAULT_HIDDEN_2_VISIBLE_TIME = 30 * 1000;
+var IM = /*#__PURE__*/function () {
+  // 消息计数器
+
+  function IM(options) {
+    var _this = this;
+    _classCallCheck(this, IM);
+    _defineProperty(this, "version", void 0);
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "emit", void 0);
+    _defineProperty(this, "on", void 0);
+    _defineProperty(this, "im", void 0);
+    // 连接统计信息
+    _defineProperty(this, "_connectionStats", void 0);
+    // 心跳管理器实例
+    _defineProperty(this, "_heartbeatManager", void 0);
+    // 消息队列管理器实例
+    _defineProperty(this, "_messageQueueManager", void 0);
+    // 事件处理器实例
+    _defineProperty(this, "_eventHandler", void 0);
+    // 消息发送器实例
+    _defineProperty(this, "_messageSender", void 0);
+    // 监控管理器实例
+    _defineProperty(this, "_monitoringManager", void 0);
+    // 连接管理器实例
+    _defineProperty(this, "_connectionManager", void 0);
+    _defineProperty(this, "_hiddenToVisibleTimeThreshold", void 0);
+    _defineProperty(this, "_reconnect", void 0);
+    _defineProperty(this, "_commonParams", void 0);
+    _defineProperty(this, "_userClosed", false);
+    // 标记用户是否主动关闭连接
+    _defineProperty(this, "_msgCounter", 0);
+    var _options$commonParams = options.commonParams,
+      commonParams = _options$commonParams === void 0 ? {} : _options$commonParams,
+      loggerConfig = options.loggerConfig;
+    Object.assign(this, _objectSpread({
+      options: options
+    }, mitt()));
+
+    // IM协议版本
+    this.version = '1.0';
+
+    // 标记用户是否主动关闭
+    this._userClosed = false;
+
+    // 初始化连接统计信息
+    this._monitoringManager = new MonitoringManager(this);
+    this._connectionStats = this._monitoringManager.initializeConnectionStats();
+
+    // 初始化心跳管理器
+    var pingTimeout = options.pingTimeout || (isMobile() ? DEFAULT_MOBILE_PING_TIMEOUT : DEFAULT_PING_TIMEOUT);
+    var pingInterval = options.pingInterval || (isMobile() ? DEFAULT_MOBILE_PING_INTERVAL : DEFAULT_PING_INTERVAL);
+    this._heartbeatManager = new HeartbeatManager({
+      pingTimeout: pingTimeout,
+      pingInterval: pingInterval
+    }, function () {
+      // 心跳超时回调
+      logger.error('[IM] Heartbeat timeout, initiating reconnect');
+      // 更新心跳超时统计
+      _this._monitoringManager.updateHeartbeatTimeoutStats();
+      _this.reconnect(RECONNECT_RESON.HEARTBEAT_TIMEOUT);
+    });
+
+    // 初始化消息队列管理器
+    this._messageQueueManager = new MessageQueueManager();
+
+    // 初始化事件处理器
+    this._eventHandler = new EventHandler(this);
+
+    // 初始化消息发送器
+    this._messageSender = new MessageSender(this);
+    this._hiddenToVisibleTimeThreshold = options.hiddenToVisibleTimeThreshold || DEFAULT_HIDDEN_2_VISIBLE_TIME;
+
+    // 初始化连接管理器
+    this._connectionManager = new ConnectionManager(this, this._hiddenToVisibleTimeThreshold);
+
+    // 配置日志系统
+    if (loggerConfig) {
+      logger.setConfig(loggerConfig);
+    }
+
+    /**
+     * 重连
+     * 1. 心跳超时直接重连，见 _mockHeartbeatTimeout
+     * 2. ws失败error重连，见 onError
+     * 3. ws非正常关闭，close重连
+     * 4. 发消息时，发现ws非连接中状态都重连，见 sendMessage
+     * 5. 往外面暴露reconnect重连方法，由外部控制重连
+     */
+    this._reconnect = Reconnect(this);
+
+    // 消息全局参数
+    this._commonParams = commonParams;
+
+    // 添加网络和可见性监听器
+    if (this.options.supportNetworkRestoredReconnect) {
+      this._connectionManager.attachEventListeners();
+    } else if (process.env.NODE_ENV !== 'production') {
+      // 开发环境提示：建议启用网络监听以获得更好的用户体验
+      logger.warn('[IM] 建议启用 supportNetworkRestoredReconnect 以获得更好的连接稳定性。\n' + '启用后请确保在组件卸载时调用 destroy() 方法。\n' + '示例: new IM({ supportNetworkRestoredReconnect: true, ... })');
+    }
+  }
+
+  /**
+   * 销毁 IM 实例
+   * 注意：如果开启了 supportNetworkRestoredReconnect，必须显式调用此方法以清理资源
+   */
+  _createClass(IM, [{
+    key: "destroy",
+    value: function destroy() {
+      logger.info('[IM] IM SDK instance destroyed');
+
+      // 移除事件监听器
+      this._connectionManager.detachEventListeners();
+
+      // 解绑WebSocket事件
+      if (this.im) {
+        this._eventHandler.unbindEvents(this.im);
+      }
+
+      // 清理定时器
+      this._connectionManager.cleanup();
+
+      // 人为主动关闭连接
+      this.close();
+      this.setUserClosed(true);
+
+      // 清理IM实例上的所有事件监听器
+      // 由于mitt库没有提供直接清理所有事件监听器的方法，我们记录这个事实
+      // 在实际应用中，使用者应该在destroy之前移除所有手动添加的事件监听器
+    }
+    /**
+     * 设置全局参数
+     * @param {*} param
+     */
+  }, {
+    key: "setCommonParams",
+    value: function setCommonParams(param) {
+      this._commonParams = _objectSpread(_objectSpread({}, this._commonParams), param);
+    }
+
+    /**
+     * IM建连
+     */
+  }, {
+    key: "connect",
+    value: function connect() {
+      this._connectionManager.connect();
+    }
+
+    /**
+     * 重新建立im连接
+     *
+     * @param code 重连原因
+     */
+  }, {
+    key: "reconnect",
+    value: function reconnect(code, error) {
+      this._connectionManager.reconnect(code, error);
+    }
+
+    /**
+     * 关闭IM连接，用户主动关闭连接
+     */
+  }, {
+    key: "close",
+    value: function close() {
+      this._connectionManager.close();
+    }
+
+    /**
+     * 手动重连（用于达到最大重连次数后）
+     */
+  }, {
+    key: "manualReconnect",
+    value: function manualReconnect() {
+      this._connectionManager.manualReconnect();
+    }
+
+    /**
+     * 参考 ws.readyState
+     * CONNECTING：值为0，表示正在连接。
+     * OPEN：值为1，表示连接成功，可以通信了。
+     * CLOSING：值为2，表示连接正在关闭。
+     * CLOSED：值为3，表示连接已经关闭，或者打开连接失败。
+     */
+  }, {
+    key: "readyState",
+    value: function readyState() {
+      return this._connectionManager.readyState();
+    }
+
+    /**
+     * error回调
+     */
+  }, {
+    key: "errorEvent",
+    value: function errorEvent(msg) {
+      this._connectionManager.errorEvent(msg);
+    }
+
+    /**
+     * 关闭回调
+     */
+  }, {
+    key: "closeEvent",
+    value: function closeEvent(msg) {
+      this._connectionManager.closeEvent(msg);
+    }
+
+    /**
+     * 重连回调
+     */
+  }, {
+    key: "reconnectEvent",
+    value: function reconnectEvent(msg) {
+      this._connectionManager.reconnectEvent(msg);
+    }
+
+    /**
+     * 设置用户关闭状态(用于测试)
+     * @param {boolean} closed - 是否为用户关闭
+     * 
+     * @example
+     * // 模拟系统错误,允许重连
+     * im.setUserClosed(false);
+     * 
+     * // 模拟用户主动关闭,阻止重连
+     * im.setUserClosed(true);
+     */
+  }, {
+    key: "setUserClosed",
+    value: function setUserClosed(closed) {
+      logger.debug("[IM] Setting _userClosed to ".concat(closed));
+      this._userClosed = closed;
+    }
+
+    /**
+     * 获取用户关闭状态(用于测试和监控)
+     * @returns {boolean} 是否为用户主动关闭
+     */
+  }, {
+    key: "getUserClosed",
+    value: function getUserClosed() {
+      return this._userClosed;
+    }
+
+    /**
+     * 获取重连状态(用于监控)
+     * @returns {ReconnectState} 重连状态
+     */
+  }, {
+    key: "getReconnectState",
+    value: function getReconnectState() {
+      var _this$_reconnect, _this$_reconnect$getS;
+      return (_this$_reconnect = this._reconnect) === null || _this$_reconnect === void 0 || (_this$_reconnect$getS = _this$_reconnect.getState) === null || _this$_reconnect$getS === void 0 ? void 0 : _this$_reconnect$getS.call(_this$_reconnect);
+    }
+
+    /**
+     * 获取当前重连次数(用于监控)
+     * @returns {number} 当前重连次数
+     */
+  }, {
+    key: "getReconnectCounter",
+    value: function getReconnectCounter() {
+      var _this$_reconnect$getC, _this$_reconnect2, _this$_reconnect2$get;
+      return (_this$_reconnect$getC = (_this$_reconnect2 = this._reconnect) === null || _this$_reconnect2 === void 0 || (_this$_reconnect2$get = _this$_reconnect2.getCounter) === null || _this$_reconnect2$get === void 0 ? void 0 : _this$_reconnect2$get.call(_this$_reconnect2)) !== null && _this$_reconnect$getC !== void 0 ? _this$_reconnect$getC : 0;
+    }
+
+    /**
+     * 获取最大重连次数(用于监控)
+     * @returns {number} 最大重连次数
+     */
+  }, {
+    key: "getReconnectMaxRetry",
+    value: function getReconnectMaxRetry() {
+      var _this$_reconnect$getM, _this$_reconnect3, _this$_reconnect3$get;
+      return (_this$_reconnect$getM = (_this$_reconnect3 = this._reconnect) === null || _this$_reconnect3 === void 0 || (_this$_reconnect3$get = _this$_reconnect3.getMaxRetry) === null || _this$_reconnect3$get === void 0 ? void 0 : _this$_reconnect3$get.call(_this$_reconnect3)) !== null && _this$_reconnect$getM !== void 0 ? _this$_reconnect$getM : 0;
+    }
+
+    /**
+     * 获取待发送消息队列大小(用于监控)
+     * @returns {number} 队列大小
+     */
+  }, {
+    key: "getQueueSize",
+    value: function getQueueSize() {
+      // 返回新的消息队列管理器中的待发送任务数量
+      return this._messageQueueManager.getSendQueueSize();
+    }
+
+    /**
+     * 获取连接统计信息(用于监控)
+     * @returns {object} 连接统计信息
+     */
+  }, {
+    key: "getConnectionStats",
+    value: function getConnectionStats() {
+      return this._monitoringManager.getConnectionStats();
+    }
+
+    /**
+     * 获取性能指标(用于监控)
+     * @returns {object} 性能指标
+     */
+  }, {
+    key: "getPerformanceMetrics",
+    value: function getPerformanceMetrics() {
+      return this._monitoringManager.getPerformanceMetrics();
+    }
+
+    /**
+     * 重置连接统计信息
+     */
+  }, {
+    key: "resetConnectionStats",
+    value: function resetConnectionStats() {
+      this._monitoringManager.resetConnectionStats();
+    }
+
+    /**
+     * 探测环境是否支持WebSocket
+     * 不支持WebSocket就降级long polling
+     */
+  }, {
+    key: "_detect",
+    value: function _detect() {
+      return !!(window.WebSocket && window.WebSocket.prototype.send);
+    }
+    // 端上保持心跳
+  }, {
+    key: "_keepAlive",
+    value: function _keepAlive() {
+      var _this2 = this;
+      // 使用心跳管理器开始心跳
+      this._heartbeatManager.start(function () {
+        _this2.ping();
+      });
+    }
+
+    /**
+     * 收到 Pong 响应
+     */
+  }, {
+    key: "_onPongReceived",
+    value: function _onPongReceived() {
+      // 收到 pong，重置心跳超时计时器
+      this._heartbeatManager.reset();
+      logger.debug('[IM] Pong received, connection is healthy');
+    }
+
+    // 收到后端业务消息的ack
+  }, {
+    key: "_ack",
+    value: function _ack(messageKey) {
+      this._messageSender.ack(messageKey);
+    }
+  }, {
+    key: "_messageKey",
+    value: function _messageKey() {
+      return this._messageSender.messageKey();
+    }
+
+    /**
+     * 发送消息
+     */
+  }, {
+    key: "sendMessage",
+    value: function sendMessage() {
+      var msgBody = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      this._messageSender.sendMessage(msgBody);
+    }
+    /**
+     * 发送hb消息
+     */
+  }, {
+    key: "ping",
+    value: function ping() {
+      this._messageSender.ping();
+    }
+    /**
+     * 发送事件消息
+     * @param {Object} data
+     */
+  }, {
+    key: "sendEvent",
+    value: function sendEvent(data) {
+      this._messageSender.sendEvent(data);
+    }
+    /**
+     * 发送消息
+     * @param {Object} data
+     */
+  }, {
+    key: "_send",
+    value: function _send(data) {
+      if (this.im && this.readyState() === WS_READYSTATE.OPEN) {
+        var _this$im;
+        (_this$im = this.im) === null || _this$im === void 0 || _this$im.send(data);
+      }
+    }
+  }]);
+  return IM;
+}();
+export { IM as default };

package/es/index.d.ts

@@ -0,0 +1,7 @@
+export * from './im';
+export * from './im.interface';
+export * from './common';
+export * from './logger';
+export * from './reconnect';
+export type * from './types';
+export { default } from './im';

package/es/index.js

@@ -0,0 +1,8 @@
+// IM SDK 导出文件
+export * from "./im";
+export * from "./im.interface";
+export * from "./common";
+export * from "./logger";
+export * from "./reconnect";
+// 添加 IM 类的默认导出
+export { default } from "./im";