tgo-widget-miniprogram 1.0.0 → 1.1.1

package/miniprogram_dist/services/wukongim.js

@@ -1,183 +1,1131 @@
-/**
- * WuKongIM EasyJSSDK wrapper for miniprogram
- * easyjssdk v1.1.0+ natively supports WeChat MiniProgram WebSocket
- */
-var WKIM = require('easyjssdk').WKIM
-var WKIMEvent = require('easyjssdk').WKIMEvent
-var adapter = require('../adapters/request')
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 
-function WuKongIMService() {
-  this._inited = false
-  this._im = null
-  this._cfg = null
-  this._uid = null
-  this._bound = false
-  this._hConnect = null
-  this._hDisconnect = null
-  this._hError = null
-  this._hMessage = null
-  this._hCustom = null
-  this._msgListeners = []
-  this._statusListeners = []
-  this._customListeners = []
-}
-
-WuKongIMService.prototype.isReady = function () {
-  return this._inited && !!this._im && !!this._cfg
-}
-
-WuKongIMService.prototype.getUid = function () {
-  return this._uid
-}
-
-WuKongIMService.prototype.init = function (opts) {
-  var self = this
-  this._cfg = Object.assign({}, opts, { channelType: opts.channelType || 'person' })
-  this._uid = opts.uid
-
-  return this._fetchRouteWsAddr(opts.apiBase, opts.uid, 10000).then(function (wsAddr) {
-    if (self._im && self._bound) {
-      try { self._unbindInternalEvents() } catch (e) {}
+// node_modules/easyjssdk/dist/cjs/index.js
+var require_cjs = __commonJS({
+  "node_modules/easyjssdk/dist/cjs/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.WKIMDeviceFlag = exports2.WKIMEvent = exports2.WKIMChannelType = exports2.WKIM = exports2.DeviceFlag = exports2.ReasonCode = exports2.Event = exports2.ChannelType = exports2.currentPlatform = exports2.PlatformType = void 0;
+    var WS_CONNECTING = 0;
+    var WS_OPEN = 1;
+    var WS_CLOSING = 2;
+    var WS_CLOSED = 3;
+    var PlatformType;
+    (function(PlatformType2) {
+      PlatformType2["Browser"] = "browser";
+      PlatformType2["NodeJS"] = "nodejs";
+      PlatformType2["WeChat"] = "wechat";
+      PlatformType2["Alipay"] = "alipay";
+      PlatformType2["UniApp"] = "uniapp";
+    })(PlatformType || (exports2.PlatformType = PlatformType = {}));
+    var WeChatWebSocketAdapter = class {
+      constructor(url) {
+        this.socketTask = null;
+        this._readyState = WS_CONNECTING;
+        this.onopen = null;
+        this.onmessage = null;
+        this.onerror = null;
+        this.onclose = null;
+        if (typeof wx === "undefined") {
+          throw new Error("WeChat Mini Program environment not detected");
+        }
+        this.socketTask = wx.connectSocket({
+          url,
+          success: () => {
+            console.log("WeChat WebSocket connecting...");
+          },
+          fail: (err) => {
+            console.error("WeChat WebSocket connection failed:", err);
+            this._readyState = WS_CLOSED;
+            if (this.onerror) {
+              this.onerror({ message: err.errMsg || "Connection failed" });
+            }
+          }
+        });
+        this.socketTask.onOpen((res) => {
+          this._readyState = WS_OPEN;
+          if (this.onopen) {
+            this.onopen(res);
+          }
+        });
+        this.socketTask.onMessage((res) => {
+          if (this.onmessage) {
+            const data = res.data instanceof ArrayBuffer ? new TextDecoder().decode(res.data) : res.data;
+            this.onmessage({ data });
+          }
+        });
+        this.socketTask.onError((res) => {
+          console.error("WeChat WebSocket error:", res);
+          if (this.onerror) {
+            this.onerror({ message: res.errMsg || "WebSocket error" });
+          }
+        });
+        this.socketTask.onClose((res) => {
+          this._readyState = WS_CLOSED;
+          if (this.onclose) {
+            this.onclose({ code: res.code || 1e3, reason: res.reason || "" });
+          }
+        });
+      }
+      get readyState() {
+        return this._readyState;
+      }
+      send(data) {
+        if (this._readyState !== WS_OPEN || !this.socketTask) {
+          throw new Error("WebSocket is not open");
+        }
+        this.socketTask.send({
+          data,
+          fail: (err) => {
+            console.error("WeChat WebSocket send failed:", err);
+            if (this.onerror) {
+              this.onerror({ message: "Send failed" });
+            }
+          }
+        });
+      }
+      close(code, reason) {
+        if (this._readyState === WS_CLOSED || this._readyState === WS_CLOSING) {
+          return;
+        }
+        this._readyState = WS_CLOSING;
+        if (this.socketTask) {
+          this.socketTask.close({
+            code: code || 1e3,
+            reason: reason || "",
+            fail: (err) => {
+              console.error("WeChat WebSocket close failed:", err);
+            }
+          });
+        }
+      }
+    };
+    var AlipayWebSocketAdapter = class {
+      constructor(url) {
+        this._readyState = WS_CONNECTING;
+        this.boundOnOpen = null;
+        this.boundOnMessage = null;
+        this.boundOnError = null;
+        this.boundOnClose = null;
+        this.onopen = null;
+        this.onmessage = null;
+        this.onerror = null;
+        this.onclose = null;
+        if (typeof my === "undefined") {
+          throw new Error("Alipay Mini Program environment not detected");
+        }
+        this.boundOnOpen = (res) => {
+          this._readyState = WS_OPEN;
+          if (this.onopen) {
+            this.onopen(res);
+          }
+        };
+        this.boundOnMessage = (res) => {
+          if (this.onmessage) {
+            const data = res.data instanceof ArrayBuffer ? new TextDecoder().decode(res.data) : res.data;
+            this.onmessage({ data });
+          }
+        };
+        this.boundOnError = (res) => {
+          console.error("Alipay WebSocket error:", res);
+          if (this.onerror) {
+            this.onerror({ message: res.errorMessage || "WebSocket error" });
+          }
+        };
+        this.boundOnClose = (res) => {
+          this._readyState = WS_CLOSED;
+          this.cleanup();
+          if (this.onclose) {
+            this.onclose({ code: res.code || 1e3, reason: res.reason || "" });
+          }
+        };
+        my.onSocketOpen(this.boundOnOpen);
+        my.onSocketMessage(this.boundOnMessage);
+        my.onSocketError(this.boundOnError);
+        my.onSocketClose(this.boundOnClose);
+        my.connectSocket({
+          url,
+          success: () => {
+            console.log("Alipay WebSocket connecting...");
+          },
+          fail: (err) => {
+            console.error("Alipay WebSocket connection failed:", err);
+            this._readyState = WS_CLOSED;
+            this.cleanup();
+            if (this.onerror) {
+              this.onerror({ message: err.errorMessage || "Connection failed" });
+            }
+          }
+        });
+      }
+      get readyState() {
+        return this._readyState;
+      }
+      send(data) {
+        if (typeof my === "undefined") {
+          throw new Error("Alipay Mini Program environment not detected");
+        }
+        if (this._readyState !== WS_OPEN) {
+          throw new Error("WebSocket is not open");
+        }
+        my.sendSocketMessage({
+          data,
+          fail: (err) => {
+            console.error("Alipay WebSocket send failed:", err);
+            if (this.onerror) {
+              this.onerror({ message: "Send failed" });
+            }
+          }
+        });
+      }
+      close(code, reason) {
+        if (typeof my === "undefined") {
+          return;
+        }
+        if (this._readyState === WS_CLOSED || this._readyState === WS_CLOSING) {
+          return;
+        }
+        this._readyState = WS_CLOSING;
+        my.closeSocket({
+          code: code || 1e3,
+          reason: reason || "",
+          fail: (err) => {
+            console.error("Alipay WebSocket close failed:", err);
+          }
+        });
+      }
+      cleanup() {
+        if (typeof my !== "undefined") {
+          my.offSocketOpen(this.boundOnOpen);
+          my.offSocketMessage(this.boundOnMessage);
+          my.offSocketError(this.boundOnError);
+          my.offSocketClose(this.boundOnClose);
+          this.boundOnOpen = null;
+          this.boundOnMessage = null;
+          this.boundOnError = null;
+          this.boundOnClose = null;
+        }
+      }
+    };
+    var UniAppWebSocketAdapter = class {
+      constructor(url) {
+        this.socketTask = null;
+        this._readyState = WS_CONNECTING;
+        this.onopen = null;
+        this.onmessage = null;
+        this.onerror = null;
+        this.onclose = null;
+        if (typeof uni === "undefined") {
+          throw new Error("UniApp environment not detected");
+        }
+        this.socketTask = uni.connectSocket({
+          url,
+          success: () => {
+            console.log("UniApp WebSocket connecting...");
+          },
+          fail: (err) => {
+            console.error("UniApp WebSocket connection failed:", err);
+            this._readyState = WS_CLOSED;
+            if (this.onerror) {
+              this.onerror({ message: err.errMsg || "Connection failed" });
+            }
+          }
+        });
+        this.socketTask.onOpen((res) => {
+          this._readyState = WS_OPEN;
+          if (this.onopen) {
+            this.onopen(res);
+          }
+        });
+        this.socketTask.onMessage((res) => {
+          if (this.onmessage) {
+            const data = res.data instanceof ArrayBuffer ? new TextDecoder().decode(res.data) : res.data;
+            this.onmessage({ data });
+          }
+        });
+        this.socketTask.onError((res) => {
+          console.error("UniApp WebSocket error:", res);
+          if (this.onerror) {
+            this.onerror({ message: res.errMsg || "WebSocket error" });
+          }
+        });
+        this.socketTask.onClose((res) => {
+          this._readyState = WS_CLOSED;
+          if (this.onclose) {
+            this.onclose({ code: res.code || 1e3, reason: res.reason || "" });
+          }
+        });
+      }
+      get readyState() {
+        return this._readyState;
+      }
+      send(data) {
+        if (this._readyState !== WS_OPEN || !this.socketTask) {
+          throw new Error("WebSocket is not open");
+        }
+        this.socketTask.send({
+          data,
+          fail: (err) => {
+            console.error("UniApp WebSocket send failed:", err);
+            if (this.onerror) {
+              this.onerror({ message: "Send failed" });
+            }
+          }
+        });
+      }
+      close(code, reason) {
+        if (this._readyState === WS_CLOSED || this._readyState === WS_CLOSING) {
+          return;
+        }
+        this._readyState = WS_CLOSING;
+        if (this.socketTask) {
+          this.socketTask.close({
+            code: code || 1e3,
+            reason: reason || "",
+            fail: (err) => {
+              console.error("UniApp WebSocket close failed:", err);
+            }
+          });
+        }
+      }
+    };
+    function detectPlatform() {
+      if (typeof uni !== "undefined" && typeof uni.connectSocket === "function") {
+        return PlatformType.UniApp;
+      }
+      if (typeof wx !== "undefined" && typeof wx.connectSocket === "function") {
+        return PlatformType.WeChat;
+      }
+      if (typeof my !== "undefined" && typeof my.connectSocket === "function") {
+        return PlatformType.Alipay;
+      }
+      if (typeof WebSocket !== "undefined") {
+        return PlatformType.Browser;
+      }
+      return PlatformType.NodeJS;
     }
-    self._im = WKIM.init(wsAddr, { uid: opts.uid, token: opts.token || '' })
-    self._bindInternalEvents()
-    self._inited = true
-  })
-}
-
-WuKongIMService.prototype._bindInternalEvents = function () {
-  if (!this._im || this._bound) return
-  var self = this
-
-  this._hConnect = function (result) { self._emitStatus('connected', result) }
-  this._hDisconnect = function (info) { self._emitStatus('disconnected', info) }
-  this._hError = function (err) { self._emitStatus('error', err) }
-  this._hMessage = function (message) { self._emitMessage(message) }
-  this._hCustom = function (ev) { self._emitCustom(ev) }
-
-  this._im.on(WKIMEvent.Connect, this._hConnect)
-  this._im.on(WKIMEvent.Disconnect, this._hDisconnect)
-  this._im.on(WKIMEvent.Error, this._hError)
-  this._im.on(WKIMEvent.Message, this._hMessage)
-  this._im.on(WKIMEvent.CustomEvent, this._hCustom)
-  this._bound = true
-}
-
-WuKongIMService.prototype._unbindInternalEvents = function () {
-  if (!this._im || !this._bound) return
-  if (this._hConnect) this._im.off(WKIMEvent.Connect, this._hConnect)
-  if (this._hDisconnect) this._im.off(WKIMEvent.Disconnect, this._hDisconnect)
-  if (this._hError) this._im.off(WKIMEvent.Error, this._hError)
-  if (this._hMessage) this._im.off(WKIMEvent.Message, this._hMessage)
-  if (this._hCustom) this._im.off(WKIMEvent.CustomEvent, this._hCustom)
-  this._hConnect = this._hDisconnect = this._hError = this._hMessage = this._hCustom = null
-  this._bound = false
-}
-
-WuKongIMService.prototype._emitMessage = function (m) {
-  this._msgListeners.forEach(function (fn) { try { fn(m) } catch (e) {} })
-}
-
-WuKongIMService.prototype._emitStatus = function (s, info) {
-  this._statusListeners.forEach(function (fn) { try { fn(s, info) } catch (e) {} })
-}
-
-WuKongIMService.prototype._emitCustom = function (e) {
-  this._customListeners.forEach(function (fn) { try { fn(e) } catch (e2) {} })
-}
-
-WuKongIMService.prototype.onMessage = function (cb) {
-  this._msgListeners.push(cb)
-  var self = this
-  return function () {
-    var idx = self._msgListeners.indexOf(cb)
-    if (idx >= 0) self._msgListeners.splice(idx, 1)
-  }
-}
-
-WuKongIMService.prototype.onStatus = function (cb) {
-  this._statusListeners.push(cb)
-  var self = this
-  return function () {
-    var idx = self._statusListeners.indexOf(cb)
-    if (idx >= 0) self._statusListeners.splice(idx, 1)
-  }
-}
-
-WuKongIMService.prototype.onCustom = function (cb) {
-  this._customListeners.push(cb)
-  var self = this
-  return function () {
-    var idx = self._customListeners.indexOf(cb)
-    if (idx >= 0) self._customListeners.splice(idx, 1)
+    var currentPlatform = detectPlatform();
+    exports2.currentPlatform = currentPlatform;
+    function createWebSocket(url) {
+      switch (currentPlatform) {
+        case PlatformType.UniApp:
+          return new UniAppWebSocketAdapter(url);
+        case PlatformType.WeChat:
+          return new WeChatWebSocketAdapter(url);
+        case PlatformType.Alipay:
+          return new AlipayWebSocketAdapter(url);
+        case PlatformType.Browser:
+          return new WebSocket(url);
+        case PlatformType.NodeJS:
+        default:
+          try {
+            const dynamicRequire = new Function("mod", "return require(mod)");
+            const Ws = dynamicRequire("ws");
+            const WsImpl = Ws.WebSocket || Ws;
+            return new WsImpl(url);
+          } catch (e) {
+            throw new Error("WebSocket is not available in this environment. Install 'ws' package for Node.js.");
+          }
+      }
+    }
+    var ChannelType;
+    (function(ChannelType2) {
+      ChannelType2[ChannelType2["Person"] = 1] = "Person";
+      ChannelType2[ChannelType2["Group"] = 2] = "Group";
+      ChannelType2[ChannelType2["CustomerService"] = 3] = "CustomerService";
+      ChannelType2[ChannelType2["Community"] = 4] = "Community";
+      ChannelType2[ChannelType2["CommunityTopic"] = 5] = "CommunityTopic";
+      ChannelType2[ChannelType2["Info"] = 6] = "Info";
+      ChannelType2[ChannelType2["Data"] = 7] = "Data";
+      ChannelType2[ChannelType2["Temp"] = 8] = "Temp";
+      ChannelType2[ChannelType2["Live"] = 9] = "Live";
+      ChannelType2[ChannelType2["Visitors"] = 10] = "Visitors";
+    })(ChannelType || (exports2.WKIMChannelType = exports2.ChannelType = ChannelType = {}));
+    var Event;
+    (function(Event2) {
+      Event2["Connect"] = "connect";
+      Event2["Disconnect"] = "disconnect";
+      Event2["Message"] = "message";
+      Event2["Error"] = "error";
+      Event2["SendAck"] = "sendack";
+      Event2["Reconnecting"] = "reconnecting";
+      Event2["CustomEvent"] = "customevent";
+    })(Event || (exports2.WKIMEvent = exports2.Event = Event = {}));
+    var ReasonCode;
+    (function(ReasonCode2) {
+      ReasonCode2[ReasonCode2["Unknown"] = 0] = "Unknown";
+      ReasonCode2[ReasonCode2["Success"] = 1] = "Success";
+      ReasonCode2[ReasonCode2["AuthFail"] = 2] = "AuthFail";
+      ReasonCode2[ReasonCode2["SubscriberNotExist"] = 3] = "SubscriberNotExist";
+      ReasonCode2[ReasonCode2["InBlacklist"] = 4] = "InBlacklist";
+      ReasonCode2[ReasonCode2["ChannelNotExist"] = 5] = "ChannelNotExist";
+      ReasonCode2[ReasonCode2["UserNotOnNode"] = 6] = "UserNotOnNode";
+      ReasonCode2[ReasonCode2["SenderOffline"] = 7] = "SenderOffline";
+      ReasonCode2[ReasonCode2["MsgKeyError"] = 8] = "MsgKeyError";
+      ReasonCode2[ReasonCode2["PayloadDecodeError"] = 9] = "PayloadDecodeError";
+      ReasonCode2[ReasonCode2["ForwardSendPacketError"] = 10] = "ForwardSendPacketError";
+      ReasonCode2[ReasonCode2["NotAllowSend"] = 11] = "NotAllowSend";
+      ReasonCode2[ReasonCode2["ConnectKick"] = 12] = "ConnectKick";
+      ReasonCode2[ReasonCode2["NotInWhitelist"] = 13] = "NotInWhitelist";
+      ReasonCode2[ReasonCode2["QueryTokenError"] = 14] = "QueryTokenError";
+      ReasonCode2[ReasonCode2["SystemError"] = 15] = "SystemError";
+      ReasonCode2[ReasonCode2["ChannelIDError"] = 16] = "ChannelIDError";
+      ReasonCode2[ReasonCode2["NodeMatchError"] = 17] = "NodeMatchError";
+      ReasonCode2[ReasonCode2["NodeNotMatch"] = 18] = "NodeNotMatch";
+      ReasonCode2[ReasonCode2["Ban"] = 19] = "Ban";
+      ReasonCode2[ReasonCode2["NotSupportHeader"] = 20] = "NotSupportHeader";
+      ReasonCode2[ReasonCode2["ClientKeyIsEmpty"] = 21] = "ClientKeyIsEmpty";
+      ReasonCode2[ReasonCode2["RateLimit"] = 22] = "RateLimit";
+      ReasonCode2[ReasonCode2["NotSupportChannelType"] = 23] = "NotSupportChannelType";
+      ReasonCode2[ReasonCode2["Disband"] = 24] = "Disband";
+      ReasonCode2[ReasonCode2["SendBan"] = 25] = "SendBan";
+    })(ReasonCode || (exports2.ReasonCode = ReasonCode = {}));
+    var DeviceFlag;
+    (function(DeviceFlag2) {
+      DeviceFlag2[DeviceFlag2["App"] = 0] = "App";
+      DeviceFlag2[DeviceFlag2["Web"] = 1] = "Web";
+      DeviceFlag2[DeviceFlag2["Desktop"] = 2] = "Desktop";
+    })(DeviceFlag || (exports2.WKIMDeviceFlag = exports2.DeviceFlag = DeviceFlag = {}));
+    var WKIM2 = class _WKIM {
+      constructor(url, auth) {
+        this.ws = null;
+        this.isConnected = false;
+        this.connectionPromise = null;
+        this.pingInterval = null;
+        this.pingTimeout = null;
+        this.PING_INTERVAL_MS = 25 * 1e3;
+        this.PONG_TIMEOUT_MS = 10 * 1e3;
+        this.pendingRequests = /* @__PURE__ */ new Map();
+        this.eventListeners = /* @__PURE__ */ new Map();
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        this.initialReconnectDelay = 1e3;
+        this.isReconnecting = false;
+        this.manualDisconnect = false;
+        this.beforeUnloadHandler = null;
+        this.url = url;
+        this.auth = auth || {};
+        this.sessionId = this.generateUUID();
+        if (!this.auth.deviceId || this.auth.deviceId === "") {
+          this.auth.deviceId = `web_${this.sessionId.slice(0, 8)}_${Date.now()}`;
+        }
+        Object.values(Event).forEach((event) => this.eventListeners.set(event, []));
+        this.setupBeforeUnloadHandler();
+      }
+      /**
+       * Initializes the WKIM instance.
+       * @param url WebSocket server URL (e.g., "ws://localhost:5100")
+       * @param auth Authentication options { uid, token, ... }
+       * @param options Configuration options { singleton: boolean }
+       * @returns A WKIM instance
+       */
+      static init(url, auth, options = {}) {
+        if (!url || !auth || !auth.uid || !auth.token) {
+          throw new Error("URL, uid, and token are required for initialization.");
+        }
+        if (options.singleton && _WKIM.globalInstance) {
+          console.log("Destroying previous global instance...");
+          _WKIM.globalInstance.destroy();
+        }
+        const instance2 = new _WKIM(url, auth);
+        if (options.singleton !== false) {
+          _WKIM.globalInstance = instance2;
+        }
+        return instance2;
+      }
+      /**
+       * Establishes connection and authenticates with the server.
+       * Returns a Promise that resolves on successful connection/authentication,
+       * or rejects on failure.
+       */
+      connect() {
+        return new Promise((resolve, reject) => {
+          var _a;
+          if (this.isConnected || ((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WS_CONNECTING) {
+            console.warn("Connection already established or in progress.");
+            if (this.isConnected) {
+              resolve();
+            } else if (this.connectionPromise) {
+              this.connectionPromise.resolve = resolve;
+              this.connectionPromise.reject = reject;
+            } else {
+              reject(new Error("Already connecting, but no connection promise found."));
+            }
+            return;
+          }
+          this.manualDisconnect = false;
+          this.connectionPromise = { resolve, reject };
+          try {
+            console.log(`Connecting to ${this.url}... (Platform: ${currentPlatform})`);
+            this.ws = createWebSocket(this.url);
+            this.ws.onopen = () => {
+              console.log("WebSocket connection opened. Authenticating...");
+              this.sendConnectRequest();
+            };
+            this.ws.onmessage = (event) => {
+              this.handleMessage(event.data);
+            };
+            this.ws.onerror = (event) => {
+              const errorMessage = event.message || (event.error ? event.error.message : "WebSocket error");
+              console.error("WebSocket error:", errorMessage, event);
+              this.emit(Event.Error, event.error || new Error(errorMessage));
+            };
+            this.ws.onclose = (event) => {
+              const wasConnected = this.isConnected;
+              console.log(`WebSocket connection closed. Code: ${event.code}, Reason: ${event.reason}`);
+              if (this.connectionPromise && !this.isConnected) {
+                this.connectionPromise.reject(new Error(`Connection closed before authentication (Code: ${event.code})`));
+              }
+              this.cleanupConnection();
+              this.emit(Event.Disconnect, { code: event.code, reason: event.reason });
+              if (wasConnected && !this.manualDisconnect) {
+                this.tryReconnect();
+              }
+            };
+          } catch (error) {
+            console.error("Failed to create WebSocket:", error);
+            this.emit(Event.Error, error);
+            if (this.connectionPromise) {
+              this.connectionPromise.reject(error);
+              this.connectionPromise = null;
+            }
+            this.cleanupConnection();
+          }
+        });
+      }
+      /**
+       * Disconnects from the server.
+       */
+      disconnect() {
+        console.log("Manual disconnect initiated.");
+        this.manualDisconnect = true;
+        this.isReconnecting = false;
+        this.cleanupBeforeUnloadHandler();
+        this.handleDisconnect(true, "Manual disconnection");
+      }
+      /**
+       * Completely destroys the SDK instance, cleaning up all resources.
+       * Call this when you no longer need the SDK instance.
+       */
+      destroy() {
+        console.log("Destroying SDK instance...");
+        this.disconnect();
+        this.eventListeners.clear();
+        this.pendingRequests.clear();
+        if (_WKIM.globalInstance === this) {
+          _WKIM.globalInstance = null;
+        }
+      }
+      /**
+       * Sends a message to a specific channel.
+       * @param channelId Target channel ID
+       * @param channelType Target channel type (e.g., WKIM.ChannelType.Person)
+       * @param payload Message payload (must be a JSON-serializable object)
+       * @param options Optional: { clientMsgNo, header, setting, msgKey, expire, topic }
+       * @returns Promise resolving with { messageId, messageSeq } on server ack, or rejecting on error.
+       */
+      send(channelId, channelType, payload, options = {}) {
+        if (!this.isConnected || !this.ws || this.ws.readyState !== WS_OPEN) {
+          return Promise.reject(new Error("Not connected. Call connect() first."));
+        }
+        if (typeof payload !== "object" || payload === null) {
+          return Promise.reject(new Error("Payload must be a non-null object."));
+        }
+        const header = options.header || {};
+        header.redDot = true;
+        const clientMsgNo = options.clientMsgNo || this.generateUUID();
+        const params = {
+          clientMsgNo,
+          channelId,
+          channelType,
+          payload: this._encodePayloadToBase64(payload),
+          header,
+          topic: options.topic,
+          setting: options.setting
+        };
+        return this.sendRequest("send", params);
+      }
+      /**
+       * Registers an event listener.
+       * @param eventName The event to listen for (e.g., WKIM.Event.Message)
+       * @param callback The function to call when the event occurs
+       */
+      on(eventName, callback) {
+        var _a;
+        if (this.eventListeners.has(eventName)) {
+          (_a = this.eventListeners.get(eventName)) === null || _a === void 0 ? void 0 : _a.push(callback);
+        } else {
+          console.warn(`Attempted to register listener for unknown event: ${eventName}`);
+        }
+      }
+      /**
+      * Removes an event listener.
+      * @param eventName The event to stop listening for
+      * @param callback The specific callback function to remove
+      */
+      off(eventName, callback) {
+        if (this.eventListeners.has(eventName)) {
+          const listeners = this.eventListeners.get(eventName);
+          if (listeners) {
+            const index = listeners.indexOf(callback);
+            if (index > -1) {
+              listeners.splice(index, 1);
+            }
+          }
+        }
+      }
+      // --- Private Methods ---
+      emit(eventName, ...args) {
+        const listeners = this.eventListeners.get(eventName);
+        if (listeners) {
+          listeners.forEach((callback) => {
+            try {
+              callback(...args);
+            } catch (error) {
+              console.error(`Error in event listener for ${eventName}:`, error);
+            }
+          });
+        }
+      }
+      generateUUID() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+          const r = Math.random() * 16 | 0, v = c === "x" ? r : r & 3 | 8;
+          return v.toString(16);
+        });
+      }
+      sendConnectRequest() {
+        var _a;
+        const params = {
+          uid: this.auth.uid,
+          token: this.auth.token,
+          deviceId: this.auth.deviceId,
+          deviceFlag: (_a = this.auth.deviceFlag) !== null && _a !== void 0 ? _a : DeviceFlag.Web,
+          // Default to WEB
+          clientTimestamp: Date.now()
+          // Add version, clientKey if needed
+        };
+        this.sendRequest("connect", params, 5e3).then((result) => {
+          console.log("Authentication successful:", result);
+          this.isConnected = true;
+          this.reconnectAttempts = 0;
+          this.isReconnecting = false;
+          this.manualDisconnect = false;
+          this.startPing();
+          this.emit(Event.Connect, result);
+          if (this.connectionPromise) {
+            this.connectionPromise.resolve();
+            this.connectionPromise = null;
+          }
+        }).catch((error) => {
+          console.error("Authentication failed:", error);
+          this.emit(Event.Error, new Error(`Authentication failed: ${error.message || JSON.stringify(error)}`));
+          if (this.connectionPromise) {
+            this.connectionPromise.reject(error);
+            this.connectionPromise = null;
+          }
+          this.handleDisconnect(false, "Authentication failed");
+          this.cleanupConnection();
+        });
+      }
+      sendRequest(method, params, timeoutMs = 15e3) {
+        return new Promise((resolve, reject) => {
+          if (!this.ws || this.ws.readyState !== WS_OPEN) {
+            return reject(new Error("WebSocket is not open."));
+          }
+          const requestId = this.generateUUID();
+          const request = {
+            method,
+            params,
+            id: requestId
+          };
+          const timeoutTimer = setTimeout(() => {
+            this.pendingRequests.delete(requestId);
+            reject(new Error(`Request timeout for method ${method} (id: ${requestId})`));
+          }, timeoutMs);
+          this.pendingRequests.set(requestId, { resolve, reject, timeoutTimer });
+          try {
+            console.debug(`--> Sending request (id: ${requestId}):`, JSON.stringify(request));
+            this.ws.send(JSON.stringify(request));
+          } catch (error) {
+            clearTimeout(timeoutTimer);
+            this.pendingRequests.delete(requestId);
+            console.error(`Error sending request (id: ${requestId}):`, error);
+            reject(error);
+          }
+        });
+      }
+      sendNotification(method, params) {
+        if (!this.ws || this.ws.readyState !== WS_OPEN) {
+          console.error("Cannot send notification, WebSocket is not open.");
+          return;
+        }
+        const notification = {
+          method,
+          params
+        };
+        console.debug(`--> Sending notification:`, JSON.stringify(notification));
+        try {
+          this.ws.send(JSON.stringify(notification));
+        } catch (error) {
+          console.error(`Error sending notification (${method}):`, error);
+          this.emit(Event.Error, new Error(`Failed to send notification ${method}: ${error}`));
+        }
+      }
+      handleMessage(data) {
+        console.debug("<-- Received raw:", data);
+        let message;
+        try {
+          message = JSON.parse(data.toString());
+        } catch (error) {
+          console.error("Failed to parse incoming message:", error, data);
+          this.emit(Event.Error, new Error(`Failed to parse message: ${error}`));
+          return;
+        }
+        if ("id" in message) {
+          this.handleResponse(message);
+        } else if ("method" in message) {
+          this.handleNotification(message);
+        } else {
+          console.warn("Received unknown message format:", message);
+        }
+      }
+      handleResponse(response) {
+        console.debug(`<-- Handling response (id: ${response.id}):`, response);
+        const pending = this.pendingRequests.get(response.id);
+        if (pending) {
+          clearTimeout(pending.timeoutTimer);
+          this.pendingRequests.delete(response.id);
+          if (response.error) {
+            pending.reject(response.error);
+          } else {
+            pending.resolve(response.result);
+          }
+        } else {
+          console.warn(`Received response for unknown request ID: ${response.id}`);
+        }
+      }
+      handleNotification(notification) {
+        var _a, _b;
+        console.debug(`<-- Handling notification (${notification.method}):`, notification.params);
+        switch (notification.method) {
+          case "recv":
+            const messageData = notification.params;
+            if (typeof messageData.payload === "string") {
+              try {
+                messageData.payload = JSON.parse(this._decodeBase64ToStr(messageData.payload));
+              } catch (e) {
+              }
+            }
+            this.emit(Event.Message, messageData);
+            this.sendRecvAck(messageData.header, messageData.messageId, messageData.messageSeq);
+            break;
+          case "pong":
+            this.handlePong();
+            break;
+          case "disconnect":
+            console.warn("Server initiated disconnect:", notification.params);
+            this.emit(Event.Disconnect, notification.params);
+            this.handleDisconnect(false, `Server disconnected: ${((_a = notification.params) === null || _a === void 0 ? void 0 : _a.reason) || ((_b = notification.params) === null || _b === void 0 ? void 0 : _b.reasonCode)}`);
+            break;
+          case "event":
+            this.handleEventNotification(notification.params);
+            break;
+          // Handle other notifications if needed
+          default:
+            console.warn(`Received unhandled notification method: ${notification.method}`);
+        }
+      }
+      /**
+       * Encode payload object to base64 string.
+       * WuKongIM server expects payload as []byte (base64 in JSON).
+       */
+      _encodePayloadToBase64(payload) {
+        const json = JSON.stringify(payload);
+        if (typeof TextEncoder !== "undefined" && typeof btoa !== "undefined") {
+          const bytes = new TextEncoder().encode(json);
+          let binary = "";
+          for (let i = 0; i < bytes.length; i++) {
+            binary += String.fromCharCode(bytes[i]);
+          }
+          return btoa(binary);
+        }
+        if (typeof Buffer !== "undefined") {
+          return Buffer.from(json, "utf-8").toString("base64");
+        }
+        if (typeof wx !== "undefined" && (wx === null || wx === void 0 ? void 0 : wx.arrayBufferToBase64)) {
+          const encoder = new TextEncoder();
+          const bytes = encoder.encode(json);
+          return wx.arrayBufferToBase64(bytes.buffer);
+        }
+        throw new Error("No base64 encoding method available");
+      }
+      /**
+       * Decode base64 string to UTF-8 string.
+       */
+      _decodeBase64ToStr(base64Str) {
+        if (typeof atob !== "undefined" && typeof TextDecoder !== "undefined") {
+          const binary = atob(base64Str);
+          const bytes = new Uint8Array(binary.length);
+          for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+          }
+          return new TextDecoder().decode(bytes);
+        }
+        if (typeof Buffer !== "undefined") {
+          return Buffer.from(base64Str, "base64").toString("utf-8");
+        }
+        if (typeof wx !== "undefined" && (wx === null || wx === void 0 ? void 0 : wx.base64ToArrayBuffer)) {
+          const buf = wx.base64ToArrayBuffer(base64Str);
+          return new TextDecoder().decode(new Uint8Array(buf));
+        }
+        throw new Error("No base64 decoding method available");
+      }
+      sendRecvAck(header, messageId, messageSeq) {
+        const params = { header, messageId, messageSeq };
+        this.sendNotification("recvack", params);
+      }
+      /**
+       * Handles incoming event notifications from the server
+       * @param params Event notification parameters
+       */
+      handleEventNotification(params) {
+        try {
+          const eventData = {
+            header: params.header,
+            id: params.id,
+            type: params.type,
+            timestamp: params.timestamp,
+            data: params.data
+          };
+          if (!eventData.id || !eventData.type) {
+            console.error("Invalid event notification: missing required fields", params);
+            this.emit(Event.Error, new Error("Invalid event notification: missing required fields"));
+            return;
+          }
+          if (typeof eventData.data === "string") {
+            try {
+              eventData.data = JSON.parse(eventData.data);
+            } catch (e) {
+              console.debug("Event data is not JSON, keeping as string");
+            }
+          }
+          console.log(`Event notification received: type=${eventData.type}, id=${eventData.id}`);
+          this.emit(Event.CustomEvent, eventData);
+        } catch (error) {
+          console.error("Error handling event notification:", error);
+          this.emit(Event.Error, new Error(`Failed to handle event notification: ${error}`));
+        }
+      }
+      startPing() {
+        this.stopPing();
+        this.pingInterval = setInterval(() => {
+          if (this.ws && this.ws.readyState === WS_OPEN) {
+            this.sendRequest("ping", {}, this.PONG_TIMEOUT_MS).then(this.handlePong.bind(this)).catch((err) => {
+              console.error("Ping failed or timed out:", err);
+              this.emit(Event.Error, new Error(`Ping timeout: ${(err === null || err === void 0 ? void 0 : err.message) || err}`));
+              if (!this.manualDisconnect) {
+                this.handleDisconnect(false, "Ping timeout");
+                this.tryReconnect();
+              }
+            });
+          } else {
+            this.stopPing();
+          }
+        }, this.PING_INTERVAL_MS);
+        console.log(`Ping interval started (${this.PING_INTERVAL_MS}ms).`);
+      }
+      stopPing() {
+        if (this.pingInterval) {
+          clearInterval(this.pingInterval);
+          this.pingInterval = null;
+          console.log("Ping interval stopped.");
+        }
+        if (this.pingTimeout) {
+          clearTimeout(this.pingTimeout);
+          this.pingTimeout = null;
+        }
+      }
+      handlePong() {
+      }
+      handleDisconnect(graceful, reason) {
+        console.log(`Handling disconnect. Graceful: ${graceful}, Reason: ${reason}`);
+        if (this.ws) {
+          this.stopPing();
+          if (graceful && this.ws.readyState === WS_OPEN) {
+            this.ws.close(1e3, "Client disconnected");
+          } else if (this.ws.readyState === WS_CONNECTING || this.ws.readyState === WS_OPEN) {
+            this.ws.close(3001, reason.substring(0, 123));
+          }
+        }
+        this.cleanupConnection();
+      }
+      cleanupConnection() {
+        console.log("Cleaning up connection resources.");
+        this.isConnected = false;
+        this.stopPing();
+        this.pendingRequests.forEach((pending) => {
+          clearTimeout(pending.timeoutTimer);
+          pending.reject(new Error("Connection closed"));
+        });
+        this.pendingRequests.clear();
+        if (this.connectionPromise) {
+          if (!this.isReconnecting && !this.isConnected) {
+            this.connectionPromise.reject(new Error("Connection closed during operation"));
+          }
+          this.connectionPromise = null;
+        }
+        if (this.ws) {
+          this.ws.onopen = null;
+          this.ws.onmessage = null;
+          this.ws.onerror = null;
+          this.ws.onclose = null;
+        }
+      }
+      // --- Reconnection Methods ---
+      setupBeforeUnloadHandler() {
+        if (typeof window !== "undefined") {
+          this.beforeUnloadHandler = () => {
+            console.log("Page unloading, closing WebSocket connection...");
+            this.manualDisconnect = true;
+            this.isReconnecting = false;
+            if (this.ws && this.ws.readyState === WS_OPEN) {
+              this.ws.close(1e3, "Page unloaded");
+            }
+          };
+          window.addEventListener("beforeunload", this.beforeUnloadHandler);
+          window.addEventListener("pagehide", this.beforeUnloadHandler);
+        }
+      }
+      cleanupBeforeUnloadHandler() {
+        if (typeof window !== "undefined" && this.beforeUnloadHandler) {
+          window.removeEventListener("beforeunload", this.beforeUnloadHandler);
+          window.removeEventListener("pagehide", this.beforeUnloadHandler);
+          this.beforeUnloadHandler = null;
+        }
+      }
+      tryReconnect() {
+        if (this.isReconnecting || this.manualDisconnect) {
+          return;
+        }
+        this.isReconnecting = true;
+        this.scheduleReconnect();
+      }
+      scheduleReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+          console.error("Max reconnect attempts reached. Giving up.");
+          this.isReconnecting = false;
+          this.reconnectAttempts = 0;
+          this.emit(Event.Error, new Error("Reconnection failed."));
+          return;
+        }
+        const delay = this.initialReconnectDelay * Math.pow(2, this.reconnectAttempts);
+        this.reconnectAttempts++;
+        console.log(`Will attempt to reconnect in ${delay / 1e3}s (Attempt ${this.reconnectAttempts}).`);
+        this.emit(Event.Reconnecting, { attempt: this.reconnectAttempts, delay });
+        setTimeout(() => {
+          if (!this.isReconnecting) {
+            console.log("Reconnection aborted.");
+            return;
+          }
+          this.connect().catch(() => {
+            if (this.isReconnecting) {
+              this.scheduleReconnect();
+            }
+          });
+        }, delay);
+      }
+    };
+    exports2.WKIM = WKIM2;
+    WKIM2.globalInstance = null;
   }
