@ethora/chat-component-rn 26.7.10 → 26.8.1

package/src/hooks/useChatWrapperInit.ts

@@ -3,13 +3,15 @@
 import { useEffect, useRef, useState } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
 import { IConfig } from '../types/types';
+import { resolveLegacyTranslatesLangSource } from '../helpers/resolveLangSource';
 import XmppClient from '../networking/xmppClient';
 import { AppDispatch, RootState } from '../roomStore';
 import { useXmppClient } from '../context/xmppProvider';
 import { chatAutoEnterer } from '../helpers/chatAutoEnterer';
 import { initRoomsPresence } from '../helpers/initRoomsPresence';
+import { updatedChatLastTimestamps } from '../helpers/updatedChatLastTimestamps';
 import { updateMessagesTillLast } from '../helpers/updateMessagesTillLast';
-import { refreshAuthTokensQuietly } from '../networking/authRefresh';
+import { refresh } from '../networking/apiClient';
 import { setLangSource, setConfig } from '../roomStore/chatSettingsSlice';
 import { setIsLoading } from '../roomStore/roomsSlice';
 import { useRoomState } from './useRoomState';
@@ -17,7 +19,6 @@ import { useChatSettingState } from './useChatSettingState';
 import { isChatIdPresentInArray } from '../helpers/isChatIdPresentInArray';
 import useGetNewArchRoom from './useGetNewArchRoom';
 import { getRoomsWithRetry } from '../helpers/getRoomsWithRetry';
-import { shallowEqual } from '../helpers/shallowEqual';
 
 interface useChatWrapperInitProps {
   roomJID: string | null | undefined;
@@ -65,20 +66,6 @@ const useChatWrapperInit = ({
     };
   }, [user.xmppPassword]);
 
