@ethora/chat-component-rn 26.4.1 → 26.5.1

package/src/networking/stanzaHandlers.ts

@@ -266,7 +266,11 @@ const handleComposing = async (stanza: Element, currentUser: string) => {
 };
 
 const onPresenceInRoom = (stanza: Element | any) => {
-  if (stanza.attrs.id === 'presenceInRoom' && !stanza.getChild('error')) {
+  if (
+    typeof stanza.attrs.id === 'string' &&
+    stanza.attrs.id.startsWith('presenceInRoom') &&
+    !stanza.getChild('error')
+  ) {
     const roomJID: string = stanza.attrs.from.split('/')[0];
     const role: string = stanza?.children[1]?.children[0]?.attrs.role;
     store.dispatch(setRoomRole({ chatJID: roomJID, role: role }));
@@ -346,17 +350,20 @@ const onGetChatRooms = (stanza: Element, xmpp: any) => {
     stanza.attrs.id === 'getUserRooms' &&
     Array.isArray(stanza.getChild('query')?.children)
   ) {
-    stanza.getChild('query')?.children.forEach(async (result: any) => {
+    const children = stanza.getChild('query')?.children || [];
+    children.forEach(async (result: any) => {
       const currentChatRooms = store.getState().rooms.rooms;
 
       const isRoomAlreadyAdded = Object.values(currentChatRooms).some(
         (element) => element.jid === result?.attrs?.jid
       );
 
+      const jid = result?.attrs?.jid;
+
       if (!isRoomAlreadyAdded) {
         try {
           const roomData: IRoom = {
-            jid: result?.attrs?.jid || '',
+            jid: jid || '',
             name: result?.attrs?.name || '',
             id: '',
             title: result?.attrs?.name || '',
@@ -380,12 +387,16 @@ const onGetChatRooms = (stanza: Element, xmpp: any) => {
           if (!store.getState().rooms.activeRoomJID) {
             store.dispatch(setCurrentRoom({ roomJID: roomData.jid }));
           }
-
-          if (roomData.jid) {
-            xmpp.presenceInRoomStanza(roomData.jid);
-          }
         } catch (error) {}
       }
+
+      if (jid) {
+        try {
+          xmpp.presenceInRoomStanza(jid);
+        } catch (e) {
+          console.warn('presenceInRoomStanza failed', jid, e);
+        }
+      }
     });
   }
 };

package/src/networking/xmpp/flushLastViewedToPrivateStore.ts

@@ -0,0 +1,86 @@
+import { getChatsPrivateStoreRequest } from './getChatsPrivateStoreRequest.xmpp';
+import { setChatsPrivateStoreRequest } from './setChatsPrivateStoreRequest.xmpp';
+
+interface RoomLike {
+  jid: string;
+  lastViewedTimestamp?: number;
+  unreadMessages?: number;
+}
+
+interface FlushOpts {
+  // When activeRoomJID is set, treat it as "user just viewed everything
+  // up to now" and stamp it with Date.now() — even if its in-memory
+  // lastViewedTimestamp is 0 (which means "actively viewing" in
+  // roomsSlice).
+  activeRoomJID?: string | null;
+  // If true, only write entries for rooms where unreadMessages === 0
+  // (or the active room). Used at logout time: rooms with outstanding
+  // unread keep their old marker so the next login still surfaces them.
+  onlyIfNoUnread?: boolean;
+}
+
+/**
+ * Merge in-memory lastViewedTimestamp values into the server-side
+ * private store. Reads current state, overlays per-room updates, writes
+ * back. Single round-trip so concurrent open clients don't trample
+ * each other's entries.
+ *
+ * Called on: tab change away from chat, AppState background/inactive,
+ * and (with onlyIfNoUnread=true) logout. ChatRoom's own unmount path
+ * still uses actionSetTimestampToPrivateStore for the single-room case.
+ */
+export async function flushLastViewedToPrivateStore(
+  client: any,
+  rooms: Record<string, RoomLike> | null | undefined,
+  opts: FlushOpts = {}
+): Promise<boolean> {
+  if (!client?.client) {return false;}
+  const { activeRoomJID, onlyIfNoUnread } = opts;
+  const roomList = Object.values(rooms || {});
+  if (roomList.length === 0) {return false;}
+
+  let storeObj: any = null;
+  try {
+    storeObj = await getChatsPrivateStoreRequest(client.client);
+  } catch {
+    storeObj = null;
+  }
+  if (!storeObj || typeof storeObj !== 'object') {storeObj = {};}
+
+  const nowMs = Date.now();
+  let dirty = false;
+
+  for (const room of roomList) {
+    if (!room?.jid) {continue;}
+    const isActive = !!activeRoomJID && room.jid === activeRoomJID;
+    const hasUnread = Number(room.unreadMessages || 0) > 0;
+
+    // For the active room, persist "now" — the in-memory value is 0
+    // (sentinel for "user is here") and writing 0 would mark all
+    // history unread on next login.
+    let ts: number | undefined;
+    if (isActive) {
+      ts = nowMs;
+    } else if (room.lastViewedTimestamp) {
+      ts = room.lastViewedTimestamp;
+    }
+
+    if (!ts) {continue;}
+    if (onlyIfNoUnread && hasUnread && !isActive) {continue;}
+
+    const prev = storeObj[room.jid];
+    const prevNum = prev != null ? Number(prev) : 0;
+    if (Number.isFinite(prevNum) && prevNum >= ts) {continue;}
+    storeObj[room.jid] = String(ts);
+    dirty = true;
+  }
+
+  if (!dirty) {return false;}
+
+  try {
+    await setChatsPrivateStoreRequest(client.client, JSON.stringify(storeObj));
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/networking/xmpp/getHistory.xmpp.ts

@@ -132,7 +132,12 @@ export const getHistory = async (
     ]);
     return res === null ? [] : res;
   } catch (e) {
-    console.log('=-> error in', fixedChatJid, e);
+    // MAM rejects with no value when an iq error returns; the timeout
+    // path resolves with null instead of throwing. Either is expected
+    // for a room with no history yet — only log if `e` is meaningful.
+    if (e !== undefined) {
+      console.log('=-> error in', fixedChatJid, e);
+    }
     return [];
   } finally {
     unsubscribe();

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

@@ -1,14 +1,19 @@
 import { Client, xml } from '@xmpp/client';
 import { createTimeoutPromise } from './createTimeoutPromise.xmpp';
 import { Element } from '@xmpp/xml';
+
+let presenceIdCounter = 0;
+const nextPresenceId = () =>
+  `presenceInRoom-${Date.now().toString(36)}-${(++presenceIdCounter).toString(36)}`;
+
 export const presenceInRoom = async (
   client: Client,
   roomJID: string,
   delay = 2000
 ): Promise<Element> => {
   let stanzaHandler: (stanza: Element) => void;
-
   const unsubscribe = () => client.off('stanza', stanzaHandler);
+  const stanzaId = nextPresenceId();
 
   return new Promise(async (resolve, reject) => {
     let settled = false;
@@ -26,7 +31,7 @@ export const presenceInRoom = async (
     stanzaHandler = (stanza) => {
       if (
         stanza.is('presence') &&
-        stanza.attrs.id === 'presenceInRoom' &&
+        stanza.attrs.id === stanzaId &&
         stanza.attrs.from?.startsWith(roomJID)
       ) {
         finish(resolve, stanza);
@@ -40,7 +45,7 @@ export const presenceInRoom = async (
       {
         from: client.jid?.toString(),
         to: `${roomJID}/${client.jid?.getLocal()}`,
-        id: 'presenceInRoom',
+        id: stanzaId,
       },
       xml('x', { xmlns: 'http://jabber.org/protocol/muc' })
     );

package/src/networking/xmpp/sendMediaMessage.xmpp.ts

@@ -1,5 +1,9 @@
 import { Client, xml } from '@xmpp/client';
 
+// Monotonic counter — see sendTextMessage for the rationale (avoids
+// Date.now() id collisions on <1ms-apart sends).
+let _sendMediaSeq = 0;
+
 /**
  * Same xmlns derivation as sendTextMessage — the server registers app
  * messages under the WSS service URL (`wss://<host>/ws`), and stanzas
@@ -23,7 +27,7 @@ export function sendMediaMessage(
   devServer?: string
 ) {
   const id =
-    customId || `send-media-message-${Date.now().toString()}`;
+    customId || `send-media-message-${Date.now()}-${(_sendMediaSeq = (_sendMediaSeq + 1) >>> 0)}`;
 
   const dataToSend = {
     xmlns: toServiceXmlns(devServer, client),
@@ -72,26 +76,20 @@ export function sendMediaMessage(
     xml('data', dataToSend)
   );
 
-  console.log('🟢 [sendMediaMessage] sending stanza', {
-    id,
-    to: roomJID,
-    mime: data?.mimetype,
-    name: data?.fileName,
-  });
   try {
     const sendResult = client.send(message);
     if (sendResult && typeof (sendResult as any).then === 'function') {
       (sendResult as Promise<unknown>)
-        .then(() => console.log('🟢 [sendMediaMessage] client.send resolved', { id }))
+        .then(() => console.log('client.send resolved', { id }))
         .catch((err) =>
-          console.error('🔴 [sendMediaMessage] client.send REJECTED', {
+          console.error('client.send REJECTED', {
             id,
             message: (err as any)?.message,
           })
         );
     }
   } catch (error) {
-    console.error('🔴 [sendMediaMessage] sync error', error);
+    console.error(error);
   }
   return id;
 }

package/src/networking/xmpp/sendTextMessage.xmpp.ts

@@ -1,5 +1,8 @@
 import { Client, xml } from '@xmpp/client';
 
+// Local monotonic counter — see comment in id construction below.
+let _sendTextSeq = 0;
+
 /**
  * Normalize devServer to the WSS service URL that the server uses as
  * the data-element xmlns. The user-facing `xmppDevServer` config
@@ -37,11 +40,15 @@ export const sendTextMessage = (
   devServer?: string,
   customId?: string
 ) => {
+  // Same monotonic-counter pattern as useSendMessage.nextStanzaId, to
+  // protect direct callers that don't supply a customId from
+  // Date.now() collisions when sends happen <1ms apart.
+  if (!_sendTextSeq) {/* noop guarded init */}
   const id = customId
     ? customId
     : isReply
-      ? `send-reply-message-${Date.now().toString()}`
-      : `send-text-message-${Date.now().toString()}`;
+      ? `send-reply-message-${Date.now()}-${(_sendTextSeq = (_sendTextSeq + 1) >>> 0)}`
+      : `send-text-message-${Date.now()}-${(_sendTextSeq = (_sendTextSeq + 1) >>> 0)}`;
 
   try {
     const message = xml(
@@ -71,19 +78,12 @@ export const sendTextMessage = (
       }),
       xml('body', {}, userMessage)
     );
-    console.log('🟢 [sendTextMessage] sending stanza', {
-      id,
-      to: roomJID,
-      bodyLen: userMessage?.length,
-      clientJid: client.jid?.toString(),
-      xmlns: toServiceXmlns(devServer, client),
-    });
     const sendResult = client.send(message);
     if (sendResult && typeof (sendResult as any).then === 'function') {
       (sendResult as Promise<unknown>)
-        .then(() => console.log('🟢 [sendTextMessage] client.send resolved', { id }))
+        .then(() => console.log('client.send resolved', { id }))
         .catch((err) =>
-          console.error('🔴 [sendTextMessage] client.send REJECTED', {
+          console.error('client.send REJECTED', {
             id,
             message: (err as any)?.message,
             name: (err as any)?.name,
@@ -94,6 +94,6 @@ export const sendTextMessage = (
       console.log('🟡 [sendTextMessage] client.send returned non-promise', { id, type: typeof sendResult });
     }
   } catch (error) {
-    console.error('🔴 [sendTextMessage] sync error', error);
+    console.error(error);
   }
 };

package/src/networking/xmppClient.ts

@@ -5,6 +5,7 @@ import { xmppSettingsInterface } from '../types/types';
 import { sendMediaMessage } from './xmpp/sendMediaMessage.xmpp';
 import { getChatsPrivateStoreRequest } from './xmpp/getChatsPrivateStoreRequest.xmpp';
 import { actionSetTimestampToPrivateStore } from './xmpp/actionSetTimestampToPrivateStore.xmpp';
+import { flushLastViewedToPrivateStore } from './xmpp/flushLastViewedToPrivateStore';
 import { sendTypingRequest } from './xmpp/sendTypingRequest.xmpp';
 import { getHistory } from './xmpp/getHistory.xmpp';
 import { sendTextMessage } from './xmpp/sendTextMessage.xmpp';
@@ -233,6 +234,17 @@ export class XmppClient {
         password: this.password,
       });
 
+      // Concurrent room preloads each register their own short-lived
+      // 'stanza' handler (getHistory, getRooms, getChatsPrivateStore,
+      // ...). With 5+ rooms preloading in parallel, Node's default
+      // EventEmitter cap of 10 trips the "possible memory leak" warning
+      // even though each handler is correctly unsubscribed in `finally`.
+      // 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);
+      } catch {}
+
       // Wrap `send` so the dev logger sees outgoing stanzas too.
       // Guarded: some @xmpp/client builds define `send` as a getter or
       // non-writable property, and overwriting would throw silently and
@@ -531,6 +543,21 @@ export class XmppClient {
     } catch (error) {}
   }
 
+  // Flush lastViewedTimestamp for every room into the server's private
+  // store. Used by AppState/background and tab-change handlers — see
+  // src/networking/xmpp/flushLastViewedToPrivateStore.ts for details.
+  async flushLastViewedToPrivateStoreStanza(
+    rooms: Record<string, any> | null | undefined,
+    opts: { activeRoomJID?: string | null; onlyIfNoUnread?: boolean } = {}
+  ) {
+    if (this.disableLastRead) {return false;}
+    try {
+      return await flushLastViewedToPrivateStore(this, rooms, opts);
+    } catch {
+      return false;
+    }
+  }
+
   sendMediaMessageStanza(roomJID: string, data: any, customId?: string) {
     return sendMediaMessage(
       this.client,

package/src/roomStore/Middleware/logoutMiddleware.tsx

@@ -10,14 +10,23 @@ export const logoutMiddleware: Middleware =
 
     const result = next(action);
 
-    if (action.type === 'chatSettingStore/logout') {
-      try {
-        setTimeout(() => {
-          DeviceEventEmitter.emit('ethora-xmpp-logout');
-        }, 0);
-      } catch (error) {
-        console.error('Error dispatching ethora-xmpp-logout event:', error);
-      }
+    // Action type uses the slice's `name`, not the store key —
+    // chatSettingsSlice is registered with `name: 'chat'`, so the
+    // logout action type is `chat/logout`. Filtering on
+    // `chatSettingStore/logout` (the store key) silently never fires,
+    // which means the XMPP transport never sees the logout signal.
+    if (action.type === 'chat/logout') {
+      // Capture the emitter reference outside the timer body so a Jest
+      // teardown that nulls out the lazy `react-native` exports between
+      // dispatch and the 0-delay timer firing can't crash the timer.
+      const emitter = DeviceEventEmitter;
+      setTimeout(() => {
+        try {
+          emitter?.emit?.('ethora-xmpp-logout');
+        } catch (error) {
+          console.error('Error dispatching ethora-xmpp-logout event:', error);
+        }
+      }, 0);
     }
 
     return result;

package/src/roomStore/Middleware/unreadMidlleware.tsx

@@ -1,8 +1,73 @@
 import { Middleware } from '@reduxjs/toolkit';
-import { updateRoom } from '../roomsSlice';
+import { updateRoom, msgSortableMs } from '../roomsSlice';
 import { IMessage } from '../../types/types';
 
-let previousMessagesCount: { [jid: string]: number } = {};
+// Per-room cache so we only recompute when something that affects the
+// count actually changed. The fingerprint is `<messages.length>|<lastViewed>`
+// — switching just the lastViewedTimestamp (e.g. user re-opens a room)
+// must also retrigger, not just the message count.
+//
+// Kept at module scope so the middleware doesn't re-allocate it on
+// every store; cleared on `chat/logout` (see the action gate below) so
+// a re-login as a different user doesn't inherit the previous user's
+// suppression cache.
+let triggerCache: { [jid: string]: string } = {};
+
+// Normalise an identity candidate (bare JID local, xmpp username, wallet)
+// for case-insensitive comparison. Drops the domain part of any JID and
+// strips XMPP resource separators ('/' for resource, '_' that the server
+// inserts inside the local part for some prefix formats).
+const norm = (s: any): string => {
+  if (s == null) {return '';}
+  let v = String(s).toLowerCase();
+  v = v.split('/')[0]; // strip XMPP resource
+  v = v.split('@')[0]; // strip JID domain
+  return v.replace(/_/g, '');
+};
+
+// Mirrors Android `isOwnMessage` (chat-core RoomStore.kt). The sender id
+// arrives in either `user.id` (Ethora user id from optimistic local sends)
+// or `user.userJID` / `xmppFrom` (XMPP local for server echoes), so we
+// match across all three against the current user's candidates.
+// Uses exact-match on the normalised bare-local (no substring containment)
+// to avoid false positives like norm('someone')='someone' matching
+// norm('me')='me' via 'someone'.includes('me').
+const isOwnMessage = (
+  msg: IMessage,
+  selfXmpp: string,
+  selfWallet: string
+): boolean => {
+  if (!selfXmpp && !selfWallet) {return false;}
+  const candidates = [
+    norm((msg as any)?.user?.id),
+    norm((msg as any)?.user?.userJID),
+    norm((msg as any)?.user?.xmppUsername),
+    norm((msg as any)?.xmppFrom),
+  ].filter(Boolean);
+  if (candidates.length === 0) {return false;}
+  const self = new Set(
+    [norm(selfXmpp), norm(selfWallet)].filter(Boolean)
+  );
+  for (const c of candidates) {
+    if (self.has(c)) {return true;}
+  }
+  return false;
+};
+
+// Action types that can affect any room's unread count. Without this
+// gate the middleware ran on EVERY dispatch — modal toggles, scroll
+// events, typing-indicator setComposing, etc. — and walked every room's
+// messages array looking for a count delta that almost never came. For
+// 50 rooms × 100 messages that's 5000 Date() parses per modal click.
+const TRIGGER_ACTIONS = new Set([
+  'roomMessages/addRoomMessage',
+  'roomMessages/setRoomMessages',
+  'roomMessages/editRoomMessage',
+  'roomMessages/setLastViewedTimestamp',
+  'roomMessages/setCurrentRoom',
+  'roomMessages/addRoom',
+  'roomMessages/updateRoom',
+]);
 
 export const unreadMiddleware: Middleware =
   (storeAPI) => (next) => (action: any) => {
@@ -11,45 +76,74 @@ export const unreadMiddleware: Middleware =
       return next(action);
     }
 
+    // Reset the per-user suppression cache on logout so the next
+    // signed-in user doesn't inherit the previous user's "saw this
+    // count, skip" entries.
+    if (action.type === 'chat/logout') {
+      triggerCache = {};
+      return next(action);
+    }
+
     if (action?.type === 'roomMessages/deleteRoomMessage') {
       return next(action);
     }
 
     const result = next(action);
 
+    // Hot-path bail-out: most actions don't touch unread state.
+    if (!TRIGGER_ACTIONS.has(action.type)) {return result;}
+
     const state = storeAPI.getState();
     const rooms = state.rooms.rooms;
     const activeChatJID = state.rooms.activeRoomJID;
+    const selfUser = state.chatSettingStore?.user;
+    const selfXmpp = selfUser?.xmppUsername || '';
+    const selfWallet = selfUser?.walletAddress || '';
 
     if (rooms && Object.keys(rooms).length > 0) {
       Object.keys(rooms).forEach((jid) => {
         const room = rooms[jid];
-        if (room.lastViewedTimestamp !== 0 && jid !== activeChatJID) {
-          const currentMessagesLength = room.messages?.length || 0;
-
-          if (previousMessagesCount[jid] !== currentMessagesLength) {
-            previousMessagesCount[jid] = currentMessagesLength;
-
-            // Mirror `countNewerMessages` in roomsSlice: ignore the
-            // "delimiter-new" sentinel + locally-pending sends so the
-            // two paths never disagree.
-            const unreadMessagesCount = room.messages?.filter(
-              (msg: IMessage) =>
-                msg.id !== 'delimiter-new' &&
-                !msg.pending &&
-                new Date(msg.date).getTime() >
-                  (room.lastViewedTimestamp || 0)
-            ).length;
-
-            if (room.unreadMessages !== unreadMessagesCount) {
-              storeAPI.dispatch(
-                updateRoom({
-                  jid,
-                  updates: { unreadMessages: unreadMessagesCount },
-                })
-              );
-            }
-          }
+        if (!room) {return;}
+        // Skip rooms the user is currently viewing — `setLastViewedTimestamp(0)`
+        // clears their unread directly. Skip rooms with no reference point
+        // (covers undefined / null / 0) — after logout→login, hydrated rooms
+        // come back without lastViewedTimestamp, and treating that as 0
+        // made every history message satisfy `date > 0` and incorrectly
+        // bumped unread for already-seen content.
+        if (!room.lastViewedTimestamp || jid === activeChatJID) {return;}
+
+        // Fingerprint = "what would affect the answer". If neither the
+        // message count nor the lastViewedTimestamp changed since last
+        // time we computed, the answer is stable; skip the walk. (The
+        // previous version tracked only message count, so changing
+        // lastViewedTimestamp without a new message dropped the
+        // recompute silently — the unread badge could go stale.)
+        const currentMessagesLength = room.messages?.length || 0;
+        const fingerprint = `${currentMessagesLength}|${room.lastViewedTimestamp || 0}`;
+        if (triggerCache[jid] === fingerprint) {return;}
+        triggerCache[jid] = fingerprint;
+
+        // Ignore the "delimiter-new" sentinel + locally-pending sends
+        // so the two unread-counting paths (this middleware + the
+        // reducer's countNewerMessages) never disagree. Also exclude
+        // own messages so MAM-replayed sends on re-login don't bump
+        // the user's own badge.
+        const unreadMessagesCount = room.messages?.filter(
+          (msg: IMessage) =>
+            msg.id !== 'delimiter-new' &&
+            !msg.pending &&
+            !isOwnMessage(msg, selfXmpp, selfWallet) &&
+            msgSortableMs(msg) >
+              (room.lastViewedTimestamp || 0)
+        ).length;
+
+        if (room.unreadMessages !== unreadMessagesCount) {
+          storeAPI.dispatch(
+            updateRoom({
+              jid,
+              updates: { unreadMessages: unreadMessagesCount },
+            })
+          );
         }
       });
     }

package/src/roomStore/persistence.ts

@@ -8,7 +8,7 @@ import { IMessage, IRoom, User } from '../types/types';
 //
 //   - persist chatSettingStore.user (sanitized) and rooms state
 //   - blacklist transient fields (modals, activeRoomJID, etc.)
-//   - cap each room's messages to the most recent 50
+//   - cap each room's messages to the most recent MESSAGE_LIMIT (100)
 //   - debounced writes (200ms) on relevant action types
 //
 // Not encrypted. We rely on AsyncStorage's per-app sandbox.
@@ -17,7 +17,10 @@ import { IMessage, IRoom, User } from '../types/types';
 const KEY_CHAT = '@ethora/persist:chatSettingStore';
 const KEY_ROOMS = '@ethora/persist:rooms';
 
-const MESSAGE_LIMIT = 50;
+// Per-room message cap on disk. Mirror this value in `roomsSlice`'s
+// in-memory cap (see `enforceMessageCap`) so the runtime and persisted
+// shapes stay aligned.
+export const MESSAGE_LIMIT = 100;
 
 interface PersistedChatState {
   user: User;