@ethora/chat-component-rn 26.9.1 → 26.10.0

package/src/hooks/useMessageQueue.ts

@@ -26,13 +26,15 @@ const addRoomToProcessed = (
   processedRooms: React.MutableRefObject<Set<string>>,
   rooms: { [jid: string]: IRoom }
 ) => {
+  // A room that left the list while queued has nothing to trim.
+  if (!rooms[queueRoom.jid]) {return;}
   if (
     queueRoom.messageCount >= 20 &&
     !processedRooms.current.has(queueRoom.jid)
   ) {
     processedRooms.current.add(queueRoom.jid);
     console.log(`Marking room: ${queueRoom.jid} as processed`);
-    if (rooms[queueRoom.jid].messages.length >= 30) {
+    if ((rooms[queueRoom.jid].messages?.length ?? 0) >= 30) {
       console.log(`Trimming messages for room: ${queueRoom.jid}`);
       rooms[queueRoom.jid].messages = rooms[queueRoom.jid].messages.slice(-30);
     }
@@ -61,7 +63,7 @@ export const useMessageQueue = (
     try {
       if (
         queueRoom.messageCount < 30 &&
-        !rooms[queueRoom.jid].historyComplete
+        !rooms[queueRoom.jid]?.historyComplete
       ) {
         console.log(`Loading messages for room: ${queueRoom.jid}`);
         dispatch(setIsLoading({ chatJID: queueRoom.jid, loading: true }));
@@ -75,7 +77,7 @@ export const useMessageQueue = (
 
         if (
           queueRoom.messageCount + queueRoom.messages.length < 30 &&
-          !rooms[queueRoom.jid].historyComplete
+          !rooms[queueRoom.jid]?.historyComplete
         ) {
           console.log(`Re-queuing room: ${queueRoom.jid} for more messages`);
           messageQueue.current.push({
@@ -111,14 +113,16 @@ export const useMessageQueue = (
       await Promise.all(
         roomsToProcess.map(async (room) => {
           try {
-            if (room.messageCount < 30 && !rooms[room.jid].historyComplete) {
+            // A room that left the list while queued is dropped, not retried.
+            if (!rooms[room.jid]) {return;}
+            if (room.messageCount < 30 && !rooms[room.jid]?.historyComplete) {
               console.log(`Loading messages for room: ${room.jid}`);
               dispatch(setIsLoading({ chatJID: room.jid, loading: true }));
               await loadMessages(room.jid, 20, Number(room.lastMessageId));
 
               if (
                 room.messageCount + 20 < 30 &&
-                !rooms[room.jid].historyComplete
+                !rooms[room.jid]?.historyComplete
               ) {
                 console.log(`Re-queuing room: ${room.jid} for more messages`);
                 queue.push({

package/src/hooks/useRoomDirectory.ts

@@ -0,0 +1,39 @@
+import { useEffect, useSyncExternalStore } from 'react';
+import {
+  ensureRoomDirectory,
+  getRoomDirectoryMembers,
+  getRoomDirectoryState,
+  subscribeUserResolver,
+  type RoomDirectoryState,
+} from '../helpers/userResolver';
+import type { RoomMember } from '../types/types';
+
+const NO_MEMBERS: RoomMember[] = [];
+
+/**
+ * Directory of a big room (usersCnt > the members the API returned).
+ * `enabled` starts the (once per room, deduplicated) load; the result grows
+ * page by page. Rooms that are not truncated never trigger a request.
+ */
+export const useRoomDirectory = (
+  roomJid: string | undefined,
+  enabled: boolean
+): { members: RoomMember[]; state: RoomDirectoryState } => {
+  const jid = roomJid || '';
+  const members = useSyncExternalStore(
+    subscribeUserResolver,
+    () => (jid ? getRoomDirectoryMembers(jid) : NO_MEMBERS),
+    () => NO_MEMBERS
+  );
+  const state = useSyncExternalStore(
+    subscribeUserResolver,
+    () => (jid ? getRoomDirectoryState(jid) : 'idle'),
+    () => 'idle' as RoomDirectoryState
+  );
+
+  useEffect(() => {
+    if (enabled && jid) ensureRoomDirectory(jid);
+  }, [enabled, jid]);
+
+  return { members, state };
+};

package/src/hooks/useRoomInitialization.tsx

@@ -1,5 +1,9 @@
-import { useEffect } from 'react';
-import { setIsLoading } from '../roomStore/roomsSlice';
+import { useEffect, useRef } from 'react';
+import {
+  clearJoiningRoom,
+  setIsLoading,
+  setJoiningRoom,
+} from '../roomStore/roomsSlice';
 import { useXmppClient } from '../context/xmppProvider';
 import { IConfig, IMessage, IRoom } from '../types/types';
 import { useDispatch, useSelector, useStore } from 'react-redux';
@@ -51,6 +55,11 @@ export const useRoomInitialization = (
 
   const syncRooms = useGetNewArchRoom();
 
+  // Rooms whose join flag this mount already raised. The effect below re-runs
+  // as the room list settles; only the first run owns the flag, so a re-run
+  // cannot clear it from under a join that is still in flight.
+  const joinFlagRef = useRef<Set<string>>(new Set());
+
   // Fast active-room join. Mirrors web's first effect: as soon as the
   // active room changes, eagerly send presence + ask for room info so
   // the header populates and the MUC join lets MAM history flow.
@@ -118,11 +127,28 @@ export const useRoomInitialization = (
 
     const initialPresenceAndHistory = async () => {
       if (!roomsList[activeRoomJID] && activeRoomJID && client) {
-        await client.presenceInRoomStanza(activeRoomJID);
-        if (config?.newArch) {
-          await syncRooms(client, config);
-        } else {
-          await client.getRoomsStanza();
+        // Entering a room we are not a member of yet (the public chats
+        // directory, a link, a QR code). Until it shows up in the room list
+        // the pane says "joining" (ChatRoom reads joiningRoomJID) instead of
+        // flashing the "choose a chat" placeholder the user just left.
+        const joinJid = activeRoomJID;
+        const ownsJoinFlag = !joinFlagRef.current.has(joinJid);
+        if (ownsJoinFlag) {
+          joinFlagRef.current.add(joinJid);
+          dispatch(setJoiningRoom(joinJid));
+        }
+        try {
+          await client.presenceInRoomStanza(activeRoomJID);
+          if (config?.newArch) {
+            await syncRooms(client, config);
+          } else {
+            await client.getRoomsStanza();
+          }
+        } finally {
+          if (ownsJoinFlag) {
+            joinFlagRef.current.delete(joinJid);
+            dispatch(clearJoiningRoom(joinJid));
+          }
         }
         await getDefaultHistory();
       } else {

package/src/hooks/useRoomMute.ts

@@ -0,0 +1,42 @@
+import { useCallback } from 'react';
+import { useDispatch, useStore } from 'react-redux';
+import type { RootState } from '../roomStore';
+import { updateRoom } from '../roomStore/roomsSlice';
+import { setRoomMuted } from '../networking/api-requests/rooms.api';
+
+/** Rooms with a mute request in flight: a second tap waits for the first. */
+const inFlight = new Set<string>();
+
+/**
+ * Mute / unmute a chat's notifications, shared by the chat profile and the
+ * room-list swipe. Optimistic: the bell flips at once, the server's answer
+ * wins, and a failure flips it back. Resolves false on that failure, so the
+ * caller can say so in its own way (the profile toasts, the list alerts).
+ */
+export const useRoomMute = () => {
+  const dispatch = useDispatch();
+  const store = useStore<RootState>();
+  return useCallback(
+    async (jid: string): Promise<boolean> => {
+      const room = store.getState().rooms.rooms[jid];
+      if (!room?.jid || !room?.name || inFlight.has(jid)) {return true;}
+      const next = !room.muted;
+      inFlight.add(jid);
+      dispatch(updateRoom({ jid, updates: { muted: next } }));
+      try {
+        const confirmed = await setRoomMuted(room.name, next);
+        if (confirmed !== next) {
+          dispatch(updateRoom({ jid, updates: { muted: confirmed } }));
+        }
+      } catch (error) {
+        dispatch(updateRoom({ jid, updates: { muted: !next } }));
+        console.warn('[ethora-rn] mute toggle failed', error);
+        return false;
+      } finally {
+        inFlight.delete(jid);
+      }
+      return true;
+    },
+    [dispatch, store]
+  );
+};

package/src/hooks/useRoomState.tsx

@@ -27,6 +27,11 @@ export const useRoomState = (roomJID?: string) => {
     (state: RootState) => state.rooms.loadingText
   );
   const usersSet = useSelector((state: RootState) => state.rooms.usersSet);
+  const joiningRoomJID = useSelector((state: RootState) =>
+    typeof state.rooms?.joiningRoomJID === 'string'
+      ? state.rooms.joiningRoomJID
+      : null
+  );
 
   const roomMessages = useMemo(
     () =>
@@ -47,5 +52,6 @@ export const useRoomState = (roomJID?: string) => {
     loading,
     roomMessages,
     usersSet,
+    joiningRoomJID,
   };
 };

package/src/hooks/useSendMessage.tsx

@@ -190,6 +190,16 @@ export const useSendMessage = (_configOverride?: IConfig) => {
           id: selfId,
           name: `${user?.firstName || ''} ${user?.lastName || ''}`.trim() || selfId,
         } as any,
+        // Thread replies: without these the optimistic copy has no
+        // mainMessage, so it shows in the channel instead of the thread
+        // until the echo lands.
+        ...(isReply
+          ? {
+              isReply: 'true' as any,
+              showInChannel: (isChecked ? 'true' : 'false') as any,
+              mainMessage: mainMessage || '',
+            }
+          : {}),
       } as IMessage;
       // On retry (`existingId`) the original optimistic bubble is still in
       // the room (pending:true) — clearMessageFailure just flipped it back out
@@ -443,7 +453,6 @@ export const useSendMessage = (_configOverride?: IConfig) => {
               isDeleted: false,
               xmppId: id,
               xmppFrom: `${activeRoomJID}/${selfId}`,
-              isSystemMessage: 'false',
               isMediafile: 'true',
               fileName: data?.name,
               location: normalizedFileUri,
@@ -451,6 +460,8 @@ export const useSendMessage = (_configOverride?: IConfig) => {
               mimetype: type,
               originalName: data?.name,
               size: fileSizeStr,
+              duration: data?.duration,
+              waveForm: data?.waveForm,
               isReply: isReply ? 'true' : 'false',
               showInChannel: `${isChecked}`,
               mainMessage,
@@ -590,7 +601,8 @@ export const useSendMessage = (_configOverride?: IConfig) => {
             originalName: item?.originalname,
             ownerKey: item?.ownerKey,
             size: item.size,
-            duration: item?.duration,
+            duration: item?.duration ?? data?.duration,
+            waveForm: data?.waveForm,
             updatedAt: item?.updatedAt,
             userId: item?.userId,
             attachmentId: item?._id,