-}
+});
 
-WuKongIMService.prototype.connect = function () {
-  if (!this._im) throw new Error('WuKongIMService not initialized')
-  this._emitStatus('connecting')
-  return this._im.connect()
+// miniprogram_dist/services/wukongim.js
+var WKIM = require_cjs().WKIM;
+var WKIMEvent = require_cjs().WKIMEvent;
+var adapter = require("../adapters/request");
+function WuKongIMService() {
+  this._inited = false;
+  this._im = null;
+  this._cfg = null;
+  this._uid = null;
+  this._bound = false;
+  this._hConnect = null;
+  this._hDisconnect = null;
+  this._hError = null;
+  this._hMessage = null;
+  this._hCustom = null;
+  this._msgListeners = [];
+  this._statusListeners = [];
+  this._customListeners = [];
 }
-
-WuKongIMService.prototype.disconnect = function () {
-  if (!this._im) return Promise.resolve()
-  if (typeof this._im.disconnect === 'function') {
-    try { return this._im.disconnect() } catch (e) { return Promise.resolve() }
+WuKongIMService.prototype.isReady = function() {
+  return this._inited && !!this._im && !!this._cfg;
+};
+WuKongIMService.prototype.getUid = function() {
+  return this._uid;
+};
+WuKongIMService.prototype.init = function(opts) {
+  var self = this;
+  this._cfg = Object.assign({}, opts, { channelType: opts.channelType || "person" });
+  this._uid = opts.uid;
+  return this._fetchRouteWsAddr(opts.apiBase, opts.uid, 1e4).then(function(wsAddr) {
+    if (self._im && self._bound) {
+      try {
+        self._unbindInternalEvents();
+      } catch (e) {
+      }
+    }
+    self._im = WKIM.init(wsAddr, { uid: opts.uid, token: opts.token || "" });
+    self._bindInternalEvents();
+    self._inited = true;
+  });
+};
+WuKongIMService.prototype._bindInternalEvents = function() {
+  if (!this._im || this._bound) return;
+  var self = this;
+  this._hConnect = function(result) {
+    self._emitStatus("connected", result);
+  };
+  this._hDisconnect = function(info) {
+    self._emitStatus("disconnected", info);
+  };
+  this._hError = function(err) {
+    self._emitStatus("error", err);
+  };
+  this._hMessage = function(message) {
+    self._emitMessage(message);
+  };
+  this._hCustom = function(ev) {
+    self._emitCustom(ev);
+  };
+  this._im.on(WKIMEvent.Connect, this._hConnect);
+  this._im.on(WKIMEvent.Disconnect, this._hDisconnect);
+  this._im.on(WKIMEvent.Error, this._hError);
+  this._im.on(WKIMEvent.Message, this._hMessage);
+  this._im.on(WKIMEvent.CustomEvent, this._hCustom);
+  this._bound = true;
+};
+WuKongIMService.prototype._unbindInternalEvents = function() {
+  if (!this._im || !this._bound) return;
+  if (this._hConnect) this._im.off(WKIMEvent.Connect, this._hConnect);
+  if (this._hDisconnect) this._im.off(WKIMEvent.Disconnect, this._hDisconnect);
+  if (this._hError) this._im.off(WKIMEvent.Error, this._hError);
+  if (this._hMessage) this._im.off(WKIMEvent.Message, this._hMessage);
+  if (this._hCustom) this._im.off(WKIMEvent.CustomEvent, this._hCustom);
+  this._hConnect = this._hDisconnect = this._hError = this._hMessage = this._hCustom = null;
+  this._bound = false;
+};
+WuKongIMService.prototype._emitMessage = function(m) {
+  this._msgListeners.forEach(function(fn) {
+    try {
+      fn(m);
+    } catch (e) {
+    }
+  });
+};
+WuKongIMService.prototype._emitStatus = function(s, info) {
+  this._statusListeners.forEach(function(fn) {
+    try {
+      fn(s, info);
+    } catch (e) {
+    }
+  });
+};
+WuKongIMService.prototype._emitCustom = function(e) {
+  this._customListeners.forEach(function(fn) {
+    try {
+      fn(e);
+    } catch (e2) {
+    }
+  });
+};
+WuKongIMService.prototype.onMessage = function(cb) {
+  this._msgListeners.push(cb);
+  var self = this;
+  return function() {
+    var idx = self._msgListeners.indexOf(cb);
+    if (idx >= 0) self._msgListeners.splice(idx, 1);
+  };
+};
+WuKongIMService.prototype.onStatus = function(cb) {
+  this._statusListeners.push(cb);
+  var self = this;
+  return function() {
+    var idx = self._statusListeners.indexOf(cb);
+    if (idx >= 0) self._statusListeners.splice(idx, 1);
+  };
+};
+WuKongIMService.prototype.onCustom = function(cb) {
+  this._customListeners.push(cb);
+  var self = this;
+  return function() {
+    var idx = self._customListeners.indexOf(cb);
+    if (idx >= 0) self._customListeners.splice(idx, 1);
+  };
+};
+WuKongIMService.prototype.connect = function() {
+  if (!this._im) throw new Error("WuKongIMService not initialized");
+  this._emitStatus("connecting");
+  return this._im.connect();
+};
+WuKongIMService.prototype.disconnect = function() {
+  if (!this._im) return Promise.resolve();
+  if (typeof this._im.disconnect === "function") {
+    try {
+      return this._im.disconnect();
+    } catch (e) {
+      return Promise.resolve();
+    }
   }
-  return Promise.resolve()
-}
-
-WuKongIMService.prototype._fetchRouteWsAddr = function (apiBase, uid, timeoutMs) {
-  var base = apiBase.endsWith('/') ? apiBase : apiBase + '/'
-  var url = base + 'v1/wukongim/route?uid=' + encodeURIComponent(uid)
-
+  return Promise.resolve();
+};
+WuKongIMService.prototype._fetchRouteWsAddr = function(apiBase, uid, timeoutMs) {
+  var base = apiBase.endsWith("/") ? apiBase : apiBase + "/";
+  var url = base + "v1/wukongim/route?uid=" + encodeURIComponent(uid);
   return adapter.request({
-    url: url,
-    method: 'GET',
-    timeout: timeoutMs || 10000
-  }).then(function (res) {
-    if (!res.ok) throw new Error('route HTTP ' + res.status)
-    return res.json().then(function (data) {
-      // Priority 1: wss_addr
-      if (data && data.wss_addr && typeof data.wss_addr === 'string' && data.wss_addr.trim()) {
-        return data.wss_addr.trim()
-      }
-      // Priority 2: ws_addr fallbacks
-      var addr = data.ws_addr || data.ws || data.ws_url || data.wsAddr || data.websocket
-      if (!addr && data.wss) addr = data.wss
-      if (!addr || typeof addr !== 'string') throw new Error('missing ws address')
-      var wsAddr = String(addr)
-      if (/^http(s)?:/i.test(wsAddr)) wsAddr = wsAddr.replace(/^http/i, 'ws')
-      return wsAddr
-    })
-  }).catch(function (e) {
-    var msg = e && e.message ? String(e.message) : String(e)
-    throw new Error('[WuKongIM] route fetch failed: ' + msg)
-  })
-}
-
-WuKongIMService.prototype.sendText = function (text, opts) {
-  if (!this._im || !this._cfg) throw new Error('WuKongIMService not ready')
-  opts = opts || {}
-  var to = opts.to || this._cfg.target
-  var payload = { type: 1, content: text }
+    url,
+    method: "GET",
+    timeout: timeoutMs || 1e4
+  }).then(function(res) {
+    if (!res.ok) throw new Error("route HTTP " + res.status);
+    return res.json().then(function(data) {
+      if (data && data.wss_addr && typeof data.wss_addr === "string" && data.wss_addr.trim()) {
+        return data.wss_addr.trim();
+      }
+      var addr = data.ws_addr || data.ws || data.ws_url || data.wsAddr || data.websocket;
+      if (!addr && data.wss) addr = data.wss;
+      if (!addr || typeof addr !== "string") throw new Error("missing ws address");
+      var wsAddr = String(addr);
+      if (/^http(s)?:/i.test(wsAddr)) wsAddr = wsAddr.replace(/^http/i, "ws");
+      return wsAddr;
+    });
+  }).catch(function(e) {
+    var msg = e && e.message ? String(e.message) : String(e);
+    throw new Error("[WuKongIM] route fetch failed: " + msg);
+  });
+};
+WuKongIMService.prototype.sendText = function(text, opts) {
+  if (!this._im || !this._cfg) throw new Error("WuKongIMService not ready");
+  opts = opts || {};
+  var to = opts.to || this._cfg.target;
+  var payload = { type: 1, content: text };
   return this._im.send(to, opts.channelType || 251, payload, {
     clientMsgNo: opts.clientMsgNo,
     header: opts.header
-  })
-}
-
-WuKongIMService.prototype.sendPayload = function (payload, opts) {
-  if (!this._im || !this._cfg) throw new Error('WuKongIMService not ready')
-  opts = opts || {}
-  var to = opts.to || this._cfg.target
+  });
+};
+WuKongIMService.prototype.sendPayload = function(payload, opts) {
+  if (!this._im || !this._cfg) throw new Error("WuKongIMService not ready");
+  opts = opts || {};
+  var to = opts.to || this._cfg.target;
   return this._im.send(to, opts.channelType || 251, payload, {
     clientMsgNo: opts.clientMsgNo,
     header: opts.header
-  })
-}
-
-// Singleton
-var instance = new WuKongIMService()
-
-module.exports = instance
+  });
+};
+var instance = new WuKongIMService();
+module.exports = instance;