@ethora/chat-component-rn 26.8.5 → 26.8.6

package/src/roomStore/Middleware/unreadMidlleware.tsx

@@ -1,5 +1,5 @@
 import { Middleware } from '@reduxjs/toolkit';
-import { updateRoom, msgSortableMs } from '../roomsSlice';
+import { setUnreadCounts, msgSortableMs } from '../roomsSlice';
 import { IMessage } from '../../types/types';
 
 // Per-room cache so we only recompute when something that affects the
@@ -60,6 +60,8 @@ const isOwnMessage = (
 // 50 rooms × 100 messages that's 5000 Date() parses per modal click.
 const TRIGGER_ACTIONS = new Set([
   'roomMessages/addRoomMessage',
+  'roomMessages/addRoomMessages',
+  'roomMessages/addRooms',
   'roomMessages/setRoomMessages',
   'roomMessages/editRoomMessage',
   'roomMessages/setLastViewedTimestamp',
@@ -79,6 +81,41 @@ const TRIGGER_ACTIONS = new Set([
   'roomMessages/applyRoomsPreloadBatch',
 ]);
 
+// Which rooms an action can have changed the unread count of. Walking
+// every room on every message (the previous behaviour) made each incoming
+// message cost O(rooms); `'all'` is reserved for the few actions that move
+// several rooms' baselines at once.
+const touchedRooms = (action: any): string[] | 'all' => {
+  const p = action?.payload;
+  switch (action?.type) {
+    case 'roomMessages/addRoomMessage':
+    case 'roomMessages/addRoomMessages':
+    case 'roomMessages/setRoomMessages':
+    case 'roomMessages/editRoomMessage':
+      return p?.roomJID ? [p.roomJID] : [];
+    case 'roomMessages/setLastViewedTimestamp':
+      return p?.chatJID ? [p.chatJID] : [];
+    case 'roomMessages/addRoom':
+      return p?.roomData?.jid ? [p.roomData.jid] : [];
+    case 'roomMessages/addRooms':
+    case 'roomMessages/applyRoomsPreloadBatch':
+      return Array.isArray(p?.rooms)
+        ? p.rooms.map((r: any) => r?.jid).filter(Boolean)
+        : [];
+    case 'roomMessages/updateRoom': {
+      // The counts this middleware writes itself, and the room-list
+      // ordering stamp, never change what is unread.
+      const keys = Object.keys(p?.updates || {});
+      const relevant = keys.some(
+        (k) => k !== 'unreadMessages' && k !== 'lastMessageTimestamp'
+      );
+      return relevant && p?.jid ? [p.jid] : [];
+    }
+    default:
+      return 'all';
+  }
+};
+
 export const unreadMiddleware: Middleware =
   (storeAPI) => (next) => (action: any) => {
     if (!action || !action.type) {
@@ -105,92 +142,67 @@ export const unreadMiddleware: Middleware =
 
     const state = storeAPI.getState();
     const rooms = state.rooms.rooms;
+    if (!rooms) {return result;}
     const visibleRoomJID = state.rooms.visibleRoomJID;
     const selfUser = state.chatSettingStore?.user;
     const selfXmpp = selfUser?.xmppUsername || '';
     const selfWallet = selfUser?.walletAddress || '';
 
-    if (rooms && Object.keys(rooms).length > 0) {
-      Object.keys(rooms).forEach((jid) => {
-        const room = rooms[jid];
-        if (!room) {return;}
-        // Skip rooms the user is currently viewing — visibility clears the
-        // badge directly. Skip rooms with no reference point (covers
-        // undefined / null / 0) — after logout→login, hydrated rooms
-        // come back without lastViewedTimestamp, and treating that as 0
-        // made every history message satisfy `date > 0` and incorrectly
-        // bumped unread for already-seen content.
-        if (jid === visibleRoomJID) {
-          if (room.unreadMessages !== 0) {
-            storeAPI.dispatch(
-              updateRoom({
-                jid,
-                updates: { unreadMessages: 0 },
-              })
-            );
-          }
-          return;
-        }
-        if (!(room.lastViewedTimestamp > 0)) {return;}
-
-        const msgs = room.messages;
-        const currentMessagesLength = msgs?.length || 0;
-        const firstId = currentMessagesLength ? String(msgs![0]?.id ?? '') : '';
-        const lastId = currentMessagesLength
-          ? String(msgs![currentMessagesLength - 1]?.id ?? '')
-          : '';
-        const fingerprint = `${currentMessagesLength}|${room.lastViewedTimestamp || 0}|${firstId}|${lastId}`;
-        if (triggerCache[jid] === fingerprint) {return;}
-        triggerCache[jid] = fingerprint;
-
-        // Ignore the "delimiter-new" sentinel + locally-pending sends
-        // so the two unread-counting paths (this middleware + the
-        // reducer's countNewerMessages) never disagree. Also exclude
-        // own messages so MAM-replayed sends on re-login don't bump
-        // the user's own badge.
-        const unreadMessagesCount = room.messages?.filter(
-          (msg: IMessage) =>
-            msg.id !== 'delimiter-new' &&
-            !msg.pending &&
-            !isOwnMessage(msg, selfXmpp, selfWallet) &&
-            msgSortableMs(msg) >
-              (room.lastViewedTimestamp || 0)
-        ).length;
-
-        const newerByTs = (room.messages || []).filter(
-          (m: IMessage) =>
-            m.id !== 'delimiter-new' &&
-            !m.pending &&
-            msgSortableMs(m) > (room.lastViewedTimestamp || 0)
-        );
-        if (newerByTs.length > 0 && (unreadMessagesCount || 0) === 0) {
-          const s: any = newerByTs[newerByTs.length - 1] || {};
-          console.log('[unread-diag] ownership suppressed', {
-            jid,
-            selfXmpp,
-            selfWallet,
-            newerByTs: newerByTs.length,
-            unreadAfterOwnFilter: unreadMessagesCount,
-            sample: {
-              id: s.id,
-              userId: s?.user?.id,
-              userJID: s?.user?.userJID,
-              xmppUsername: s?.user?.xmppUsername,
-              xmppFrom: s?.xmppFrom,
-              senderJID: s?.senderJID,
-            },
-          });
+    const touched = touchedRooms(action);
+    const jids = touched === 'all' ? Object.keys(rooms) : touched;
+    if (jids.length === 0) {return result;}
+
+    const counts: Record<string, number> = {};
+    for (const jid of jids) {
+      const room = rooms[jid];
+      if (!room) {continue;}
+      // The room the user is looking at never carries a badge.
+      if (jid === visibleRoomJID) {
+        if (room.unreadMessages !== 0) {counts[jid] = 0;}
+        continue;
+      }
+      // 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;}
+
+      const msgs = room.messages;
+      const currentMessagesLength = msgs?.length || 0;
+      const firstId = currentMessagesLength ? String(msgs![0]?.id ?? '') : '';
+      const lastId = currentMessagesLength
+        ? String(msgs![currentMessagesLength - 1]?.id ?? '')
+        : '';
+      const fingerprint = `${currentMessagesLength}|${room.lastViewedTimestamp || 0}|${firstId}|${lastId}`;
+      if (triggerCache[jid] === fingerprint) {continue;}
+      triggerCache[jid] = fingerprint;
+
+      // Ignore the "delimiter-new" sentinel + locally-pending sends
+      // so the two unread-counting paths (this middleware + the
+      // reducer's countNewerMessages) never disagree. Also exclude
+      // own messages so MAM-replayed sends on re-login don't bump
+      // the user's own badge.
+      const since = room.lastViewedTimestamp || 0;
+      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 (room.unreadMessages !== unreadMessagesCount) {
-          storeAPI.dispatch(
-            updateRoom({
-              jid,
-              updates: { unreadMessages: unreadMessagesCount },
-            })
-          );
-        }
-      });
+      if (room.unreadMessages !== unreadMessagesCount) {
+        counts[jid] = unreadMessagesCount;
+      }
+    }
+
+    // One action for every room that changed — and one that is not itself
+    // a trigger, so the chain stops here.
+    if (Object.keys(counts).length > 0) {
+      storeAPI.dispatch(setUnreadCounts(counts));
     }
 
     return result;

package/src/roomStore/index.ts

@@ -1,6 +1,6 @@
 import { configureStore, combineReducers } from '@reduxjs/toolkit';
 import chatSettingsReducer, { setUser } from './chatSettingsSlice';
-import roomsSlice, { addRoom } from './roomsSlice';
+import roomsSlice, { addRooms } from './roomsSlice';
 import { roomHeapSlice, markMessageFailed } from './roomHeapSlice';
 import callReducer from './callSlice';
 import { IRoom } from '../types/types';
@@ -8,6 +8,7 @@ import { unreadMiddleware } from './Middleware/unreadMidlleware';
 import { logoutMiddleware } from './Middleware/logoutMiddleware';
 import { newMessageMidlleware } from './Middleware/newMessageMidlleware';
 import { reactionsMiddleware } from './Middleware/reactionsMiddleware';
+import { isPerfProfilingEnabled, perfMiddleware } from './Middleware/perfMiddleware';
 import {
   persistenceMiddleware,
   readPersistedState,
@@ -29,29 +30,27 @@ export type RootState = ReturnType<typeof rootReducer>;
 const createChatStore = () =>
   configureStore({
     reducer: rootReducer,
-    middleware: (getDefaultMiddleware) =>
-      getDefaultMiddleware({
-        serializableCheck: {
-          // Slice names: chatSlice→'chat', roomsStore→'roomMessages'.
-          ignoredActions: [
-            'chat/addMessage',
-            'chat/setStoreClient',
-            'chat/setConfig',
-            'roomMessages/addRoom',
-          ],
-          ignoredActionPaths: ['payload.client', 'payload.config'],
-          ignoredPaths: [
-            'chat.messages.timestamp',
-            'chatSettingStore.client',
-            'chatSettingStore.config',
-          ],
-        },
-      })
-        .concat(unreadMiddleware)
-        .concat(newMessageMidlleware)
-        .concat(reactionsMiddleware)
-        .concat(logoutMiddleware)
-        .concat(persistenceMiddleware),
+    middleware: (getDefaultMiddleware) => {
+      const base = getDefaultMiddleware({
+        // Both dev-only invariant checks walk the WHOLE state on every
+        // action. With rooms + message history in the store that took
+        // 60-80 ms per dispatch (RTK's own "took Xms" warning), blocking
+        // the JS thread long enough to make taps feel dead in dev builds.
+        // Production builds never ran them.
+        serializableCheck: false,
+        immutableCheck: false,
+      });
+      const chain = [
+        unreadMiddleware,
+        newMessageMidlleware,
+        reactionsMiddleware,
+        logoutMiddleware,
+        persistenceMiddleware,
+      ];
+      return isPerfProfilingEnabled()
+        ? base.concat(perfMiddleware, ...chain)
+        : base.concat(...chain);
+    },
   });
 
 const globalScope = globalThis as typeof globalThis & {
@@ -82,9 +81,11 @@ export const persistorReady =
       store.dispatch(setUser(chat.user));
     }
     if (rooms?.rooms) {
-      for (const [jid, room] of Object.entries(rooms.rooms)) {
-        if (!jid || !room) {continue;}
-        store.dispatch(addRoom({ roomData: room as IRoom }));
+      const restored = Object.entries(rooms.rooms)
+        .filter(([jid, room]) => !!jid && !!room)
+        .map(([, room]) => room as IRoom);
+      if (restored.length) {
+        store.dispatch(addRooms({ rooms: restored }));
       }
     }
 

package/src/roomStore/persistBackend.ts

@@ -0,0 +1,96 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { secureGet, secureSet } from '../helpers/secureKeyValue';
+import { encryptForPersist, decryptFromPersist } from '../helpers/persistCrypto';
+
+
+export interface PersistBackend {
+  name: 'mmkv' | 'async-storage';
+  getMany(keys: string[]): Promise<(string | null)[]>;
+  setMany(pairs: [string, string][]): Promise<void>;
+  removeMany(keys: string[]): Promise<void>;
+  allKeys(): Promise<string[]>;
+}
+
+const MMKV_INSTANCE_ID = 'ethora-chat-persist';
+const MMKV_KEY_STORE_KEY = '@ethora/persist:mmkvKey';
+const MMKV_KEY_LENGTH = 16;
+
+const randomKey = (length: number): string => {
+  const alphabet =
+    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  const bytes = new Uint8Array(length);
+  (globalThis as any).crypto.getRandomValues(bytes);
+  let out = '';
+  for (let i = 0; i < length; i++) {out += alphabet[bytes[i] % alphabet.length];}
+  return out;
+};
+
+const loadOrCreateMmkvKey = async (): Promise<string> => {
+  const existing = await secureGet(MMKV_KEY_STORE_KEY);
+  if (existing) {return existing;}
+  const key = randomKey(MMKV_KEY_LENGTH);
+  await secureSet(MMKV_KEY_STORE_KEY, key);
+  return key;
+};
+
+const createMmkvBackend = async (): Promise<PersistBackend | null> => {
+  let MMKV: any;
+  try {
+    MMKV = require('react-native-mmkv').MMKV;
+  } catch {
+    return null;
+  }
+  if (typeof MMKV !== 'function') {return null;}
+  try {
+    const encryptionKey = await loadOrCreateMmkvKey();
+    // Throws when the native module is missing from the binary.
+    const storage = new MMKV({ id: MMKV_INSTANCE_ID, encryptionKey });
+    return {
+      name: 'mmkv',
+      getMany: async (keys) => keys.map((k) => storage.getString(k) ?? null),
+      setMany: async (pairs) => {
+        for (const [k, v] of pairs) {storage.set(k, v);}
+      },
+      removeMany: async (keys) => {
+        for (const k of keys) {storage.delete(k);}
+      },
+      allKeys: async () => storage.getAllKeys(),
+    };
+  } catch (e) {
+    console.warn('[persist] react-native-mmkv present but unusable, falling back', e);
+    return null;
+  }
+};
+
+const asyncStorageBackend: PersistBackend = {
+  name: 'async-storage',
+  getMany: async (keys) => {
+    const pairs = await AsyncStorage.multiGet(keys);
+    return Promise.all(
+      pairs.map(([, raw]) => (raw ? decryptFromPersist(raw) : Promise.resolve(null)))
+    );
+  },
+  setMany: async (pairs) => {
+    const encrypted = await Promise.all(
+      pairs.map(async ([k, v]) => [k, await encryptForPersist(v)] as [string, string])
+    );
+    await AsyncStorage.multiSet(encrypted);
+  },
+  removeMany: (keys) => AsyncStorage.multiRemove(keys),
+  allKeys: async () => [...(await AsyncStorage.getAllKeys())],
+};
+
+let backendPromise: Promise<PersistBackend> | null = null;
+
+export const getPersistBackend = (): Promise<PersistBackend> => {
+  if (!backendPromise) {
+    backendPromise = createMmkvBackend().then((mmkv) => mmkv ?? asyncStorageBackend);
+  }
+  return backendPromise;
+};
+
+export const legacyAsyncStorageBackend = asyncStorageBackend;
+
+export const __resetPersistBackend = () => {
+  backendPromise = null;
+};