-  // Presentational config flags (e.g. `disableHeader`) can change while the
-  // chat stays mounted — sync them to redux whenever `config` actually
-  // changes, not just at init. Shallow-equal guard: an inline object
-  // literal from the host is a fresh reference every render even when
-  // nothing in it changed, and dispatching unconditionally would re-render
-  // every config consumer on every host render.
-  const lastSyncedConfigRef = useRef<IConfig | undefined>(undefined);
-  useEffect(() => {
-    if (!shallowEqual(lastSyncedConfigRef.current, config)) {
-      lastSyncedConfigRef.current = config;
-      dispatch(setConfig(config));
-    }
-  }, [config, dispatch]);
-
   const getRoomsWithRertyRequest = async () => {
     setIsRetrying(true);
     const retryRooms = await getRoomsWithRetry(
@@ -111,8 +98,11 @@ const useChatWrapperInit = ({
     let retryTimeout: NodeJS.Timeout;
 
     const initXmmpClient = async () => {
-      if (config?.translates?.enabled && !config?.translates?.translations) {
-        dispatch(setLangSource(config?.translates?.translations));
+      const legacyLangSource = resolveLegacyTranslatesLangSource(
+        config?.translates
+      );
+      if (legacyLangSource) {
+        dispatch(setLangSource(legacyLangSource));
       }
 
       dispatch(setConfig(config));
@@ -169,21 +159,15 @@ const useChatWrapperInit = ({
                 }
               }
               try {
-                // getChatsPrivateStoreRequestStanza hydrates redux itself
-                // (dispatch(applyPrivateStoreMarkers(...)) internally,
-                // clamped + forward-only) - do not also apply the raw
-                // return value here. That used to double-dispatch via
-                // updatedChatLastTimestamps' unconditional
-                // setLastViewedTimestamp, which has neither the
-                // forward-only guard nor the future-marker clamp, so on
-                // every reconnect it could silently re-clobber a value
-                // the clamp had just corrected (bug #38).
                 const roomTimestampObject: any =
                   await newClient.getChatsPrivateStoreRequestStanza();
                 console.log(
                   'Got chats private store',
                   roomTimestampObject?.length || 0
                 );
+                if (roomTimestampObject) {
+                  updatedChatLastTimestamps(roomTimestampObject, dispatch);
+                }
                 if (!hasSyncedHistoryRef.current) {
                   console.log('Updating messages till last');
                   await updateMessagesTillLast(rooms, newClient);
@@ -199,7 +183,7 @@ const useChatWrapperInit = ({
               }
 
               {
-                config?.refreshTokens?.enabled && refreshAuthTokensQuietly();
+                config?.refreshTokens?.enabled && refresh();
               }
             } catch (error) {
               console.error(' Error during initialization', error);
@@ -225,15 +209,15 @@ const useChatWrapperInit = ({
             setInited(true);
             console.log(' Getting chats private store for existing client');
             try {
-              // See the "new client" branch above: getChatsPrivateStoreRequestStanza
-              // already hydrates redux (clamped + forward-only); do not
-              // also apply the raw return value here.
               const roomTimestampObject: any =
                 await client.getChatsPrivateStoreRequestStanza();
               console.log(
                 'Got chats private store for existing client',
                 roomTimestampObject?.length || 0
               );
+              if (roomTimestampObject) {
+                updatedChatLastTimestamps(roomTimestampObject, dispatch);
+              }
               if (!hasSyncedHistoryRef.current) {
                 console.log(
                   'Updating messages till last for existing client'
@@ -253,7 +237,7 @@ const useChatWrapperInit = ({
               setConnectionLost(false);
             }
             {
-              config?.refreshTokens?.enabled && refreshAuthTokensQuietly();
+              config?.refreshTokens?.enabled && refresh();
             }
           }
         }

package/src/hooks/useComposing.tsx

@@ -1,5 +1,4 @@
-import { useCallback, useEffect, useRef } from 'react';
-import { AppState, AppStateStatus } from 'react-native';
+import { useCallback, useEffect, useState } from 'react';
 import { useXmppClient } from '../context/xmppProvider';
 import { useSelector } from 'react-redux';
 import { RootState } from '../roomStore';
@@ -10,16 +9,8 @@ const useComposing = (config?: IConfig) => {
   const { client } = useXmppClient();
   const { activeRoomJID } = useSelector((state: RootState) => state.rooms);
   const { user } = useChatSettingState();
-  // RN keeps a focused TextInput focused when the app is backgrounded or
-  // the device is locked — nothing fires `onBlur`, so without this the
-  // other participant sees "typing…" for as long as the user is away.
-  // Tracks whether the input is *currently* focused, independent of the
-  // foreground/background transition, so we know whether to resume
-  // composing on return.
-  const isFocusedRef = useRef(false);
 
   const sendStartComposing = useCallback(() => {
-    isFocusedRef.current = true;
     if (config?.disableTypingIndicator) {
       return;
     }
@@ -33,7 +24,6 @@ const useComposing = (config?: IConfig) => {
   }, [activeRoomJID, client, config?.disableTypingIndicator, user.firstName, user.lastName]);
 
   const sendEndComposing = useCallback(() => {
-    isFocusedRef.current = false;
     if (config?.disableTypingIndicator) {
       return;
     }
@@ -54,32 +44,6 @@ const useComposing = (config?: IConfig) => {
     return () => clearTimeout(timerId);
   }, [sendEndComposing]);
 
-  // Foreground/background transition only — a pause in typing must NOT
-  // clear the indicator (that would flicker for a slowly-composing user),
-  // so this deliberately does not hook keystroke/idle timing at all.
-  useEffect(() => {
-    const handleAppStateChange = (nextState: AppStateStatus) => {
-      if (nextState !== 'active') {
-        if (isFocusedRef.current && !config?.disableTypingIndicator && client) {
-          client.sendTypingRequestStanza(
-            activeRoomJID || '',
-            `${user.firstName} ${user.lastName}`,
-            false
-          );
-        }
-      } else if (isFocusedRef.current && !config?.disableTypingIndicator && client) {
-        client.sendTypingRequestStanza(
-          activeRoomJID || '',
-          `${user.firstName} ${user.lastName}`,
-          true
-        );
-      }
-    };
-
-    const subscription = AppState.addEventListener('change', handleAppStateChange);
-    return () => subscription.remove();
-  }, [activeRoomJID, client, config?.disableTypingIndicator, user.firstName, user.lastName]);
-
   return { sendStartComposing, sendEndComposing };
 };
 

package/src/hooks/useLogout.tsx

@@ -9,8 +9,7 @@ import { clearHeap } from '../roomStore/roomHeapSlice';
 import { pushSubscriptionService } from '../services/pushSubscriptionService';
 import { clearRoomsRestCache } from '../networking/api-requests/rooms.api';
 import { clearPersistedState } from '../roomStore/persistence';
-import { secureUserStorage } from '../helpers/secureUserStorage';
-import { getFlushBoundaryTs } from '../helpers/getServerReadTimestamp';
+import { localStorageConstants } from '../helpers/constants/LOCAL_STORAGE';
 
 // AsyncStorage keys the library writes but that aren't cleared by any
 // slice reducer. Listed here so a single logout call wipes the full
@@ -60,23 +59,10 @@ const logoutService = {
       const client = (state.chatSettingStore as any)?.client;
       const rooms = state.rooms?.rooms;
       const visibleRoomJID = state.rooms?.visibleRoomJID || null;
-      // The visible room is exempt from `onlyIfNoUnread`'s skip (it's
-      // meant to write "read up to now" for whatever's open), so if the
-      // user is logging out while scrolled up with unread messages
-      // above, the boundary must still be carried through here - same
-      // reasoning as every other "leaving a room" path (bug #42).
-      const boundaryTs = visibleRoomJID
-        ? getFlushBoundaryTs(
-            rooms?.[visibleRoomJID],
-            state.roomHeapSlice,
-            state.rooms?.readBoundaries?.[visibleRoomJID] ?? null
-          )
-        : undefined;
       if (client?.flushLastViewedToPrivateStoreStanza) {
         await Promise.race([
           client.flushLastViewedToPrivateStoreStanza(rooms, {
             visibleRoomJID,
-            visibleRoomTs: boundaryTs,
             onlyIfNoUnread: true,
           }),
           new Promise((res) => setTimeout(res, 2000)),
@@ -134,23 +120,17 @@ const logoutService = {
 
     // 6. Stray keys the slices don't touch.
     try {
-      await AsyncStorage.multiRemove(LIBRARY_STRAY_KEYS);
+      await AsyncStorage.multiRemove([
+        ...LIBRARY_STRAY_KEYS,
+        // Belt-and-suspenders: the chat slice's `logout` reducer
+        // schedules an async remove of ETHORA_USER fire-and-forget;
+        // re-issue it here so the disk is provably clean before this
+        // Promise resolves.
+        localStorageConstants.ETHORA_USER,
+      ]);
     } catch (e) {
       console.warn('logoutService: stray-key clear failed', e);
     }
-
-    // 7. Belt-and-suspenders: the chat slice's `logout` reducer already
-    //    fires an async ETHORA_USER removal, but re-issue it here (via
-    //    the same secureUserStorage split the reducer uses) so BOTH the
-    //    plain-AsyncStorage profile half AND the Keychain/Keystore
-    //    secrets are provably gone before this Promise resolves — a bare
-    //    `AsyncStorage.removeItem(ETHORA_USER)` here would only clear the
-    //    profile half and leave the tokens behind.
-    try {
-      await secureUserStorage().remove();
-    } catch (e) {
-      console.warn('logoutService: secure user storage clear failed', e);
-    }
   },
 };
 

package/src/hooks/usePendingNotification.ts

@@ -4,7 +4,7 @@ import AsyncStorage from '@react-native-async-storage/async-storage';
 import { RootState } from '../roomStore';
 import { setCurrentRoom, clearPendingNotificationJid } from '../roomStore/roomsSlice';
 
-import { PENDING_NOTIFICATION_JID_KEY, readPendingJid } from '../helpers/pushPayload';
+const PENDING_NOTIFICATION_JID_KEY = 'ethora_pending_notification_jid';
 
 export function usePendingNotification() {
   const dispatch = useDispatch();
@@ -21,15 +21,21 @@ export function usePendingNotification() {
       let jidToOpen = pendingNotificationJid;
 
       if (!jidToOpen) {
-        jidToOpen = await readPendingJid();
+        try {
+          const storedJid = await AsyncStorage.getItem(PENDING_NOTIFICATION_JID_KEY);
+          if (storedJid) {
+            jidToOpen = storedJid;
+            await AsyncStorage.removeItem(PENDING_NOTIFICATION_JID_KEY);
+          }
+        } catch (error) {
+          console.error('Error reading from AsyncStorage:', error);
+        }
       }
 
       if (jidToOpen) {
         const room = rooms[jidToOpen];
         if (room) {
-          dispatch(clearPendingNotificationJid());
-          AsyncStorage.removeItem(PENDING_NOTIFICATION_JID_KEY).catch(() => undefined);
-          dispatch(setCurrentRoom({ roomJID: jidToOpen }));
+          return;
         }
       }
     };

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,
   };
 };