@ethora/chat-component-rn 26.4.1 → 26.4.2

package/src/roomStore/roomsSlice.ts

@@ -2,6 +2,25 @@ import { createSlice, PayloadAction } from '@reduxjs/toolkit';
 import { EditAction, HistoryPreloadState, IMessage, IRoom } from '../types/types';
 import { insertMessageWithDelimiter } from '../helpers/insertMessageWithDelimiter';
 
+// Per-room runtime message cap. Mirrors the persistence layer's
+// MESSAGE_LIMIT so what's in memory matches what's on disk; otherwise
+// long sessions grow the array unbounded (memory leak) and reload
+// shows fewer messages than the user saw last in the session.
+//
+// The cap fires on the APPEND path (new messages arriving) — paginated
+// older history added via unshift/splice is exempt, so the user can
+// page backward arbitrarily far without instantly losing what they
+// just fetched. After cap eviction we drop from the head (oldest).
+const RUNTIME_MESSAGE_LIMIT = 100;
+
+const enforceMessageCap = (messages: IMessage[]): void => {
+  // Trim oldest until we're at/under the limit. Mutates in place
+  // (immer-compatible inside reducers).
+  while (messages.length > RUNTIME_MESSAGE_LIMIT) {
+    messages.shift();
+  }
+};
+
 export interface RoomPreloadPatch {
   jid: string;
   messages?: IMessage[];
@@ -37,7 +56,18 @@ export const roomsStore = createSlice({
   reducers: {
     addRoom(state, action: PayloadAction<{ roomData: IRoom }>) {
       const { roomData } = action.payload;
-      state.rooms[roomData.jid] = roomData;
+      const existing = state.rooms[roomData.jid];
+      // Preserve a pre-existing lastViewedTimestamp (the private-store
+      // pull may have landed before /chats/my finished). If neither
+      // source set one, stamp `Date.now()` so initial REST history
+      // counts as "seen" — without this default, every back-history
+      // message read by the unread middleware satisfies `>0` and the
+      // badge shows the entire room population on first paint.
+      const lastViewed =
+        roomData.lastViewedTimestamp ??
+        existing?.lastViewedTimestamp ??
+        Date.now();
+      state.rooms[roomData.jid] = { ...roomData, lastViewedTimestamp: lastViewed };
     },
     deleteRoom(state, action: PayloadAction<{ jid: string }>) {
       const { jid } = action.payload;
@@ -65,7 +95,14 @@ export const roomsStore = createSlice({
     ) {
       const { roomJID, messages } = action.payload;
       if (state.rooms[roomJID]) {
-        state.rooms[roomJID].messages = messages;
+        // Cap to the runtime limit on replace too — guards against a
+        // single MAM page returning more than the limit (would balloon
+        // the array on its own).
+        const capped =
+          messages.length > RUNTIME_MESSAGE_LIMIT
+            ? messages.slice(-RUNTIME_MESSAGE_LIMIT)
+            : messages;
+        state.rooms[roomJID].messages = capped;
       }
     },
     deleteRoomMessage(
@@ -120,11 +157,22 @@ export const roomsStore = createSlice({
     ) {
       const { roomJID, message, start } = action.payload;
 
-      if (!state.rooms[roomJID]?.messages) {
+      // Guard against the "stanza arrived before /chats/my completed"
+      // race — without this, the optional-chain `?.messages` falls
+      // back to undefined, and the assignment below tries to set
+      // `.messages` on undefined → TypeError. Caller can safely
+      // ignore the message; the room will get its messages array on
+      // `addRoom` when the API response lands.
+      if (!state.rooms[roomJID]) {
+        return;
+      }
+
+      if (!state.rooms[roomJID].messages) {
         state.rooms[roomJID].messages = [];
       }
 
       const roomMessages = state.rooms[roomJID].messages;
+      const lengthBefore = roomMessages.length;
 
       if (roomMessages.length === 0 || start) {
         roomMessages.unshift(message);
@@ -135,6 +183,14 @@ export const roomsStore = createSlice({
 
         insertMessageWithDelimiter(roomMessages, message, lastViewedTimestamp);
       }
+
+      // Apply the in-memory cap only when the array actually GREW
+      // (i.e. this wasn't a dedupe/merge that left length unchanged).
+      // Otherwise repeated echoes of the same message would chip away
+      // at the oldest history for no reason.
+      if (roomMessages.length > lengthBefore) {
+        enforceMessageCap(roomMessages);
+      }
     },
     deleteAllRooms(state) {
       state.rooms = {};
@@ -309,17 +365,69 @@ export const roomsStore = createSlice({
 });
 
 // Count messages strictly newer than the given millisecond timestamp.
-// Uses `msg.date` (canonical ISO/Date) so it matches the unread
-// middleware. Excludes the "delimiter-new" sentinel and pending sends.
+// Uses `msg.id` (server-authoritative microsecond timestamp prefixed by
+// 13-digit millis — see helpers/dateComparison `getHighResolutionTimestamp`)
+// because `msg.date` can be derived client-side (createMessageFromXml
+// falls back to `Date.now()` for realtime stanzas without a `date`
+// attr), which makes the comparison drift vs what the server assigned.
+// Excludes the "delimiter-new" sentinel, pending sends, and the current
+// user's own messages (parity with unreadMiddleware's isOwnMessage
+// filter — without this, the reducer and the middleware disagree about
+// the count and we get a flicker as the badge gets written twice with
+// different values on every message).
+export const msgSortableMs = (msg: any): number => {
+  const id = String(msg?.id || '');
+  const m = /^(\d{13})/.exec(id);
+  if (m) {return Number(m[1]);}
+  if (msg?.date) {
+    const t = new Date(msg.date as any).getTime();
+    if (Number.isFinite(t)) {return t;}
+  }
+  return 0;
+};
+
+const norm = (s: any): string => {
+  if (s == null) {return '';}
+  let v = String(s).toLowerCase();
+  v = v.split('/')[0];
+  v = v.split('@')[0];
+  return v.replace(/_/g, '');
+};
+
+const isOwn = (
+  msg: IMessage,
+  selfXmpp: string,
+  selfWallet: string
+): boolean => {
+  if (!selfXmpp && !selfWallet) {return false;}
+  const candidates = [
+    norm((msg as any)?.user?.id),
+    norm((msg as any)?.user?.userJID),
+    norm((msg as any)?.user?.xmppUsername),
+    norm((msg as any)?.xmppFrom),
+  ].filter(Boolean);
+  if (candidates.length === 0) {return false;}
+  const self = new Set(
+    [norm(selfXmpp), norm(selfWallet)].filter(Boolean)
+  );
+  for (const c of candidates) {
+    if (self.has(c)) {return true;}
+  }
+  return false;
+};
+
 const countNewerMessages = (
   messages: IMessage[],
-  timestamp: number
+  timestamp: number,
+  selfXmpp: string = '',
+  selfWallet: string = ''
 ): number => {
   if (!messages?.length || !timestamp) {return 0;}
   let count = 0;
   for (const message of messages) {
     if (!message || message.id === 'delimiter-new' || message.pending) {continue;}
-    const ms = new Date(message.date as any).getTime();
+    if (isOwn(message, selfXmpp, selfWallet)) {continue;}
+    const ms = msgSortableMs(message);
     if (Number.isFinite(ms) && ms > timestamp) {count += 1;}
   }
   return count;

package/src/types/types.ts

@@ -60,6 +60,11 @@ export interface IRoom {
   createdAt?: string | number | Date;
   updatedAt?: string | number | Date;
 
+  // REST-side metadata populated by `/chats/my` hydration. Surfaced
+  // in ChatProfileModal under Description / Chat type fields.
+  description?: string;
+  type?: string;
+
   roomMembers?: RoomMember[];
 
   // QoS / preload state
@@ -349,6 +354,8 @@ export interface IConfig {
   roomListStyles?: ViewStyle;
   chatRoomStyles?: ViewStyle;
 
+  keyboardVerticalOffset?: number;
+
   // ----- interactions / messages -----
   disableInteractions?: boolean;
   disableReactions?: boolean;
@@ -356,15 +363,9 @@ export interface IConfig {
   disableUserCount?: boolean;
   disableSentLogic?: boolean;
   disableTypingIndicator?: boolean;
-  // Chat-profile modal granular gates (matches web's
-  // `disableChatInfo`).
-  disableChatInfo?: {
-    disableHeader?: boolean;
-    disableDescription?: boolean;
-    disableType?: boolean;
-    hideMembers?: boolean;
-    disableMembers?: boolean;
-  };
+  // disableChatInfo already declared above (line ~338) — granular gates
+  // (disableHeader / disableDescription / disableType / hideMembers /
+  // disableMembers / disableChatHeaderMenu). Don't redeclare here.
   botMessageAutoScroll?: boolean;
   blockMessageSendingWhenProcessing?:
     | boolean

package/src/utils/devLogger.ts

@@ -106,6 +106,17 @@ function safeStringify(value: any): string {
 let consolePatched = false;
 
 export function installConsoleCapture() {
+  // Under Jest, patching `console.*` to fan out through `pushLog` causes
+  // a render-time feedback loop: React's dev build emits `console.error`
+  // during act() for various reasons (deprecated APIs, act-warnings),
+  // each call schedules a microtask notify → `useSyncExternalStore`
+  // subscribers re-render → next render may log again → "Maximum
+  // update depth exceeded" → the suite hangs. Skipping the patch in
+  // test environments eliminates the loop without changing dev/prod
+  // behaviour. Mirrors how the web build gates DEV-only diagnostics.
+  if (typeof process !== 'undefined' && process.env?.NODE_ENV === 'test') {
+    return;
+  }
   if (consolePatched) {return;}
   consolePatched = true;
   (['log', 'info', 'warn', 'error'] as const).forEach((level) => {