magic-chat-im 2.9.2 → 2.9.3

package/es/monitoring-manager.d.ts

@@ -0,0 +1,48 @@
+import type { IMInstance, IMConnectionStats } from './im.interface';
+export declare class MonitoringManager {
+    private im;
+    constructor(im: IMInstance);
+    /**
+     * 初始化连接统计信息
+     */
+    initializeConnectionStats(): IMConnectionStats;
+    /**
+     * 更新连接打开统计
+     */
+    updateConnectionOpenStats(): void;
+    /**
+     * 更新心跳超时统计
+     */
+    updateHeartbeatTimeoutStats(): void;
+    /**
+     * 更新消息接收统计
+     */
+    updateMessageReceivedStats(): void;
+    /**
+     * 更新消息发送统计
+     */
+    updateMessageSentStats(): void;
+    /**
+     * 更新连接关闭统计
+     */
+    updateConnectionCloseStats(): void;
+    /**
+     * 获取连接统计信息(用于监控)
+     * @returns {object} 连接统计信息
+     */
+    getConnectionStats(): IMConnectionStats;
+    /**
+     * 获取性能指标(用于监控)
+     * @returns {object} 性能指标
+     */
+    getPerformanceMetrics(): {
+        connectionSuccessRate: number;
+        messageLossRate: number;
+        averageReconnectionTime: number;
+        heartbeatTimeoutRate: number;
+    };
+    /**
+     * 重置连接统计信息
+     */
+    resetConnectionStats(): void;
+}

package/es/monitoring-manager.js

@@ -0,0 +1,161 @@
+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); }
+export var MonitoringManager = /*#__PURE__*/function () {
+  function MonitoringManager(im) {
+    _classCallCheck(this, MonitoringManager);
+    _defineProperty(this, "im", void 0);
+    this.im = im;
+  }
+
+  /**
+   * 初始化连接统计信息
+   */
+  _createClass(MonitoringManager, [{
+    key: "initializeConnectionStats",
+    value: function initializeConnectionStats() {
+      return {
+        totalConnections: 0,
+        totalReconnections: 0,
+        totalMessagesSent: 0,
+        totalMessagesReceived: 0,
+        totalHeartbeatTimeouts: 0,
+        firstConnectionTime: 0,
+        lastConnectTime: 0,
+        lastDisconnectTime: 0,
+        totalOnlineTime: 0,
+        currentOnlineTime: 0
+      };
+    }
+
+    /**
+     * 更新连接打开统计
+     */
+  }, {
+    key: "updateConnectionOpenStats",
+    value: function updateConnectionOpenStats() {
+      // 更新连接统计信息
+      this.im._connectionStats.totalConnections++;
+      var now = Date.now();
+      if (this.im._connectionStats.firstConnectionTime === 0) {
+        this.im._connectionStats.firstConnectionTime = now;
+      }
+      this.im._connectionStats.lastConnectTime = now;
+      if (this.im._connectionStats.totalConnections > 1) {
+        this.im._connectionStats.totalReconnections++;
+      }
+    }
+
+    /**
+     * 更新心跳超时统计
+     */
+  }, {
+    key: "updateHeartbeatTimeoutStats",
+    value: function updateHeartbeatTimeoutStats() {
+      this.im._connectionStats.totalHeartbeatTimeouts++;
+    }
+
+    /**
+     * 更新消息接收统计
+     */
+  }, {
+    key: "updateMessageReceivedStats",
+    value: function updateMessageReceivedStats() {
+      this.im._connectionStats.totalMessagesReceived++;
+    }
+
+    /**
+     * 更新消息发送统计
+     */
+  }, {
+    key: "updateMessageSentStats",
+    value: function updateMessageSentStats() {
+      this.im._connectionStats.totalMessagesSent++;
+    }
+
+    /**
+     * 更新连接关闭统计
+     */
+  }, {
+    key: "updateConnectionCloseStats",
+    value: function updateConnectionCloseStats() {
+      // 更新断开连接统计信息
+      if (this.im._connectionStats.lastConnectTime > 0) {
+        var now = Date.now();
+        this.im._connectionStats.lastDisconnectTime = now;
+        this.im._connectionStats.totalOnlineTime += now - this.im._connectionStats.lastConnectTime;
+        this.im._connectionStats.currentOnlineTime = 0;
+      }
+    }
+
+    /**
+     * 获取连接统计信息(用于监控)
+     * @returns {object} 连接统计信息
+     */
+  }, {
+    key: "getConnectionStats",
+    value: function getConnectionStats() {
+      // 更新当前在线时长
+      if (this.im._connectionStats.lastConnectTime > 0) {
+        this.im._connectionStats.currentOnlineTime = Date.now() - this.im._connectionStats.lastConnectTime;
+      }
+      return _objectSpread({}, this.im._connectionStats);
+    }
+
+    /**
+     * 获取性能指标(用于监控)
+     * @returns {object} 性能指标
+     */
+  }, {
+    key: "getPerformanceMetrics",
+    value: function getPerformanceMetrics() {
+      var stats = this.getConnectionStats();
+
+      // 连接成功率 = (总连接次数 - 总心跳超时次数) / 总连接次数
+      var connectionSuccessRate = stats.totalConnections > 0 ? (stats.totalConnections - stats.totalHeartbeatTimeouts) / stats.totalConnections : 1;
+
+      // 消息丢失率 = (发送消息数 - 接收ACK数) / 发送消息数
+      // 注意：这里简化处理，实际应该跟踪ACK确认数
+      var messageLossRate = stats.totalMessagesSent > 0 ? (stats.totalMessagesSent - stats.totalMessagesReceived) / stats.totalMessagesSent : 0;
+
+      // 平均重连时间（简化处理）
+      var averageReconnectionTime = stats.totalReconnections > 0 ? stats.totalOnlineTime / stats.totalReconnections : 0;
+
+      // 心跳超时率 = 心跳超时次数 / 总连接次数
+      var heartbeatTimeoutRate = stats.totalConnections > 0 ? stats.totalHeartbeatTimeouts / stats.totalConnections : 0;
+      return {
+        connectionSuccessRate: connectionSuccessRate,
+        messageLossRate: messageLossRate,
+        averageReconnectionTime: averageReconnectionTime,
+        heartbeatTimeoutRate: heartbeatTimeoutRate
+      };
+    }
+
+    /**
+     * 重置连接统计信息
+     */
+  }, {
+    key: "resetConnectionStats",
+    value: function resetConnectionStats() {
+      this.im._connectionStats = {
+        totalConnections: 0,
+        totalReconnections: 0,
+        totalMessagesSent: 0,
+        totalMessagesReceived: 0,
+        totalHeartbeatTimeouts: 0,
+        firstConnectionTime: 0,
+        lastConnectTime: 0,
+        lastDisconnectTime: 0,
+        totalOnlineTime: 0,
+        currentOnlineTime: 0
+      };
+    }
+  }]);
+  return MonitoringManager;
+}();

