@ethora/chat-component-rn 26.7.9 → 26.8.1

package/src/hooks/useSendMessage.tsx

@@ -9,8 +9,8 @@ import {
   clearMessageFailure,
   markMessageFailed,
 } from '../roomStore/roomHeapSlice';
-import { uploadFileV2 } from '../networking/api-requests/auth.api';
-import { enqueueOutboundSend, removeOutboundSend } from '../networking/outboundQueue';
+import { uploadFileViaFetch } from '../networking/api-requests/auth.api';
+import { enqueueOutboundSend } from '../networking/outboundQueue';
 import { RootState, store } from '../roomStore';
 import { getGlobalXmppClient } from '../utils/clientRegistry';
 import { useEventHandlers } from './useEventHandlers';
@@ -182,45 +182,17 @@ export const useSendMessage = (_configOverride?: IConfig) => {
       // PENDING_WATCHDOG_MS, flip the bubble to "failed → tap to
       // retry". We check at fire-time whether the message is still
       // pending and not already marked failed by the catch path.
-      // One-shot extension for the case below. Declared outside the
-      // timer so the rescheduled run can't extend again.
-      let watchdogExtended = false;
-      const runWatchdog = () => {
+      const watchdogTimer = setTimeout(() => {
         const state = reduxStore.getState();
         const roomMsgs = state.rooms?.rooms?.[activeRoomJID]?.messages || [];
         const stillPending = roomMsgs.find(
           (m: any) => m.id === optimisticId && m.pending
         );
         const alreadyFailed = state.roomHeapSlice?.failedMessages?.[optimisticId];
-
-        // Don't call it a failure while the stream is still coming back.
-        // A reconnect tears the old client down and builds a new one, and
-        // any echo in flight during that window is simply lost — the
-        // message may well have been delivered (it has been observed
-        // arriving twice on the receiving side). Failing it here shows a
-        // red "tap to retry" under a message that actually went through.
-        // Give the reconnect one more window to produce an echo, once.
-        const streamOnline = getGlobalXmppClient()?.status === 'online';
-        if (stillPending && !alreadyFailed && !streamOnline && !watchdogExtended) {
-          watchdogExtended = true;
-          console.warn(
-            `Send watchdog — ${optimisticId} still pending but the stream is not online; extending one window`
-          );
-          watchdogTimer = setTimeout(runWatchdog, PENDING_WATCHDOG_MS);
-          return;
-        }
-
         if (stillPending && !alreadyFailed) {
           console.warn(
             `Send watchdog fired — message ${optimisticId} stuck pending > ${PENDING_WATCHDOG_MS}ms; marking failed`
           );
-          // Drop the buffered replay now that the bubble is showing
-          // "failed / tap to retry" — a later onOnline flush must not
-          // silently resend it behind the user's back. If the original
-          // send actually lands after this point, the server echo still
-          // flips the bubble back to delivered (newMessageMidlleware);
-          // only an explicit tap-to-retry should trigger another send.
-          removeOutboundSend(optimisticId);
           dispatch(
             markMessageFailed({
               kind: 'text',
@@ -239,9 +211,7 @@ export const useSendMessage = (_configOverride?: IConfig) => {
             messageType: 'text',
           });
         }
-      };
-
-      let watchdogTimer = setTimeout(runWatchdog, PENDING_WATCHDOG_MS);
+      }, PENDING_WATCHDOG_MS);
 
       try {
         // The single send closure, used both for the immediate send and for
@@ -315,9 +285,6 @@ export const useSendMessage = (_configOverride?: IConfig) => {
         });
       } catch (error) {
         clearTimeout(watchdogTimer);
-        // Same reasoning as the watchdog: once the bubble shows failed,
-        // only an explicit tap-to-retry should resend it.
-        removeOutboundSend(optimisticId);
         dispatch(
           markMessageFailed({
             kind: 'text',
@@ -464,10 +431,6 @@ export const useSendMessage = (_configOverride?: IConfig) => {
           console.warn(
             `Media-send watchdog fired — ${id} stuck pending > ${PENDING_WATCHDOG_MS}ms; marking failed`
           );
-          // See the text-send watchdog above: drop the buffered replay so
-          // a later onOnline flush can't silently resend behind the
-          // "failed / tap to retry" bubble.
-          removeOutboundSend(id);
           dispatch(
             markMessageFailed({
               kind: 'media',
@@ -504,11 +467,19 @@ export const useSendMessage = (_configOverride?: IConfig) => {
         name: data?.name || data?.fileName || `media_${Date.now()}`,
       };
 
+      // Mirror the web client: a single multipart POST to /files/ with
+      // the file under the plural "files" field. We send it via fetch
+      // (not axios) because RN's fetch sets the multipart boundary on the
+      // Content-Type header correctly. The previous axios fallback omitted
+      // a valid boundary, so the server mis-parsed one file as many and
+      // rejected the request with HTTP 413 "TOO_MANY_FILES". The only
+      // retry is the documented singular-"file" fallback for deployments
+      // that 500 on the plural field (bug #10).
       const tryUpload = async () => {
         const fd = new FormData();
         fd.append('files', fileBlob as any);
         try {
-          return await uploadFileV2(fd, activeRoomJID);
+          return await uploadFileViaFetch(fd);
         } catch (err: any) {
           if (err?.response?.status === 500) {
             console.warn(
@@ -517,7 +488,7 @@ export const useSendMessage = (_configOverride?: IConfig) => {
             );
             const fd2 = new FormData();
             fd2.append('file', fileBlob as any);
-            return await uploadFileV2(fd2, activeRoomJID);
+            return await uploadFileViaFetch(fd2);
           }
           throw err;
         }
@@ -675,22 +646,6 @@ export const useSendMessage = (_configOverride?: IConfig) => {
     async (failedId: string) => {
       const payload = failedMessages[failedId];
       if (!payload) {return;}
-
-      // The server may have accepted the original send even though its
-      // echo arrived too late to beat the watchdog — the bubble shows
-      // failed, but a confirmed (non-pending) copy is already sitting in
-      // the room. Resending here would deliver a genuine duplicate; just
-      // clear the failure and let the existing copy stand.
-      const roomMsgs = rooms?.[payload.roomJID]?.messages || [];
-      const alreadyDelivered = roomMsgs.some(
-        (m: any) =>
-          !m.pending && (m.id === failedId || m.xmppId === failedId)
-      );
-      if (alreadyDelivered) {
-        dispatch(clearMessageFailure(failedId));
-        return;
-      }
-
       dispatch(clearMessageFailure(failedId));
       handleMessageRetry({
         messageId: failedId,
@@ -720,7 +675,7 @@ export const useSendMessage = (_configOverride?: IConfig) => {
         );
       }
     },
-    [failedMessages, rooms, dispatch, handleMessageRetry, sendMessage, sendMedia]
+    [failedMessages, dispatch, handleMessageRetry, sendMessage, sendMedia]
   );
 
   // ChatRoom/ThreadWrapper consume this as the "edit branch" of send.

package/src/hooks/useUnreadMessagesCounter.ts

@@ -11,12 +11,6 @@ interface UnreadMessagesStats {
   totalCount: number;
   unreadByRoom: UnreadMessagesMap;
   isLoading: boolean;
-  // True while at least one room's unread count could still be a floor
-  // rather than the true total — the history-preload scheduler paged back
-  // as far as its catch-up budget allows without finding the read
-  // boundary. Lets a host show "99+"-style affordances honestly instead of
-  // implying an exact count it can't back up.
-  isCapped: boolean;
 }
 
 export const useUnreadMessagesCounter = (): UnreadMessagesStats => {
@@ -41,7 +35,6 @@ export const useUnreadMessagesCounter = (): UnreadMessagesStats => {
   const rooms = roomsState.rooms;
   const unreadByRoom: UnreadMessagesMap = {};
   let totalCount = 0;
-  let isCapped = false;
 
   Object.entries(rooms).forEach(([roomJid, room]: [string, IRoom]) => {
     const unreadCount = room.unreadMessages || 0;
@@ -49,9 +42,6 @@ export const useUnreadMessagesCounter = (): UnreadMessagesStats => {
       unreadByRoom[roomJid] = unreadCount;
       totalCount += unreadCount;
     }
-    if ((room as any)?.unreadCapped) {
-      isCapped = true;
-    }
   });
 
   return {
@@ -59,7 +49,6 @@ export const useUnreadMessagesCounter = (): UnreadMessagesStats => {
     totalCount,
     unreadByRoom,
     isLoading: !!roomsState.isUnreadSyncing || !!roomsState.isLoading,
-    isCapped,
   };
 };