@ethora/chat-component-rn 26.9.0 → 26.10.0

package/src/roomStore/Middleware/jumpThreadMiddleware.ts

@@ -0,0 +1,163 @@
+import { Middleware } from '@reduxjs/toolkit';
+import {
+  clearJumpThread,
+  findMessageIndex,
+  getJumpThread,
+  JUMP_TTL_MS,
+  replyParentId,
+  setJumpThread,
+} from '../../helpers/jumpThread';
+import { IMessage } from '../../types/types';
+
+const find = (messages: IMessage[] | undefined, id: string) =>
+  (messages ?? []).find((message) => String(message.id) === id);
+
+const mergeUnique = (a: IMessage[], b: IMessage[]) => {
+  const seen = new Set(a.map((message) => String(message.id)));
+  return [...a, ...b.filter((message) => !seen.has(String(message.id)))];
+};
+
+/**
+ * Keeps the thread panel's parent (helpers/jumpThread) in step with the
+ * actions that open and close threads, without the room slice knowing about
+ * jump windows:
+ *  - closing a thread, leaving the room or logging out forgets it;
+ *  - opening a thread on a message that exists only in a jump window (the
+ *    live-list flag has nothing to flag) records that message and the replies
+ *    seen with it, so the panel can open;
+ *  - clearing the window while the panel shows a window-only parent: if the
+ *    parent has meanwhile reached the live list, the ordinary flag takes over;
+ *    otherwise the panel keeps the copy it already has.
+ *  - a jump request while a thread panel is open: the panel replaces the main
+ *    list, so no main-list instance exists to take the jump. Unless the target
+ *    is a reply of the open parent (the thread's own list serves it), the
+ *    thread is closed so the main list mounts; a reply of another parent is
+ *    then resolved by the normal flow, which opens that parent's thread;
+ *  - a request nobody owns is dropped shortly after its TTL, without the
+ *    "archived" card when the message is in the live list.
+ */
+// Slack after the TTL so an owner that is merely polling finishes first.
+const ORPHAN_GRACE_MS = 5000;
+
+export const jumpThreadMiddleware: Middleware =
+  (storeAPI) => (next) => (action: any) => {
+    const result = next(action);
+    const type = action?.type;
+
+    if (
+      type === 'roomMessages/setCloseActiveMessage' ||
+      type === 'roomMessages/setCurrentRoom' ||
+      type === 'roomMessages/setLogoutState' ||
+      // The settings slice is named 'chat', so its logout is 'chat/logout'.
+      type === 'chat/logout'
+    ) {
+      clearJumpThread();
+      return result;
+    }
+
+    if (type === 'roomMessages/requestJumpToMessage') {
+      const state = storeAPI.getState().rooms;
+      const jump = state.pendingJump;
+      if (!jump) {return result;}
+      const roomJID = jump.roomJID;
+      const live: IMessage[] = state.rooms?.[roomJID]?.messages ?? [];
+      const window = state.jumpWindow;
+      const pool = mergeUnique(
+        live,
+        window && window.roomJID === roomJID ? window.messages : []
+      );
+      const open = pool.find((message) => message.activeMessage);
+      if (open) {
+        const content = { createdAt: jump.createdAt, body: jump.body };
+        const index = findMessageIndex(pool, jump.ids, content);
+        const sameParent =
+          index >= 0 && replyParentId(pool[index]) === String(open.id);
+        if (sameParent) {
+          // The open thread serves this jump: make it the owner (a thread
+          // opened by hand owns nothing, so the jump would stay pending).
+          const held = getJumpThread();
+          const base =
+            held && held.parentId === String(open.id) ? held : null;
+          setJumpThread({
+            roomJID,
+            parentId: String(open.id),
+            at: jump.at,
+            parent: base?.parent ?? null,
+            replies: mergeUnique(base?.replies ?? [], [pool[index]]),
+          });
+        } else {
+          storeAPI.dispatch({
+            type: 'roomMessages/setCloseActiveMessage',
+            payload: { chatJID: roomJID },
+          });
+        }
+      }
+      const at = jump.at;
+      setTimeout(() => {
+        const now = storeAPI.getState().rooms;
+        const still = now.pendingJump;
+        if (!still || still.at !== at) {return;}
+        storeAPI.dispatch({ type: 'roomMessages/clearPendingJump' });
+        const inLive =
+          findMessageIndex(
+            now.rooms?.[still.roomJID]?.messages ?? [],
+            still.ids,
+            { createdAt: still.createdAt, body: still.body }
+          ) >= 0;
+        if (!inLive && still.preview) {
+          storeAPI.dispatch({
+            type: 'roomMessages/showArchivedMessage',
+            payload: still.preview,
+          });
+        }
+      }, JUMP_TTL_MS + ORPHAN_GRACE_MS);
+      return result;
+    }
+
+    if (type === 'roomMessages/setActiveMessage') {
+      const { id, chatJID } = action.payload ?? {};
+      const held = getJumpThread();
+      // A thread this jump just opened and flagged: nothing to do.
+      if (held && held.parentId === id && held.roomJID === chatJID) {
+        return result;
+      }
+      clearJumpThread();
+      const rooms = storeAPI.getState().rooms;
+      if (find(rooms.rooms?.[chatJID]?.messages, id)) {return result;}
+      const window = rooms.jumpWindow;
+      const parent =
+        window && window.roomJID === chatJID
+          ? find(window.messages, id)
+          : undefined;
+      if (parent) {
+        setJumpThread({
+          roomJID: chatJID,
+          parentId: id,
+          at: null,
+          parent,
+          replies: window!.messages.filter(
+            (message: IMessage) => replyParentId(message) === id
+          ),
+        });
+      }
+      return result;
+    }
+
+    if (type === 'roomMessages/clearJumpWindow') {
+      const held = getJumpThread();
+      if (!held?.parent) {return result;}
+      const live = find(
+        storeAPI.getState().rooms.rooms?.[held.roomJID]?.messages,
+        held.parentId
+      );
+      if (live) {
+        const { roomJID, parentId } = held;
+        clearJumpThread();
+        storeAPI.dispatch({
+          type: 'roomMessages/setActiveMessage',
+          payload: { id: parentId, chatJID: roomJID },
+        });
+      }
+    }
+    return result;
+  };