package/es/reconnect.d.ts

@@ -0,0 +1,19 @@
+import { RECONNECT_RESON } from './common';
+/**
+ * 重连状态枚举
+ * 使用状态机模式管理重连流程，避免 boolean 标记的不确定性
+ */
+export declare enum ReconnectState {
+    IDLE = "IDLE",// 空闲状态，没有重连
+    SCHEDULED = "SCHEDULED",// 已调度，等待定时器触发
+    CONNECTING = "CONNECTING"
+}
+export interface IReconnect {
+    success: () => void;
+    fail: (code: RECONNECT_RESON, err?: string | Event) => void;
+    reset: () => void;
+    getState?: () => ReconnectState;
+    getCounter?: () => number;
+    getMaxRetry?: () => number;
+}
+export default function (im: any): IReconnect;

package/es/reconnect.js

@@ -0,0 +1,279 @@
+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); }
+/* eslint-disable no-underscore-dangle */
+import { EXCEPTION_ERROR } from "./common";
+import { logger } from "./logger";
+import { isMobile } from "./util";
+/**
+ * 重连状态枚举
+ * 使用状态机模式管理重连流程，避免 boolean 标记的不确定性
+ */
+export var ReconnectState = /*#__PURE__*/function (ReconnectState) {
+  ReconnectState["IDLE"] = "IDLE";
+  ReconnectState["SCHEDULED"] = "SCHEDULED";
+  ReconnectState["CONNECTING"] = "CONNECTING";
+  return ReconnectState;
+}({}); // 正在连接中
+export default function (im) {
+  /**
+   * 重连最大次数默认值: 10 次 (约 3 分钟)
+   * 
+   * 时间计算 (指数退避 + 随机抖动):
+   * - 10 次: ~181s ≈ 3 分钟
+   * - 15 次: ~331s ≈ 5.5 分钟
+   * - 20 次: ~481s ≈ 8 分钟
+   * 
+   * 重连延迟序列: 1s → 2s → 4s → 8s → 16s → 30s(最大) × N
+   */
+  var _im$options$reconnect = im.options.reconnectMaxRetry,
+    reconnectMaxRetry = _im$options$reconnect === void 0 ? 10 : _im$options$reconnect;
+  var Reconnect = /*#__PURE__*/function () {
+    function Reconnect() {
+      _classCallCheck(this, Reconnect);
+      _defineProperty(this, "_state", void 0);
+      _defineProperty(this, "_counter", void 0);
+      _defineProperty(this, "_maxRetry", void 0);
+      _defineProperty(this, "_reconnectTimer", void 0);
+      this._state = ReconnectState.IDLE;
+      this._counter = 0;
+      this._maxRetry = reconnectMaxRetry;
+      this._reconnectTimer = null;
+    }
+
+    /**
+     * 连接异常后需要用户手动操作
+     * 否则可能引起死循环
+     */
+    _createClass(Reconnect, [{
+      key: "_exception",
+      value: function _exception(code, err) {
+        // 清理定时器并重置状态
+        if (this._reconnectTimer) {
+          clearTimeout(this._reconnectTimer);
+          this._reconnectTimer = null;
+        }
+        this._state = ReconnectState.IDLE;
+        var msg = {
+          code: code,
+          err: err
+        };
+        im.closeEvent(msg);
+      }
+
+      /**
+       * 标记重连已调度（定时器已设置）
+       */
+    }, {
+      key: "_scheduleReconnect",
+      value: function _scheduleReconnect() {
+        this._state = ReconnectState.SCHEDULED;
+      }
+
+      /**
+       * 标记正在连接中
+       */
+    }, {
+      key: "_startConnecting",
+      value: function _startConnecting() {
+        this._state = ReconnectState.CONNECTING;
+      }
+
+      /**
+       * 重连成功，重置所有状态
+       */
+    }, {
+      key: "_end",
+      value: function _end() {
+        this._counter = 0;
+        this._state = ReconnectState.IDLE;
+        if (this._reconnectTimer) {
+          clearTimeout(this._reconnectTimer);
+          this._reconnectTimer = null;
+        }
+      }
+
+      /**
+       * 指数退避算法 + 随机抖动
+       * 避免大量客户端同时重连造成惊群效应
+       * 移动端使用更积极的重连策略
+       */
+    }, {
+      key: "_backoff",
+      value: function _backoff(attempt) {
+        // 基础延迟 1 秒，最大延迟 30 秒
+        var baseDelay = isMobile() ? 500 : 1000; // 移动端更短的基础延迟
+        var maxDelay = 30000;
+
+        // 指数退避：1s, 2s, 4s, 8s, 16s, 30s, 30s...
+        var exponentialDelay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+
+        // 添加 ±30% 的随机抖动
+        var jitter = exponentialDelay * 0.3 * (Math.random() - 0.5);
+        return Math.floor(exponentialDelay + jitter);
+      }
+    }, {
+      key: "_exec",
+      value: function _exec(code, err) {
+        var _this = this;
+        // 防止重复调度重连
+        if (this._state !== ReconnectState.IDLE) {
+          logger.debug("[Reconnect] Reconnect already in progress (state: ".concat(this._state, "), skipping..."));
+          return;
+        }
+
+        // 取消之前的重连计划（防御性编程）
+        if (this._reconnectTimer) {
+          clearTimeout(this._reconnectTimer);
+          this._reconnectTimer = null;
+        }
+
+        // 使用指数退避算法确定重连时间，防止并发过多
+        var t = this._backoff(this._counter);
+        logger.debug("[Reconnect] Scheduling reconnect in ".concat(t, "ms (attempt ").concat(this._counter + 1, "/").concat(this._maxRetry, ")"), {
+          code: code
+        });
+
+        // 标记为已调度状态
+        this._scheduleReconnect();
+
+        // 倒计时后开始重连
+        this._reconnectTimer = window.setTimeout(function () {
+          _this._reconnectTimer = null;
+
+          // 标记为正在连接状态
+          _this._startConnecting();
+          try {
+            // 主动关闭 IM 连接
+            im.close();
+            // 重新建连
+            im.connect();
+          } catch (error) {
+            // 连接失败，触发异常处理
+            _this._exception(EXCEPTION_ERROR.RECONNECT_ERROR, {
+              code: EXCEPTION_ERROR.RECONNECT_ERROR,
+              err: {
+                code: code,
+                err: err,
+                error: error
+              },
+              msg: '重连失败',
+              context: {
+                attempt: _this._counter,
+                maxRetry: _this._maxRetry,
+                reconnectReason: code
+              }
+            });
+            return;
+          }
+
+          // 发送重连事件
+          im.reconnectEvent({
+            code: code,
+            err: err,
+            attempt: _this._counter + 1,
+            maxRetries: _this._maxRetry,
+            nextRetryDelay: _this._backoff(_this._counter + 1)
+          });
+        }, t);
+      }
+
+      /**
+       * 连接成功清除相关标记
+       */
+    }, {
+      key: "success",
+      value: function success() {
+        this._end();
+      }
+
+      /**
+       * 连接失败后自动重连
+       * @param {String} code - 重连原因
+       * @param {String | Event} err - 错误信息
+       */
+    }, {
+      key: "fail",
+      value: function fail(code, err) {
+        // 如果正在连接中，将状态重置为空闲以允许重新调度
+        if (this._state === ReconnectState.CONNECTING) {
+          this._state = ReconnectState.IDLE;
+        }
+        // 如果已经调度，需要先清理定时器
+        else if (this._state === ReconnectState.SCHEDULED && this._reconnectTimer) {
+          clearTimeout(this._reconnectTimer);
+          this._reconnectTimer = null;
+          this._state = ReconnectState.IDLE;
+        }
+        this._counter = this._counter + 1;
+
+        // 自动重连最多 this._maxRetry 次，否则需要用户手动重连
+        if (this._counter > this._maxRetry) {
+          // 这里不能直接重置计数器为0
+          // 而是在UI上做体现，提醒用户手动重连
+          // 不然会死循环
+          return this._exception(EXCEPTION_ERROR.NEED_RECONNECT_MANUAL, {
+            code: EXCEPTION_ERROR.NEED_RECONNECT_MANUAL,
+            err: {
+              reconnectReason: code,
+              reconnectError: err
+            },
+            msg: '重连次数超过最大值',
+            maxRetry: this._maxRetry
+          });
+        } else {
+          // 执行自动重连
+          this._exec(code, err);
+        }
+      }
+
+      /**
+       * 重置重连状态（供手动重连使用）
+       */
+    }, {
+      key: "reset",
+      value: function reset() {
+        this._counter = 0;
+        this._state = ReconnectState.IDLE;
+        if (this._reconnectTimer) {
+          clearTimeout(this._reconnectTimer);
+          this._reconnectTimer = null;
+        }
+      }
+
+      /**
+       * 获取当前重连状态（用于调试和监控）
+       */
+    }, {
+      key: "getState",
+      value: function getState() {
+        return this._state;
+      }
+
+      /**
+       * 获取当前重连次数（用于调试和监控）
+       */
+    }, {
+      key: "getCounter",
+      value: function getCounter() {
+        return this._counter;
+      }
+
+      /**
+       * 获取最大重连次数（用于调试和监控）
+       */
+    }, {
+      key: "getMaxRetry",
+      value: function getMaxRetry() {
+        return this._maxRetry;
+      }
+    }]);
+    return Reconnect;
+  }();
+  var r = new Reconnect();
+  return r;
+}

package/es/socket.d.ts

@@ -0,0 +1,29 @@
+import type { WS_READYSTATE } from './common';
+import { WS_STATUS } from './common';
+interface Config {
+    url: string;
+    token: string;
+    appKey: string;
+}
+export default class Socket {
+    ws: WebSocket;
+    config: Config;
+    emit: (type: string, data?: any) => void;
+    on: (type: string, handler: (data: any) => void) => void;
+    private _eventHandlers;
+    constructor(config: Config);
+    /**
+     * 获取 WebSocket 的 readyState
+     */
+    get readyState(): WS_READYSTATE;
+    /**
+     * 自动根据 WebSocket 的实际状态计算 status
+     * 使用 getter 避免状态不同步问题
+     */
+    get status(): WS_STATUS;
+    send(data: string): void;
+    close(): void;
+    private _bindEvts;
+    private _unbindEvts;
+}
+export {};