@ethora/chat-component-rn 26.5.5 → 26.5.10

package/src/networking/outboundQueue.ts

@@ -0,0 +1,98 @@
+/**
+ * Outbound-send queue — buffers message stanzas that can't reach the wire
+ * because there is no live XMPP stream at send time, and replays them once
+ * a stream comes (back) online.
+ *
+ * Lives at MODULE scope on purpose, NOT on the XmppClient instance: the
+ * exact windows we need to cover are the ones where the instance itself is
+ * gone or being swapped —
+ *   1. start race — a send fires before the provider's bootstrap has run
+ *      `setClient(created)`, so `useSendMessage` sees `client === null` and
+ *      used to throw "No XMPP client".
+ *   2. full-reinit race — after 3 failed reconnects the provider does
+ *      `setClient(null)` then re-`initializeClient`s; sends in that gap
+ *      also saw `client === null`.
+ *   3. reconnect window — the instance survives but its underlying stream
+ *      is `connecting`/`offline`; a fire-and-forget stanza is silently lost
+ *      and only the 30s watchdog notices.
+ *
+ * Each queued item carries a `send(client)` closure that captures the
+ * original args (text or media), so flush is type-agnostic.
+ *
+ * TTL is deliberately aligned with the 30s pending-send watchdog in
+ * useSendMessage (PENDING_WATCHDOG_MS): a queued item older than that has
+ * already been — or is about to be — flipped to "Failed → tap to retry" by
+ * the watchdog, so replaying it on a late reconnect would duplicate the
+ * bubble. We drop those on flush and let the watchdog own the failure.
+ */
+
+export interface OutboundQueueClient {
+  sendMessage: (...args: any[]) => any;
+  sendMediaMessageStanza: (...args: any[]) => any;
+}
+
+export interface QueuedSend {
+  /** Optimistic/stanza id — used to dedupe re-enqueues (e.g. media retry). */
+  optimisticId: string;
+  roomJID: string;
+  /** Wall-clock ms when first queued; drives the TTL drop on flush. */
+  enqueuedAt: number;
+  /** Replays the original send against a live, online client. */
+  send: (client: OutboundQueueClient) => void;
+}
+
+// Kept in lockstep with PENDING_WATCHDOG_MS in useSendMessage.
+export const OUTBOUND_QUEUE_TTL_MS = 30_000;
+
+let queue: QueuedSend[] = [];
+
+/**
+ * Append (or, if the id is already queued, replace in place) a pending
+ * send. Order is preserved for FIFO flush.
+ */
+export function enqueueOutboundSend(item: QueuedSend): void {
+  const idx = queue.findIndex((q) => q.optimisticId === item.optimisticId);
+  if (idx >= 0) {
+    // Re-enqueue of the same id (e.g. a media retry): refresh in place so
+    // we don't grow a duplicate, and keep its original position.
+    queue[idx] = item;
+    return;
+  }
+  queue.push(item);
+}
+
+/**
+ * Replay every queued send (in order) against a now-online client. Items
+ * older than the TTL are dropped — the send watchdog has already failed
+ * them, so re-sending would duplicate. The queue is emptied either way.
+ */
+export function flushOutboundSends(
+  client: OutboundQueueClient,
+  now: number
+): void {
+  if (queue.length === 0) {return;}
+  const pending = queue;
+  queue = [];
+  for (const item of pending) {
+    if (now - item.enqueuedAt > OUTBOUND_QUEUE_TTL_MS) {
+      // Stale — the 30s watchdog owns the failure; don't duplicate.
+      continue;
+    }
+    try {
+      item.send(client);
+    } catch (err) {
+      // A single bad replay must not strand the rest of the queue.
+      console.warn('flushOutboundSends: replay failed', item.optimisticId, err);
+    }
+  }
+}
+
+/** Drop everything — called on permanent teardown (logout / close). */
+export function clearOutboundSends(): void {
+  queue = [];
+}
+
+/** Current depth — for tests and diagnostics. */
+export function outboundQueueLength(): number {
+  return queue.length;
+}

package/src/networking/xmpp/createTimeoutPromise.xmpp.ts