package/src/roomStore/Middleware/reactionsMiddleware.tsx

@@ -21,6 +21,10 @@ export const reactionsMiddleware: Middleware =
       return next(action);
     }
     const result = next(action);
+    // Reactions replayed from the archive update the target message only. The
+    // room preview showing an emoji is for LIVE reactions; a history replay
+    // would otherwise replace the latest real message with the emoji.
+    if (action.meta?.fromHistory) {return result;}
     try {
       const payload = action.payload || {};
       const { roomJID, reactions, latestReactionTimestamp, data } = payload;

package/src/roomStore/Middleware/unreadMidlleware.tsx

@@ -1,6 +1,7 @@
 import { Middleware } from '@reduxjs/toolkit';
 import { setUnreadCounts, msgSortableMs } from '../roomsSlice';
 import { IMessage } from '../../types/types';
+import { getTimestampFromUnknown } from '../../helpers/timestamp';
 
 // Per-room cache so we only recompute when something that affects the
 // count actually changed. The fingerprint is `<messages.length>|<lastViewed>`
@@ -73,6 +74,9 @@ const TRIGGER_ACTIONS = new Set([
   'roomMessages/setVisibleRoom',
   'roomMessages/clearVisibleRoom',
   'roomMessages/addRoom',
+  // A /chats/my refresh can bring a fresh server-reported unread count
+  // (apiUnreadCount) that has to reach the badge without any local history.
+  'roomMessages/addRoomFromApi',
   'roomMessages/updateRoom',
   // The history preload scheduler merges fetched pages via this action on
   // re-entry; recompute so unread reflects messages that arrived while the
@@ -161,10 +165,17 @@ export const unreadMiddleware: Middleware =
         if (room.unreadMessages !== 0) {counts[jid] = 0;}
         continue;
       }
+      // Server-reported unread (GET /v1/chats/my `unreadCount`): lets a room
+      // with no baseline and no loaded history still show a badge.
+      const apiUnread: number | undefined =
+        typeof room.apiUnreadCount === 'number' && room.apiUnreadCount > 0
+          ? room.apiUnreadCount
+          : undefined;
       // No reference point (undefined / null / 0): after logout→login,
       // hydrated rooms come back without lastViewedTimestamp, and treating
-      // that as 0 made every history message count as unread.
-      if (!(room.lastViewedTimestamp > 0)) {continue;}
+      // that as 0 made every history message count as unread. Only the API
+      // count can speak for such a room.
+      if (!(room.lastViewedTimestamp > 0) && apiUnread === undefined) {continue;}
 
       const msgs = room.messages;
       const currentMessagesLength = msgs?.length || 0;
@@ -172,7 +183,11 @@ export const unreadMiddleware: Middleware =
       const lastId = currentMessagesLength
         ? String(msgs![currentMessagesLength - 1]?.id ?? '')
         : '';
-      const fingerprint = `${currentMessagesLength}|${room.lastViewedTimestamp || 0}|${firstId}|${lastId}`;
+      const fingerprint = `${currentMessagesLength}|${room.lastViewedTimestamp || 0}|${firstId}|${lastId}|${room.apiUnreadCount ?? ''}|${room.apiUnreadSeededAt ?? ''}|${room.lastMessage?.date ?? ''}${
+        // Another reducer can reset the displayed count under an unchanged
+        // fingerprint; with a server count in play, recompute then too.
+        apiUnread !== undefined ? `|${room.unreadMessages ?? ''}` : ''
+      }`;
       if (triggerCache[jid] === fingerprint) {continue;}
       triggerCache[jid] = fingerprint;
 
@@ -182,15 +197,48 @@ export const unreadMiddleware: Middleware =
       // own messages so MAM-replayed sends on re-login don't bump
       // the user's own badge.
       const since = room.lastViewedTimestamp || 0;
+      const isCountable = (msg: IMessage) =>
+        msg.id !== 'delimiter-new' &&
+        !msg.pending &&
+        String((msg as any)?.isSystemMessage || '') !== 'true' &&
+        !isOwnMessage(msg, selfXmpp, selfWallet);
+      // Without a baseline (only reachable here via the API count) nothing
+      // can be counted locally: the whole history would read as unread.
       let unreadMessagesCount = 0;
-      for (const msg of msgs || []) {
-        if (
-          msg.id !== 'delimiter-new' &&
-          !msg.pending &&
-          msgSortableMs(msg) > since &&
-          !isOwnMessage(msg, selfXmpp, selfWallet)
-        ) {
-          unreadMessagesCount += 1;
+      if (since > 0) {
+        for (const msg of msgs || []) {
+          if (isCountable(msg) && msgSortableMs(msg) > since) {
+            unreadMessagesCount += 1;
+          }
+        }
+      }
+
+      // Server-reported unread as a floor while history is not (fully)
+      // loaded. No double counting: messages newer than the seed time are
+      // counted on top of the API number (they arrived after the server
+      // computed it); older loaded ones are NOT added (the API number
+      // already covers them) and the result is max(local, api + newer).
+      // Once the user has read past the API's last message the API number
+      // is stale and ignored.
+      if (apiUnread !== undefined) {
+        const seededAt = getTimestampFromUnknown(room.apiUnreadSeededAt);
+        const apiLastTs = getTimestampFromUnknown(room.lastMessage?.date);
+        const readPastApi = since > 0 && apiLastTs > 0 && since >= apiLastTs;
+        if (!readPastApi) {
+          let newerThanSeed = 0;
+          for (const msg of msgs || []) {
+            if (
+              isCountable(msg) &&
+              msgSortableMs(msg) > seededAt &&
+              msgSortableMs(msg) > since
+            ) {
+              newerThanSeed += 1;
+            }
+          }
+          unreadMessagesCount = Math.max(
+            unreadMessagesCount,
+            apiUnread + newerThanSeed
+          );
         }
       }
 

package/src/roomStore/chatSettingsSlice.ts

@@ -215,6 +215,16 @@ const reducers = {
       state.user.fileToken = action.payload.fileToken;
     }
   },
+  /**
+   * Just the XMPP credential, for POST /v1/users/xmpp-token. refreshTokens
+   * above needs a whole token pair, and minting only an XMPP password must
+   * not touch the REST session. Like refreshTokens, persistence belongs to
+   * the caller, which can await it.
+   */
+  setXmppPassword: (state: WritableDraft<ChatState>, action: PayloadAction<string>) => {
+    if (!action.payload) {return;}
+    state.user.xmppPassword = action.payload;
+  },
   logout: (state: WritableDraft<ChatState>) => {
     state.user = unpackAndTransform();
     state.config = undefined;
@@ -259,6 +269,7 @@ export const {
   setUser,
   setConfig,
   refreshTokens,
+  setXmppPassword,
   logout,
   setActiveModal,
   setDeleteModal,

package/src/roomStore/index.ts

@@ -8,13 +8,17 @@ import { unreadMiddleware } from './Middleware/unreadMidlleware';
 import { logoutMiddleware } from './Middleware/logoutMiddleware';
 import { newMessageMidlleware } from './Middleware/newMessageMidlleware';
 import { reactionsMiddleware } from './Middleware/reactionsMiddleware';
+import { jumpThreadMiddleware } from './Middleware/jumpThreadMiddleware';
 import { isPerfProfilingEnabled, perfMiddleware } from './Middleware/perfMiddleware';
 import {
   persistenceMiddleware,
   readPersistedState,
   computeBootTimeFailures,
+  resetSessionRoomState,
 } from './persistence';
 
+export { resetSessionRoomState };
+
 const rootReducer = combineReducers({
   chatSettingStore: chatSettingsReducer,
   rooms: roomsSlice,
@@ -44,6 +48,7 @@ const createChatStore = () =>
         unreadMiddleware,
         newMessageMidlleware,
         reactionsMiddleware,
+        jumpThreadMiddleware,
         logoutMiddleware,
         persistenceMiddleware,
       ];
@@ -81,9 +86,11 @@ export const persistorReady =
       store.dispatch(setUser(chat.user));
     }
     if (rooms?.rooms) {
-      const restored = Object.entries(rooms.rooms)
-        .filter(([jid, room]) => !!jid && !!room)
-        .map(([, room]) => room as IRoom);
+      // Per-session state (preload progress, the API unread snapshot) must
+      // not outlive the session that produced it.
+      const restored = Object.values(
+        resetSessionRoomState(rooms.rooms as Record<string, IRoom>)
+      ).filter((room) => !!room && !!room.jid) as IRoom[];
       if (restored.length) {
         store.dispatch(addRooms({ rooms: restored }));
       }

package/src/roomStore/persistence.ts

@@ -206,6 +206,42 @@ const sanitizeMessages = (messages: IMessage[]): IMessage[] => {
   return capped.map(compactMessageForPersist);
 };
 
+/**
+ * Room fields that describe ONE session and must never be written to disk:
+ * the server's unread snapshot (a moment-in-time number the next /chats/my
+ * re-seeds). Volatile slice state that is not on the room at all (jumpWindow,
+ * pendingJump, archivedMessage, usersSet) is never persisted because only
+ * `rooms.rooms` is picked from the slice.
+ */
+const SESSION_ROOM_FIELDS = ['apiUnreadCount', 'apiUnreadSeededAt'] as const;
+
+/**
+ * Rehydrate step: a persisted room must be refetched once per session, so
+ * a stale 'done' / 'loading' / 'error' preload state is demoted to
+ * 'partial' (the room has cached messages, a page that does not overlap the
+ * cache replaces it instead of leaving a hole) or 'idle'. The API unread
+ * snapshot is dropped: the next /chats/my response re-seeds it.
+ */
+export const resetSessionRoomState = (
+  roomsMap: Record<string, IRoom>
+): Record<string, IRoom> =>
+  Object.fromEntries(
+    Object.entries(roomsMap || {}).map(([jid, room]) => {
+      const state = room?.historyPreloadState;
+      const hasMessages = (room?.messages?.length ?? 0) > 0;
+      const next: IRoom = { ...room };
+      // 'error' is a per-session transient (a timeout, an IQ error): it must
+      // not stick across reloads, so it is demoted like 'loading'.
+      if (state === 'done' || state === 'loading' || state === 'error') {
+        next.historyPreloadState = hasMessages ? 'partial' : 'idle';
+      }
+      for (const field of SESSION_ROOM_FIELDS) {
+        if (next[field] !== undefined) {next[field] = undefined;}
+      }
+      return [jid, next];
+    })
+  );
+
 const sanitizeRooms = (
   rooms: Record<string, IRoom>
 ): Record<string, IRoom> => {
@@ -224,6 +260,9 @@ const sanitizeRooms = (
     for (const field of REFETCHED_ROOM_FIELDS) {
       delete compactRoom[field];
     }
+    for (const field of SESSION_ROOM_FIELDS) {
+      delete compactRoom[field];
+    }
     // The same reasoning, one size down: the full roster a room gets once
     // it is opened (loadRoomMembers) is re-fetched on the next open, so only
     // the preview-sized head of it is worth a place in the cache.
@@ -408,6 +447,8 @@ const ROOM_ACTIONS: Record<string, RoomTouch> = {
   'roomMessages/setRoomMessages': (p) => asList(p?.roomJID),
   'roomMessages/deleteRoomMessage': (p) => asList(p?.roomJID),
   'roomMessages/editRoomMessage': (p) => asList(p?.roomJID),
+  'roomMessages/removeRoomMessage': (p) => asList(p?.roomJID),
+  'roomMessages/setMessageTranslation': (p) => asList(p?.roomJID),
   'roomMessages/addRoomMessage': (p) => asList(p?.roomJID),
   'roomMessages/addRoomMessages': (p) => asList(p?.roomJID),
   'roomMessages/setReactions': (p) => asList(p?.roomJID),
@@ -439,6 +480,19 @@ const TRANSIENT_ROOM_ACTIONS = new Set([
   'roomMessages/clearReadBoundary',
   'roomMessages/setLoadingText',
   'roomMessages/mergeUsersSet',
+  // Volatile slice-level fields (search jump request, joining flag): not rooms data.
+  'roomMessages/requestJumpToMessage',
+  'roomMessages/clearPendingJump',
+  'roomMessages/setJoiningRoom',
+  'roomMessages/clearJoiningRoom',
+  // The reader's jump window and an archived-message view are separate,
+  // never-persisted copies; they leave the room's cached messages untouched.
+  'roomMessages/setJumpWindow',
+  'roomMessages/prependJumpWindowMessages',
+  'roomMessages/appendJumpWindowMessages',
+  'roomMessages/clearJumpWindow',
+  'roomMessages/showArchivedMessage',
+  'roomMessages/clearArchivedMessage',
 ]);
 
 const roomsTouchedBy = (action: any): string[] | 'all' | null => {