@ethora/chat-component-rn 26.5.5 → 26.5.10

package/lib/module/networking/xmpp/sendTextMessage.xmpp.js.map

@@ -1 +1 @@
-{"version":3,"names":["xml","_sendTextSeq","toServiceXmlns","devServer","client","clientService","options","service","test","ds","trim","includes","replace","sendTextMessage","roomJID","firstName","lastName","photo","walletAddress","userMessage","notDisplayedValue","isReply","showInChannel","mainMessage","customId","id","Date","now","message","to","type","xmlns","senderFirstName","senderLastName","fullName","photoURL","senderJID","jid","toString","senderWalletAddress","roomJid","isSystemMessage","tokenAmount","quickReplies","push","sendResult","send","then","console","log","catch","err","error","name","stack"],"sourceRoot":"../../../../src","sources":["networking/xmpp/sendTextMessage.xmpp.ts"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["xml","_sendTextSeq","toServiceXmlns","devServer","client","clientService","options","service","test","ds","trim","includes","replace","sendTextMessage","roomJID","firstName","lastName","photo","walletAddress","userMessage","notDisplayedValue","isReply","showInChannel","mainMessage","customId","id","Date","now","dataXmlns","message","to","type","xmlns","senderFirstName","senderLastName","fullName","photoURL","senderJID","jid","toString","senderWalletAddress","roomJid","isSystemMessage","tokenAmount","quickReplies","push","sendResult","send","then","console","log","catch","err","error","name","stack"],"sourceRoot":"../../../../src","sources":["networking/xmpp/sendTextMessage.xmpp.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/networking/xmppClient.js

@@ -22,9 +22,27 @@ import { inviteRoomRequest } from './xmpp/inviteRoomRequest.xmpp';
 import { getRooms } from './xmpp/getRooms.xmpp';
 import { handleStanza } from './xmpp/handleStanzas.xmpp';
 import { pushLog as devPushLog } from '../utils/devLogger';
+import { normalizeRoomJid } from '../helpers/normalizeRoomJid';
+import { clearOutboundSends, enqueueOutboundSend, flushOutboundSends } from './outboundQueue';
 
 // Canonical production XMPP WSS endpoint (standard wss/443, no port suffix).
 const DEFAULT_DEV_SERVER = 'xmpp.chat.ethora.com';
+
+// @xmpp/client surfaces SASL/stream errors in a few shapes depending on
+// where it fails — XMPPError on stream:error, SASLError on SASL bind, or
+// a generic Error whose message contains "not-authorized". Match all of
+// them so we trigger the credentials refresh path consistently.
+function isNotAuthorizedError(err) {
+  if (!err) {
+    return false;
+  }
+  const condition = err?.condition || err?.name || err?.type || err?.error?.condition || '';
+  if (typeof condition === 'string' && condition.includes('not-authorized')) {
+    return true;
+  }
+  const message = (err?.message || err?.text || '').toString();
+  return /not-authorized|SASLError/i.test(message);
+}
 export class XmppClient {
   host = '';
   service = '';
@@ -34,7 +52,35 @@ export class XmppClient {
   reconnectAttempts = 0;
   maxReconnectAttempts = 5;
   reconnectDelay = 2000;
+  // Upper bound on the backoff delay. The old hard stop at
+  // maxReconnectAttempts gave up entirely after ~62s; now we keep retrying
+  // at a steady cadence on a long outage and just clamp the delay here.
+  maxReconnectDelay = 30000;
+  // Timestamp of the last forced reconnect so bursty external triggers
+  // (NetInfo + AppState + the provider watchdog firing together) can't
+  // spawn a reconnect storm.
+  lastReconnectAt = 0;
   suppressReconnect = false;
+  // Tracked so close()/disconnect() can cancel a pending reconnect —
+  // otherwise a scheduleReconnect() timer fires after logout and (until
+  // suppressReconnect short-circuits it) keeps the dead instance alive.
+  reconnectTimer = null;
+  // Single-flight guard for reconnect(). Multiple triggers can fire near-
+  // simultaneously (AppState 'active' + NetInfo restore + a scheduled
+  // timer). Without this, two overlapping reconnect()s each spawn a fresh
+  // underlying client and one is leaked with its `stanza` handler still
+  // bound → duplicate stanza dispatch into redux.
+  reconnecting = false;
+
+  // Set when SASL fails with `not-authorized` (typically a stale JWT-
+  // derived XMPP password after idle). Triggers the credentialsProvider
+  // refresh path in reconnect().
+  lastAuthError = null;
+  credentialsProvider = null;
+  credentialsRefreshInFlight = null;
+  // Fired by the provider on every 'online' so it can re-join MUC rooms
+  // after a reconnect (bug #21 — reconnected but not in the room).
+  onOnlineCallback = null;
 
   // ---- QoS state (mirrors web XmppClient) ----------------------------
   presencesReady = false;
@@ -53,6 +99,29 @@ export class XmppClient {
   checkOnline() {
     return this.client && this.client.status === 'online';
   }
+
+  /**
+   * Inject (or replace) the callback used by reconnect() to fetch fresh
+   * XMPP credentials after a `not-authorized` SASL failure. The provider
+   * is responsible for refreshing whatever upstream token is needed
+   * (REST JWT, /users/client, etc.) and returning the resulting
+   * username + password.
+   */
+  setCredentialsProvider(provider) {
+    this.credentialsProvider = provider;
+  }
+
+  /** Install a callback invoked on every successful 'online'. The provider
+   * uses it to re-join MUC rooms after a reconnect. */
+  setOnOnline(cb) {
+    this.onOnlineCallback = cb;
+  }
+
+  /** Swap in fresh credentials before the next reconnect. */
+  updateCredentials(username, password) {
+    this.username = username;
+    this.password = password;
+  }
   constructor(username, password, xmppSettings) {
     // Back-compat: third arg used to be a bare devServer string.
     if (typeof xmppSettings === 'string') {
@@ -206,11 +275,22 @@ export class XmppClient {
       this.host = this.xmppSettings?.host || url.match(/wss:\/\/([^:/]+)/)?.[1] || '';
       this.conference = this.xmppSettings?.conference || `conference.${this.host}`;
       this.status = 'connecting';
+
+      // Defensive: if a previous underlying client is still referenced
+      // (initializeClient reached from a path other than reconnect()),
+      // detach its handlers before we overwrite the ref so the orphaned
+      // client can't keep dispatching stanzas into redux.
+      try {
+        this.detachEventListeners();
+      } catch {}
       this.client = xmpp.client({
         service: url,
         username: walletToUsername(this.username),
         password: this.password
       });
+      try {
+        this.client?.reconnect?.stop?.();
+      } catch {}
 
       // Concurrent room preloads each register their own short-lived
       // 'stanza' handler (getHistory, getRooms, getChatsPrivateStore,
@@ -238,7 +318,18 @@ export class XmppClient {
               const to = stanza?.attrs?.to || '';
               devPushLog('xmpp', `→ ${tag}${id ? ` id=${id}` : ''}${to ? ` to=${to.split('/')[0]}` : ''}`, stanza?.toString ? stanza.toString() : undefined);
             } catch {}
-            return origSend(stanza);
+            const result = origSend(stanza);
+            // Most stanza helpers fire-and-forget `client.send(...)`
+            // without awaiting/catching. On @xmpp/client builds where
+            // send() returns a Promise, a transient send failure (e.g.
+            // mid-reconnect) then surfaces as a red-screen "Uncaught (in
+            // promise, id: N)" (#4). Attach a no-op catch so the
+            // rejection is considered handled — callers that DO await/
+            // catch still get it, because we return the SAME promise.
+            if (result && typeof result.catch === 'function') {
+              result.catch(() => {});
+            }
+            return result;
           };
           // Property may be non-writable on some builds; defineProperty
           // gives us a clearer error than a plain assignment.
@@ -254,15 +345,39 @@ export class XmppClient {
       this.attachEventListeners();
       this.client.start().catch(error => {
         console.error('Error starting xmpp client:', error);
+        if (isNotAuthorizedError(error)) {
+          this.lastAuthError = 'not-authorized';
+        }
         this.status = 'error';
+        // A connect-time failure lands in 'error', which — unlike a
+        // 'disconnect' after being online — has no other retry path
+        // (onError doesn't reschedule; the provider only reacts to
+        // 'offline'). Schedule a backoff retry so a failed initial or
+        // reconnect attempt recovers on its own. reconnect() refreshes
+        // creds first when the failure was a SASL not-authorized.
+        if (!this.suppressReconnect) {
+          try {
+            this.scheduleReconnect();
+          } catch {}
+        }
       });
     } catch (error) {
       console.error('Error initializing client:', error);
       this.status = 'error';
     }
   }
+
+  // Stored so detachEventListeners() can remove exactly the handlers we
+  // added (not xmpp.js's internal ones). Without this a re-login left the
+  // previous instance's `stanza` handler bound, double-dispatching every
+  // incoming stanza into the (new session's) redux store.
+
   attachEventListeners() {
-    this.client.on('disconnect', () => {
+    // Idempotent: drop any previously-attached handlers first so a
+    // reconnect that re-runs initializeClient on a fresh underlying
+    // client doesn't stack duplicates.
+    this.detachEventListeners();
+    this.onDisconnect = () => {
       console.log('XMPP disconnected.');
       this.status = 'offline';
       try {
@@ -270,8 +385,19 @@ export class XmppClient {
         // that don't reference it; tree-shaken via dead-code elim.
         devPushLog('xmpp', 'disconnect');
       } catch {}
-    });
-    this.client.on('online', () => {
+      // Self-heal at the socket level. The provider's reconnect effect
+      // keys on `client.status`, but that's a mutated class field React
+      // does NOT track — so a silent socket drop (e.g. JS paused by the
+      // debugger, iOS WebSocket suspend) never re-runs the effect and the
+      // client sits 'offline' forever (sends then queue and time out).
+      // Driving reconnect here makes recovery independent of React.
+      if (!this.suppressReconnect) {
+        try {
+          this.scheduleReconnect();
+        } catch {}
+      }
+    };
+    this.onOnline = () => {
       console.log('XMPP online.', new Date());
       this.status = 'online';
       this.presencesReady = true;
@@ -279,14 +405,39 @@ export class XmppClient {
       try {
         devPushLog('xmpp', 'online', this.username);
       } catch {}
-    });
-    this.client.on('error', error => {
+      // Notify the provider that the session is live again. On a RECONNECT
+      // (new stream) the client is no longer joined to any MUC, so the
+      // provider must re-send room presences — otherwise messages get a
+      // local double-tick but never reach the room (bug #21). Harmless on
+      // the first connect (room list not loaded yet → joins nothing; the
+      // bootstrap's own allRoomPresences handles that pass).
+      try {
+        this.onOnlineCallback?.();
+      } catch (err) {
+        console.warn('onOnline callback failed', err);
+      }
+      // Drain any sends that were buffered while the stream was down. The
+      // presence stanzas from onOnlineCallback above were written to the
+      // socket synchronously (allRoomPresences → presenceInRoom send the
+      // <presence> before yielding), so flushing here puts the message
+      // stanzas AFTER the joins on the same stream — XMPP's in-order
+      // per-stream processing guarantees the MUC join lands first.
+      try {
+        this.flushPendingSends();
+      } catch (err) {
+        console.warn('flushPendingSends failed', err);
+      }
+    };
+    this.onError = error => {
       console.error('XMPP client error:', error);
+      if (isNotAuthorizedError(error)) {
+        this.lastAuthError = 'not-authorized';
+      }
       try {
         devPushLog('xmpp', 'error', error && error.message || error);
       } catch {}
-    });
-    this.client.on('stanza', stanza => {
+    };
+    this.onStanza = stanza => {
       try {
         const tag = stanza?.name || 'stanza';
         const id = stanza?.attrs?.id || '';
@@ -295,7 +446,35 @@ export class XmppClient {
         devPushLog('xmpp', `← ${tag}${id ? ` id=${id}` : ''}${type ? ` type=${type}` : ''}${from ? ` from=${from.split('/')[0]}` : ''}`, stanza?.toString ? stanza.toString() : undefined);
       } catch {}
       handleStanza.bind(this, stanza, this)();
-    });
+    };
+    this.client.on('disconnect', this.onDisconnect);
+    this.client.on('online', this.onOnline);
+    this.client.on('error', this.onError);
+    this.client.on('stanza', this.onStanza);
+  }
+  detachEventListeners() {
+    const c = this.client;
+    if (!c?.removeListener) {
+      return;
+    }
+    try {
+      if (this.onDisconnect) {
+        c.removeListener('disconnect', this.onDisconnect);
+      }
+      if (this.onOnline) {
+        c.removeListener('online', this.onOnline);
+      }
+      if (this.onError) {
+        c.removeListener('error', this.onError);
+      }
+      if (this.onStanza) {
+        c.removeListener('stanza', this.onStanza);
+      }
+    } catch {}
+    this.onDisconnect = undefined;
+    this.onOnline = undefined;
+    this.onError = undefined;
+    this.onStanza = undefined;
   }
 
   /**
@@ -332,28 +511,133 @@ export class XmppClient {
     if (this.suppressReconnect) {
       return;
     }
-    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      console.error('Max reconnect attempts reached.');
+    if (this.reconnecting || this.reconnectTimer) {
       return;
     }
     this.reconnectAttempts++;
-    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+    const exp = Math.min(this.reconnectAttempts - 1, Math.max(0, this.maxReconnectAttempts));
+    const delay = Math.min(this.maxReconnectDelay, this.reconnectDelay * Math.pow(2, exp));
     console.log(`Reconnecting attempt ${this.reconnectAttempts} in ${delay}ms`);
-    setTimeout(() => this.reconnect(), delay);
+    // No clearTimeout needed — the guard above guarantees no pending timer.
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      // The connection may have recovered on its own (xmpp.js auto-
+      // reconnect) between scheduling and firing — don't tear down a
+      // healthy stream. forceReconnect() bypasses this by calling
+      // reconnect() directly.
+      if (this.status === 'online') {
+        this.reconnectAttempts = 0;
+        return;
+      }
+      this.reconnect();
+    }, delay);
   }
-  reconnect() {
+
+  /**
+   * Force an immediate reconnect, resetting the backoff counter. Called
+   * by the provider when NetInfo reports the network came back or the app
+   * returned to the foreground — we don't want to wait out the existing
+   * exponential delay (or a maxed-out attempt count) in those cases.
+   */
+  forceReconnect() {
+    if (this.suppressReconnect) {
+      return;
+    }
+    // Debounce bursts: NetInfo restore + AppState 'active' + the provider
+    // watchdog can fire within the same instant. reconnect() dedups
+    // CONCURRENT calls, but sequential ones (one finishes, the next
+    // arrives) would still each tear down + re-create the client. Ignore
+    // forces within 2s of the last one.
+    const now = Date.now();
+    if (now - this.lastReconnectAt < 2000) {
+      return;
+    }
+    this.lastReconnectAt = now;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.reconnectAttempts = 0;
+    this.reconnect();
+  }
+  async reconnect() {
     if (this.suppressReconnect) {
       return;
     }
+    // Single-flight: ignore overlapping triggers (AppState + NetInfo +
+    // scheduled timer) so we never spawn two underlying clients and leak
+    // one with live listeners (duplicate stanza dispatch).
+    if (this.reconnecting) {
+      console.log('reconnect already in progress — skip');
+      return;
+    }
+    this.reconnecting = true;
     console.log('Attempting to reconnect xmpp client...');
-    if (this.client) {
-      this.client.stop().finally(() => {
-        this.initializeClient();
-      });
-    } else {
+    try {
+      // If the last failure was a SASL `not-authorized` (typically a stale
+      // JWT-derived XMPP password after idle), try to fetch fresh creds
+      // before retrying. Without this, reconnect retries with the same
+      // stale password forever and the user has to kill the app.
+      if (this.lastAuthError === 'not-authorized' && this.credentialsProvider) {
+        try {
+          await this.refreshCredentialsOnce();
+        } catch (err) {
+          console.warn('XMPP credential refresh failed; reconnecting with cached creds', err);
+        }
+      }
+
+      // Tear the OLD underlying client down FULLY before spinning up a new
+      // one: detach our handlers (so its `stanza` handler can't keep
+      // dispatching) and stop it. detachEventListeners() must run while
+      // `this.client` still points at the old client — i.e. before
+      // initializeClient() reassigns it.
+      const old = this.client;
+      if (old) {
+        this.detachEventListeners();
+        try {
+          await old.stop();
+        } catch {}
+      }
       this.initializeClient();
+    } finally {
+      this.reconnecting = false;
     }
   }
+
+  /**
+   * Single-flight wrapper around credentialsProvider. Multiple concurrent
+   * reconnect() calls (e.g. from the provider's reconnect effect firing
+   * twice quickly) share one in-flight request and update `this.password`
+   * exactly once.
+   */
+  refreshCredentialsOnce() {
+    if (this.credentialsRefreshInFlight) {
+      return this.credentialsRefreshInFlight;
+    }
+    if (!this.credentialsProvider) {
+      return Promise.resolve();
+    }
+    const provider = this.credentialsProvider;
+    this.credentialsRefreshInFlight = (async () => {
+      try {
+        const fresh = await provider();
+        if (fresh?.username && fresh?.password) {
+          // Apply whatever the provider returns and retry. We do NOT try to
+          // detect "auth expired" by comparing passwords — a stable
+          // xmppPassword (e.g. deterministic from the JWT/wallet) is the
+          // NORMAL case for a transient blip, and treating it as expiry
+          // falsely bricked recoverable sessions (sending stopped). If the
+          // creds really are stale we simply get not-authorized again and
+          // retry, which is the confirmed-good 26.5.7 behaviour.
+          this.updateCredentials(fresh.username, fresh.password);
+          this.lastAuthError = null;
+        }
+      } finally {
+        this.credentialsRefreshInFlight = null;
+      }
+    })();
+    return this.credentialsRefreshInFlight;
+  }
   async disconnect(options) {
     if (options?.suppressReconnect) {
       this.suppressReconnect = true;
@@ -361,7 +645,17 @@ export class XmppClient {
     return this.close();
   }
   async close() {
+    // Cancel any pending reconnect so a stale timer can't resurrect this
+    // instance after teardown/logout.
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
     if (this.client) {
+      // Detach OUR handlers first so a late stanza during the close
+      // handshake can't re-enter handleStanza and dispatch into a store
+      // that's being wiped (or, on re-login, the new session's store).
+      this.detachEventListeners();
       try {
         await this.client.stop();
         console.log('XMPP client connection closed.');
@@ -370,6 +664,11 @@ export class XmppClient {
       }
     }
     this.status = 'offline';
+    this.presencesReady = false;
+    // Permanent teardown (logout / unmount) — drop buffered sends so they
+    // don't replay into the next session. Reconnect uses old.stop(), NOT
+    // close(), so the queue still survives a transient drop+reconnect.
+    clearOutboundSends();
   }
   getRoomsStanza = async () => {
     await getRooms(this.client);
@@ -384,10 +683,10 @@ export class XmppClient {
     await inviteRoomRequest(this.client, to, roomJid);
   }
   leaveTheRoomStanza = roomJID => {
-    leaveTheRoom(roomJID, this.client);
+    leaveTheRoom(normalizeRoomJid(roomJID, this.conference), this.client);
   };
   presenceInRoomStanza = roomJID => {
-    presenceInRoom(this.client, roomJID);
+    presenceInRoom(this.client, normalizeRoomJid(roomJID, this.conference));
   };
   getHistoryStanza = async (chatJID, max, before, id, options) => {
     if (options?.coalesceRoom) {
@@ -402,21 +701,49 @@ export class XmppClient {
     return await getHistory(this.client, chatJID, max, before, id);
   };
   getLastMessageArchiveStanza(roomJID) {
-    getLastMessage(this.client, roomJID);
+    getLastMessage(this.client, normalizeRoomJid(roomJID, this.conference));
   }
   setRoomImageStanza = (roomJid, roomThumbnail, type, roomBackground) => {
     setRoomImage(roomJid, roomThumbnail, type, this.client, roomBackground);
   };
   getRoomInfoStanza = roomJID => {
-    getRoomInfo(roomJID, this.client);
+    getRoomInfo(normalizeRoomJid(roomJID, this.conference), this.client);
   };
   getRoomMembersStanza = roomJID => {
-    getRoomMembers(roomJID, this.client);
+    getRoomMembers(normalizeRoomJid(roomJID, this.conference), this.client);
   };
 
+  /**
+   * True when the underlying stream is live enough to actually put a
+   * stanza on the wire. Used to gate sends: when false we buffer instead
+   * of firing a fire-and-forget stanza into a dead/half-open socket
+   * (which is silently dropped and only caught by the 30s watchdog).
+   */
+  isStreamReady() {
+    return !!this.client && this.status === 'online' && !this.reconnecting;
+  }
+
+  /** Replay buffered sends against this (now-online) client, in order. */
+  flushPendingSends() {
+    flushOutboundSends(this, Date.now());
+  }
+
   //messages
   sendMessage = (roomJID, firstName, lastName, photo, walletAddress, userMessage, notDisplayedValue, isReply, showInChannel, mainMessage, customId) => {
+    // Stream down (start race / reconnect window): buffer and replay on
+    // the next 'online' instead of losing the stanza. Returns false so
+    // callers know the send was deferred, not delivered.
+    if (!this.isStreamReady()) {
+      enqueueOutboundSend({
+        optimisticId: customId || `send-text-message-${Date.now()}`,
+        roomJID,
+        enqueuedAt: Date.now(),
+        send: c => c.sendMessage(roomJID, firstName, lastName, photo, walletAddress, userMessage, notDisplayedValue, isReply, showInChannel, mainMessage, customId)
+      });
+      return false;
+    }
     sendTextMessage(this.client, roomJID, firstName, lastName, photo, walletAddress, userMessage, notDisplayedValue, isReply, showInChannel, mainMessage, this.devServer || DEFAULT_DEV_SERVER, customId);
+    return true;
   };
   deleteMessageStanza(room, msgId) {
     deleteMessage(this.client, room, msgId);
@@ -461,6 +788,19 @@ export class XmppClient {
     }
   }
   sendMediaMessageStanza(roomJID, data, customId) {
+    // Media: the file is already uploaded by the time we get here; only the
+    // stanza needs the stream. Buffer + replay on reconnect if it's down so
+    // the upload isn't wasted (otherwise the stanza is lost and the media
+    // bubble sits pending until the 30s watchdog fails it).
+    if (!this.isStreamReady()) {
+      enqueueOutboundSend({
+        optimisticId: customId || `send-media-message-${Date.now()}`,
+        roomJID,
+        enqueuedAt: Date.now(),
+        send: c => c.sendMediaMessageStanza(roomJID, data, customId)
+      });
+      return undefined;
+    }
     return sendMediaMessage(this.client, roomJID, data, customId, this.devServer || DEFAULT_DEV_SERVER);
   }
 
@@ -482,9 +822,14 @@ export class XmppClient {
   sendMessageReactionStanza(_messageId, _roomJid, _reactionsList, _reactionSymbol) {
     console.warn('sendMessageReactionStanza: not implemented in RN xmpp client');
   }
-  sendTextMessageWithTranslateTagStanza(roomJID, firstName, lastName, photo, walletAddress, userMessage, notDisplayedValue, isReply, showInChannel, mainMessage, _langSource) {
+  sendTextMessageWithTranslateTagStanza(roomJID, firstName, lastName, photo, walletAddress, userMessage, notDisplayedValue, isReply, showInChannel, mainMessage, _langSource, customId) {
     // No translate tag support yet — fall back to a regular text send.
-    this.sendMessage(roomJID, firstName, lastName, photo, walletAddress, userMessage, notDisplayedValue, isReply, showInChannel, mainMessage);
+    // Forward the caller's customId so the optimistic message (heap/redux)
+    // reconciles with the server echo. Without it, translated sends went
+    // out with no client id → the echo carried a server-assigned id and
+    // surfaced as a stuck-pending message PLUS a duplicate (affected both
+    // the live translated-send path and resend).
+    this.sendMessage(roomJID, firstName, lastName, photo, walletAddress, userMessage, notDisplayedValue, isReply, showInChannel, mainMessage, customId);
   }
 }
 export default XmppClient;