@@ -2,14 +2,18 @@ export function createTimeoutPromise(
   ms: number | undefined,
   unsubscribe?: () => void
 ) {
-  return new Promise((_, reject) => {
+  const promise = new Promise((_, reject) => {
     setTimeout(() => {
       try {
         if (unsubscribe) {
           unsubscribe();
         }
       } catch (e) {}
+      // result and stay silent.
       reject();
     }, ms);
   });
+ 
+  promise.catch(() => {});
+  return promise;
 }

package/src/networking/xmpp/flushLastViewedToPrivateStore.ts

@@ -8,13 +8,12 @@ interface RoomLike {
 }
 
 interface FlushOpts {
-  // When activeRoomJID is set, treat it as "user just viewed everything
+  // When visibleRoomJID 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;
+  // lastViewedTimestamp has not been updated yet.
+  visibleRoomJID?: string | null;
   // If true, only write entries for rooms where unreadMessages === 0
-  // (or the active room). Used at logout time: rooms with outstanding
+  // (or the visible room). Used at logout time: rooms with outstanding
   // unread keep their old marker so the next login still surfaces them.
   onlyIfNoUnread?: boolean;
 }
@@ -35,7 +34,7 @@ export async function flushLastViewedToPrivateStore(
   opts: FlushOpts = {}
 ): Promise<boolean> {
   if (!client?.client) {return false;}
-  const { activeRoomJID, onlyIfNoUnread } = opts;
+  const { visibleRoomJID, onlyIfNoUnread } = opts;
   const roomList = Object.values(rooms || {});
   if (roomList.length === 0) {return false;}
 
@@ -52,21 +51,20 @@ export async function flushLastViewedToPrivateStore(
 
   for (const room of roomList) {
     if (!room?.jid) {continue;}
-    const isActive = !!activeRoomJID && room.jid === activeRoomJID;
+    const isVisible = !!visibleRoomJID && room.jid === visibleRoomJID;
     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.
+    // For the visible room, persist "now" — read state is driven by
+    // room visibility, not by a sentinel timestamp.
     let ts: number | undefined;
-    if (isActive) {
+    if (isVisible) {
       ts = nowMs;
-    } else if (room.lastViewedTimestamp) {
+    } else if (room.lastViewedTimestamp && room.lastViewedTimestamp > 0) {
       ts = room.lastViewedTimestamp;
     }
 
     if (!ts) {continue;}
-    if (onlyIfNoUnread && hasUnread && !isActive) {continue;}
+    if (onlyIfNoUnread && hasUnread && !isVisible) {continue;}
 
     const prev = storeObj[room.jid];
     const prevNum = prev != null ? Number(prev) : 0;

package/src/networking/xmpp/getRoomsPaged.xmpp.ts

@@ -17,7 +17,12 @@ export const getRoomsPaged = async (
     client.off('stanza', stanzaHdlrPointer);
   };
 
-  return new Promise(async (resolve, reject) => {
+  // Avoid `new Promise(async (resolve, reject) => {...})` — an async
+  // executor swallows the promise it returns, so any rejection inside
+  // it that happens BEFORE the catch handler attaches becomes
+  // "Uncaught (in promise)" red-screen. Use an explicit deferred + a
+  // regular async body that handles its own errors.
+  return new Promise<any>((resolve, reject) => {
     stanzaHdlrPointer = (stanza) => {
       if (stanza.is('iq') && stanza.attrs.id === 'getUserRooms') {
         unsubscribe();
@@ -46,14 +51,33 @@ export const getRoomsPaged = async (
       query
     );
 
+    // Capture potential rejections from client.send() — it returns a
+    // Promise on most @xmpp/client builds; the previous bare call left
+    // the rejection unhandled when the socket was closing.
+    let sendPromise: Promise<unknown> | undefined;
     try {
-      client.send(message);
+      sendPromise = client.send(message) as unknown as Promise<unknown>;
     } catch (err) {
       console.error('Error sending getRooms request:', err);
       unsubscribe();
       reject(err);
+      return;
     }
+    Promise.resolve(sendPromise)
+      .catch((err) => {
+        console.error('client.send rejected in getRoomsPaged', err);
+        unsubscribe();
+        reject(err);
+      });
 
-    await createTimeoutPromise(2000, unsubscribe).catch(reject);
+    // The timeout catch was racy — if createTimeoutPromise rejected
+    // before `.catch(reject)` attached, the rejection escaped. Use a
+    // .then/.catch pair attached synchronously to be safe.
+    createTimeoutPromise(2000, unsubscribe).then(
+      () => {
+        /* timeout completed cleanly */
+      },
+      (err) => reject(err)
+    );
   });
 };

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

@@ -15,7 +15,12 @@ export const presenceInRoom = async (
   const unsubscribe = () => client.off('stanza', stanzaHandler);
   const stanzaId = nextPresenceId();
 
-  return new Promise(async (resolve, reject) => {
+  // Avoid `new Promise(async (resolve, reject) => …)` — the async
+  // executor's own thrown errors / unhandled rejections inside it can
+  // escape the constructed promise depending on the order of catch
+  // attachment vs rejection. Use a regular Promise + a separate async
+  // wrapper that funnels every failure path through reject().
+  return new Promise<Element>((resolve, reject) => {
     let settled = false;
 
     const finish = (cb: (value?: any) => void, value?: any) => {
@@ -50,13 +55,23 @@ export const presenceInRoom = async (
       xml('x', { xmlns: 'http://jabber.org/protocol/muc' })
     );
 
-    try {
-      await client.send(presence);
-    } catch (err) {
-      unsubscribe();
-      return [];
-    }
-
-    await createTimeoutPromise(2000, unsubscribe).catch(reject);
+    // Side-effects sequence: send the presence (handles its own
+    // failure → reject), then wait the timeout (also handles its own
+    // failure → reject). Each chain attaches its rejection handler
+    // synchronously, so no race with the outer Promise's catch.
+    (async () => {
+      try {
+        await client.send(presence);
+      } catch (err) {
+        unsubscribe();
+        reject(err);
+        return;
+      }
+      try {
+        await createTimeoutPromise(2000, unsubscribe);
+      } catch (err) {
+        reject(err);
+      }
+    })();
   });
 };

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

@@ -51,6 +51,7 @@ export const sendTextMessage = (
       : `send-text-message-${Date.now()}-${(_sendTextSeq = (_sendTextSeq + 1) >>> 0)}`;
 
   try {
+    const dataXmlns = toServiceXmlns(devServer, client);
     const message = xml(
       'message',
       {
@@ -59,7 +60,7 @@ export const sendTextMessage = (
         id: id,
       },
       xml('data', {
-        xmlns: toServiceXmlns(devServer, client),
+        xmlns: dataXmlns,
         senderFirstName: firstName,
         senderLastName: lastName,
         fullName: `${firstName} ${lastName}`,