@ethora/chat-component-rn 26.8.5 → 26.8.6

package/src/networking/xmpp/presenceInRoom.xmpp.ts

@@ -6,10 +6,44 @@ let presenceIdCounter = 0;
 const nextPresenceId = () =>
   `presenceInRoom-${Date.now().toString(36)}-${(++presenceIdCounter).toString(36)}`;
 
-export const presenceInRoom = async (
+const joinedByClient = new WeakMap<Client, Map<string, Promise<Element>>>();
+
+const joinedRooms = (client: Client): Map<string, Promise<Element>> => {
+  let map = joinedByClient.get(client);
+  if (!map) {
+    map = new Map();
+    joinedByClient.set(client, map);
+    const forget = () => joinedByClient.get(client)?.clear();
+    client.on('disconnect', forget);
+    client.on('offline', forget);
+  }
+  return map;
+};
+
+export const __forgetJoinedRooms = (client: Client) =>
+  joinedByClient.get(client)?.clear();
+
+export const presenceInRoom = (
+  client: Client,
+  roomJID: string,
+  delay = 0
+): Promise<Element> => {
+  const joined = joinedRooms(client);
+  const existing = joined.get(roomJID);
+  if (existing) {return existing;}
+  const join = joinRoom(client, roomJID, delay);
+  joined.set(roomJID, join);
+  // A failed join is not a join: let the next caller try again.
+  join.catch(() => {
+    if (joined.get(roomJID) === join) {joined.delete(roomJID);}
+  });
+  return join;
+};
+
+const joinRoom = async (
   client: Client,
   roomJID: string,
-  delay = 2000
+  delay: number
 ): Promise<Element> => {
   let stanzaHandler: (stanza: Element) => void;
   const unsubscribe = () => client.off('stanza', stanzaHandler);
@@ -27,6 +61,11 @@ export const presenceInRoom = async (
       if (settled) {return;}
       settled = true;
 
+      if (delay <= 0) {
+        unsubscribe();
+        cb(value);
+        return;
+      }
       setTimeout(() => {
         unsubscribe();
         cb(value);
@@ -52,7 +91,11 @@ export const presenceInRoom = async (
         to: `${roomJID}/${client.jid?.getLocal()}`,
         id: stanzaId,
       },
-      xml('x', { xmlns: 'http://jabber.org/protocol/muc' })
+      xml(
+        'x',
+        { xmlns: 'http://jabber.org/protocol/muc' },
+        xml('history', { maxstanzas: '0' })
+      )
     );
 
     // Side-effects sequence: send the presence (handles its own

package/src/networking/xmppClient.ts

@@ -10,6 +10,7 @@ import { sendTypingRequest } from './xmpp/sendTypingRequest.xmpp';
 import { sendPing } from './xmpp/sendPing.xmpp';
 import { getHistory } from './xmpp/getHistory.xmpp';
 import { sendTextMessage } from './xmpp/sendTextMessage.xmpp';
+import { sendMessageReaction } from './xmpp/sendMessageReaction.xmpp';
 import { sendTextMessageWithTranslateTag } from './xmpp/sendTextMessageWithTranslateTag.xmpp';
 import { deleteMessage } from './xmpp/deleteMessage.xmpp';
 import { presenceInRoom } from './xmpp/presenceInRoom.xmpp';
@@ -23,7 +24,7 @@ import { editMessage } from './xmpp/editMessage.xmpp';
 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 { pushLog as devPushLog, isDevLogActive } from '../utils/devLogger';
 import { normalizeRoomJid } from '../helpers/normalizeRoomJid';
 import { store } from '../roomStore';
 import { applyPrivateStoreMarkers } from '../roomStore/roomsSlice';
@@ -69,6 +70,11 @@ function withTimeout(promise: Promise<unknown>, ms: number): Promise<void> {
 // 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.
+// Failed XMPP-password recoveries in a row before the session is ended.
+const AUTH_RECOVERY_MAX_FAILURES = 2;
+// Rejections (each with a fresh password) before the password counts as lost.
+const AUTH_REJECTIONS_LIMIT = 3;
+
 function isNotAuthorizedError(err: any): boolean {
   if (!err) {return false;}
   const condition =
@@ -90,6 +96,10 @@ interface HistoryOptions {
   coalesceRoom?: boolean;
   skipIfPreloaded?: boolean;
   source?: HistorySource;
+  /** The caller merges the returned page into the store itself (the
+   * preload scheduler and the catch-up pass do, to detect gaps); the MAM
+   * router then does not apply it. Default: applied by the router. */
+  selfApplied?: boolean;
 }
 
 interface MamInFlightEntry {
@@ -185,6 +195,42 @@ export class XmppClient {
    * (REST JWT, /users/client, etc.) and returning the resulting
    * username + password.
    */
+  /**
+   * Called once when the session's XMPP password is lost for good: the
+   * server rejected it (SASL not-authorized) and the refresh chain could
+   * not produce a working one — the refresh request failed, came back
+   * without a new password, or the new one was rejected too. Network
+   * outages never get here (no rejection without a reachable server).
+   */
+  private authLostHandler: (() => void) | null = null;
+  private authRecoveryFailures = 0;
+  private authLostFired = false;
+  // Rejections since the stream was last online — catches a refresh that
+  // keeps returning NEW passwords the server still rejects.
+  private authRejectionsSinceOnline = 0;
+
+  setAuthLostHandler(handler: (() => void) | null) {
+    this.authLostHandler = handler;
+  }
+
+  private markAuthRecoveryFailed(reason: string) {
+    this.authRecoveryFailures += 1;
+    console.warn(
+      `[xmpp] XMPP password recovery failed (${reason}), attempt ${this.authRecoveryFailures}`
+    );
+    // One retry before giving up, so a single REST hiccup does not end the
+    // session; a second failure in a row means the password is gone.
+    if (this.authRecoveryFailures >= AUTH_RECOVERY_MAX_FAILURES && !this.authLostFired) {
+      this.authLostFired = true;
+      this.suppressReconnect = true;
+      try {
+        this.authLostHandler?.();
+      } catch (e) {
+        console.warn('[xmpp] auth-lost handler threw', e);
+      }
+    }
+  }
+
   setCredentialsProvider(provider: XmppCredentialsProvider | null) {
     this.credentialsProvider = provider;
   }
@@ -286,8 +332,9 @@ export class XmppClient {
     before?: number;
     id?: string;
     source?: HistorySource;
+    selfApplied?: boolean;
   }): Promise<any> {
-    const { chatJID, max, before, id, source = 'default' } = params;
+    const { chatJID, max, before, id, source = 'default', selfApplied } = params;
 
     // Coalesce — if a fetch for the same room is in-flight, reuse it
     // unless the new request is higher priority.
@@ -315,7 +362,9 @@ export class XmppClient {
     const handle: { p?: Promise<any> } = {};
     handle.p = (async () => {
       try {
-        return await getHistory(this.client, chatJID, max, before, id);
+        return await getHistory(this.client, chatJID, max, before, id, {
+          selfApplied,
+        });
       } finally {
         const cur = this.mamInFlightByRoom.get(chatJID);
         if (cur && cur.promise === handle.p) {
@@ -383,7 +432,7 @@ export class XmppClient {
       // Raising the cap silences the warning without masking real leaks
       // — true leaks would still grow unboundedly past this number.
       try {
-        (this.client as any)?.setMaxListeners?.(50);
+        (this.client as any)?.setMaxListeners?.(120);
       } catch {}
 
       // Wrap `send` so the dev logger sees outgoing stanzas too.
@@ -395,7 +444,7 @@ export class XmppClient {
         const origSend = this.client.send?.bind(this.client);
         if (origSend) {
           const wrapped = (stanza: any) => {
-            try {
+            if (isDevLogActive()) {try {
               const tag = stanza?.name || 'stanza';
               const id = stanza?.attrs?.id || '';
               const to = stanza?.attrs?.to || '';
@@ -404,7 +453,7 @@ export class XmppClient {
                 `→ ${tag}${id ? ` id=${id}` : ''}${to ? ` to=${to.split('/')[0]}` : ''}`,
                 stanza?.toString ? stanza.toString() : undefined
               );
-            } catch {}
+            } catch {}}
             const result = origSend(stanza);
             // Most stanza helpers fire-and-forget `client.send(...)`
             // without awaiting/catching. On @xmpp/client builds where
@@ -438,6 +487,7 @@ export class XmppClient {
         console.error('Error starting xmpp client:', error);
         if (isNotAuthorizedError(error)) {
           this.lastAuthError = 'not-authorized';
+          this.authRejectionsSinceOnline += 1;
         }
         this.status = 'error';
         // A connect-time failure lands in 'error', which — unlike a
@@ -497,6 +547,8 @@ export class XmppClient {
     this.onOnline = () => {
       console.log('XMPP online.', new Date());
       this.status = 'online';
+      this.authRecoveryFailures = 0;
+      this.authRejectionsSinceOnline = 0;
       this.presencesReady = true;
       this.reconnectAttempts = 0;
       try {
@@ -534,6 +586,7 @@ export class XmppClient {
       console.error('XMPP client error:', error);
       if (isNotAuthorizedError(error)) {
         this.lastAuthError = 'not-authorized';
+        this.authRejectionsSinceOnline += 1;
       }
       try {
         devPushLog(
@@ -545,7 +598,7 @@ export class XmppClient {
     };
 
     this.onStanza = (stanza: any) => {
-      try {
+      if (isDevLogActive()) {try {
         const tag = stanza?.name || 'stanza';
         const id = stanza?.attrs?.id || '';
         const from = stanza?.attrs?.from || '';
@@ -555,7 +608,7 @@ export class XmppClient {
           `← ${tag}${id ? ` id=${id}` : ''}${type ? ` type=${type}` : ''}${from ? ` from=${from.split('/')[0]}` : ''}`,
           stanza?.toString ? stanza.toString() : undefined
         );
-      } catch {}
+      } catch {}}
       handleStanza.bind(this, stanza, this)();
     };
 
@@ -739,16 +792,29 @@ export class XmppClient {
         CREDENTIALS_REFRESH_MIN_INTERVAL_MS;
 
       if (this.credentialsProvider && (authFailed || staleCreds)) {
+        const rejectedPassword = authFailed ? this.password : null;
         try {
           await this.refreshCredentialsOnce();
+          // The server said this password is wrong and the refresh handed
+          // back nothing new: there is no working password to connect with.
+          if (rejectedPassword !== null && (!this.password || this.password === rejectedPassword)) {
+            this.markAuthRecoveryFailed('no new XMPP password after refresh');
+          } else if (this.authRejectionsSinceOnline >= AUTH_REJECTIONS_LIMIT) {
+            this.markAuthRecoveryFailed('refreshed XMPP password rejected again');
+          }
         } catch (err) {
-          // Offline is the common case here — reconnect with what we
-          // have and let the next attempt try again.
-          console.warn(
-            'XMPP credential refresh failed; reconnecting with cached creds',
-            err
-          );
+          if (rejectedPassword !== null) {
+            this.markAuthRecoveryFailed('refresh request failed');
+          } else {
+            // Offline is the common case here — reconnect with what we
+            // have and let the next attempt try again.
+            console.warn(
+              'XMPP credential refresh failed; reconnecting with cached creds',
+              err
+            );
+          }
         }
+        if (this.suppressReconnect) {return;}
       }
 
       // Tear the OLD underlying client down FULLY before spinning up a new
@@ -903,6 +969,16 @@ export class XmppClient {
   }
 
   getRoomsStanza = async () => {
+    // Asked while the socket is down (mid-reconnect) this used to throw
+    // "Cannot read property 'write' of null". Wait for the stream instead;
+    // if it does not come back, skip — the reconnect hook re-syncs rooms.
+    if (this.status !== 'online') {
+      try {
+        await this.waitForOnline(15000);
+      } catch {
+        return;
+      }
+    }
     await getRooms(this.client);
   };
 
@@ -938,9 +1014,12 @@ export class XmppClient {
         before,
         id,
         source: options?.source || 'default',
+        selfApplied: options?.selfApplied,
       });
     }
-    return await getHistory(this.client, chatJID, max, before, id);
+    return await getHistory(this.client, chatJID, max, before, id, {
+      selfApplied: options?.selfApplied,
+    });
   };
 
   getLastMessageArchiveStanza(roomJID: string) {
@@ -1194,12 +1273,18 @@ export class XmppClient {
   }
 
   sendMessageReactionStanza(
-    _messageId: string,
-    _roomJid: string,
-    _reactionsList: string[],
-    _reactionSymbol?: string
+    messageId: string,
+    roomJid: string,
+    reactionsList: string[],
+    data?: { firstName?: string; lastName?: string }
   ) {
-    console.warn('sendMessageReactionStanza: not implemented in RN xmpp client');
+    sendMessageReaction(
+      this.client,
+      messageId,
+      normalizeRoomJid(roomJid, this.conference),
+      reactionsList,
+      data || {}
+    );
   }
 
   // Sends a groupchat message carrying a `<translate source="xx"/>` tag so

package/src/roomStore/Middleware/newMessageMidlleware.tsx

@@ -1,8 +1,7 @@
 import { Middleware } from '@reduxjs/toolkit';
-import { updateRoom } from '../roomsSlice';
 import { clearMessageFailure } from '../roomHeapSlice';
 import { removeOutboundSend } from '../../networking/outboundQueue';
-import { IRoom } from '../../types/types';
+import { IMessage } from '../../types/types';
 
 export const newMessageMidlleware: Middleware =
   (storeAPI) => (next) => (action: any) => {
@@ -11,7 +10,9 @@ export const newMessageMidlleware: Middleware =
       return next(action);
     }
 
-    if (action.type !== 'roomMessages/addRoomMessage') {
+    const isSingle = action.type === 'roomMessages/addRoomMessage';
+    const isBatch = action.type === 'roomMessages/addRoomMessages';
+    if (!isSingle && !isBatch) {
       return next(action);
     }
 
@@ -22,48 +23,44 @@ export const newMessageMidlleware: Middleware =
 
     const result = next(action);
     const state = storeAPI.getState();
-    const rooms: { [jid: string]: IRoom } = state.rooms.rooms;
-
-    const { roomJID, message } = action.payload;
-
-    // Un-fail on confirmed delivery. A server-confirmed copy (echo or MAM
-    // history, never `pending`) arriving for a message we'd flagged failed
-    // means the send actually went through — e.g. a slow send that completed
-    // just after the 5s watchdog window, or a queued auto-resend landing on
-    // reconnect. The failed flag is keyed by our optimistic/stanza id, which
-    // the echo carries back as `id`/`xmppId`, so clear it here and let the
-    // bubble flip to delivered instead of staying stuck on "Failed".
-    if (message && !message.pending) {
-      // The confirmed copy carries our optimistic/stanza id back as id/xmppId.
-      // Drop any still-buffered replay for it so a later reconnect flush can't
-      // re-send an already-delivered message.
-      removeOutboundSend(message.id);
-      removeOutboundSend(message.xmppId);
-
-      const failedMap = state.roomHeapSlice?.failedMessages || {};
-      const failedKey = [message.id, message.xmppId].find(
-        (k: string | undefined) => k && failedMap[k]
-      );
-      if (failedKey) {
-        storeAPI.dispatch(clearMessageFailure(failedKey as string));
-      }
-    }
 
-    if ((rooms[roomJID]?.lastMessageTimestamp ?? 0) <= Number(message.id)) {
-      storeAPI.dispatch(
-        updateRoom({
-          jid: roomJID,
-          updates: { lastMessageTimestamp: Number(message.id) ?? 0 },
-        })
-      );
+    // `lastMessageTimestamp` is now bumped inside the reducer itself (no
+    // second `updateRoom` pass per message). What is left here are the
+    // side effects outside the rooms slice.
+    const messages: IMessage[] = isBatch
+      ? action.payload.messages || []
+      : [action.payload.message];
+    const failedMap = state.roomHeapSlice?.failedMessages || {};
+
+    for (const message of messages) {
+      // Un-fail on confirmed delivery. A server-confirmed copy (echo or MAM
+      // history, never `pending`) arriving for a message we'd flagged failed
+      // means the send actually went through — e.g. a slow send that completed
+      // just after the 5s watchdog window, or a queued auto-resend landing on
+      // reconnect. The failed flag is keyed by our optimistic/stanza id, which
+      // the echo carries back as `id`/`xmppId`, so clear it here and let the
+      // bubble flip to delivered instead of staying stuck on "Failed".
+      if (message && !message.pending) {
+        // The confirmed copy carries our optimistic/stanza id back as id/xmppId.
+        // Drop any still-buffered replay for it so a later reconnect flush can't
+        // re-send an already-delivered message.
+        removeOutboundSend(message.id);
+        if (message.xmppId) {removeOutboundSend(message.xmppId);}
+
+        const failedKey = [message.id, message.xmppId].find(
+          (k: string | undefined) => k && failedMap[k]
+        );
+        if (failedKey) {
+          storeAPI.dispatch(clearMessageFailure(failedKey as string));
+        }
+      }
     }
 
     return result;
   };
 
 //   import { Middleware, PayloadAction } from '@reduxjs/toolkit';
-// import { updateRoom } from '../roomsSlice';
-// import { AddRoomMessageAction, IRoom } from '../../types/types';
+// // import { AddRoomMessageAction, IRoom } from '../../types/types';
 // import { nanoToMs } from '../../helpers/nanoToMs';
 
 // export const newMessageMidlleware: Middleware =

package/src/roomStore/Middleware/perfMiddleware.ts

@@ -0,0 +1,50 @@
+import { Middleware } from '@reduxjs/toolkit';
+
+declare const __DEV__: boolean | undefined;
+
+/**
+ * Dev-only store profiler: counts dispatches and the time the reducer +
+ * middleware chain spent on them, and prints a one-line summary every
+ * 10 s while there was activity. Reads as
+ *   [perf] 10s: 143 actions, 212ms in store, top: roomMessages/addRoomMessages×12 (90ms) …
+ * No-op (and not even installed) in release builds.
+ */
+const WINDOW_MS = 10000;
+
+let count = 0;
+let totalMs = 0;
+let byType: Record<string, { n: number; ms: number }> = {};
+let timer: ReturnType<typeof setTimeout> | null = null;
+
+const flush = () => {
+  timer = null;
+  if (count === 0) {return;}
+  const top = Object.entries(byType)
+    .sort((a, b) => b[1].ms - a[1].ms)
+    .slice(0, 4)
+    .map(([type, v]) => `${type}×${v.n} (${v.ms.toFixed(0)}ms)`)
+    .join(', ');
+  console.log(
+    `[perf] ${WINDOW_MS / 1000}s: ${count} actions, ${totalMs.toFixed(0)}ms in store, top: ${top}`
+  );
+  count = 0;
+  totalMs = 0;
+  byType = {};
+};
+
+export const perfMiddleware: Middleware = () => (next) => (action: any) => {
+  const start = Date.now();
+  const result = next(action);
+  const ms = Date.now() - start;
+  count += 1;
+  totalMs += ms;
+  const type = action?.type || '?';
+  const entry = byType[type] || (byType[type] = { n: 0, ms: 0 });
+  entry.n += 1;
+  entry.ms += ms;
+  if (!timer) {timer = setTimeout(flush, WINDOW_MS);}
+  return result;
+};
+
+export const isPerfProfilingEnabled = () =>
+  typeof __DEV__ !== 'undefined' && __DEV__ === true;

package/src/roomStore/Middleware/reactionsMiddleware.tsx

@@ -1,77 +1,78 @@
-import { Middleware, PayloadAction } from '@reduxjs/toolkit';
+import { Middleware } from '@reduxjs/toolkit';
 import { updateRoom } from '../roomsSlice';
-import { IRoom, ReactionAction } from '../../types/types';
-import { nanoToMs } from '../../helpers/nanoToMs';
+import { IMessage, IRoom } from '../../types/types';
 
+/**
+ * Keeps the room-list preview in step with reactions (as on web): the
+ * newest event in a room being a reaction shows "Ann: 👍"; a reactor
+ * clearing theirs puts the last real message back.
+ *
+ * Timestamps here are the server's stanza ids, the same unit as
+ * `lastMessageTimestamp` (set from message ids in the reducer), so a
+ * reaction older than the room's latest message never takes the preview.
+ */
 export const reactionsMiddleware: Middleware =
   (storeAPI) => (next) => (action: any) => {
-    if (action.type !== 'roomMessages/setReactions') {
+    if (action?.type !== 'roomMessages/setReactions') {
       return next(action);
     }
-
     if (!action.payload || typeof action.payload !== 'object') {
       console.error('Invalid action payload for setReactions:', action);
       return next(action);
     }
-
     const result = next(action);
-    const state = storeAPI.getState();
-    const rooms: { [jid: string]: IRoom } = state.rooms.rooms;
-    const { roomJID, reactions, latestReactionTimestamp, data, ...rest } =
-      action.payload;
+    try {
+      const payload = action.payload || {};
+      const { roomJID, reactions, latestReactionTimestamp, data } = payload;
+      const room: IRoom | undefined = storeAPI.getState().rooms?.rooms?.[roomJID];
+      if (!room) {return result;}
 
-    const updLastMessage = () => {
-      if (!reactions?.[0]) {
-        const newLastMessage =
-          rooms[roomJID].messages[rooms[roomJID].messages.length - 1];
+      const ts = Number(latestReactionTimestamp) || 0;
+      const roomTs = Number(room.lastMessageTimestamp) || 0;
 
+      if (Array.isArray(reactions) && reactions[0]) {
+        // Only the newest event in the room may become the preview.
+        if (!ts || ts < roomTs) {return result;}
+        const name = `${data?.senderFirstName || ''} ${data?.senderLastName || ''}`.trim();
         storeAPI.dispatch(
           updateRoom({
             jid: roomJID,
             updates: {
-              lastMessageTimestamp: nanoToMs(
-                rooms[roomJID].messages[rooms[roomJID].messages.length - 1].id
-              ) ?? 0,
-              lastMessage: newLastMessage as any,
+              lastMessageTimestamp: ts,
+              lastMessage: {
+                id: `reaction-${ts}`,
+                body: reactions[0],
+                emoji: reactions[0],
+                user: { id: `emoji-${ts}`, name },
+                date: new Date(Math.floor(ts / 1000)).toISOString(),
+              } as any,
             },
           })
         );
-      } else {
-        const updates = {
-          lastMessageTimestamp: nanoToMs(latestReactionTimestamp) ?? 0,
-          lastMessage: {
-            ...rest,
-            body: reactions[0],
-            emoji: reactions[0],
-            user: {
-              name: `${data.senderFirstName} ${data.senderLastName}`,
-              id: `emoji-${new Date().toString()}`,
-            },
-            date: new Date(nanoToMs(latestReactionTimestamp) ?? 0).toISOString(),
-          },
-        };
-
-        storeAPI.dispatch(
-          updateRoom({
-            jid: roomJID,
-            updates: updates as any,
-          })
-        );
+        return result;
       }
-    };
-
-    if (!rooms[roomJID]) {
-      console.warn(`Room ${roomJID} not found in reactions middleware`);
-      return result;
-    }
 
-    if (
-      (rooms[roomJID]?.lastMessageTimestamp ?? 0) <= (nanoToMs(latestReactionTimestamp) ?? 0)
-    ) {
-      updLastMessage();
-    } else if (!rooms[roomJID]?.lastMessageTimestamp) {
-      updLastMessage();
+      // A reaction was cleared: if the preview was a reaction, fall back to
+      // the newest real message (the room may have none loaded yet).
+      if (!(room.lastMessage as any)?.emoji) {return result;}
+      const messages: IMessage[] = room.messages || [];
+      let last: IMessage | undefined;
+      for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        if (m && m.id !== 'delimiter-new' && !m.isDeleted) {
+          last = m;
+          break;
+        }
+      }
+      storeAPI.dispatch(
+        updateRoom({
+          jid: roomJID,
+          updates: { lastMessage: (last as any) ?? undefined },
+        })
+      );
+    } catch (e) {
+      // A preview update must never break the action that carried it.
+      console.warn('reactionsMiddleware: preview update failed', e);
     }
-
     return result;
   };