@ethora/chat-component-rn 26.4.1

package/src/helpers/historyPreloadScheduler.ts

@@ -0,0 +1,264 @@
+import { AppState } from 'react-native';
+import XmppClient from '../networking/xmppClient';
+import { store } from '../roomStore';
+import { applyRoomsPreloadBatch } from '../roomStore/roomsSlice';
+import { IMessage, IRoom } from '../types/types';
+
+interface HistoryPreloadSchedulerOptions {
+  client: XmppClient;
+  signal?: AbortSignal;
+  concurrency?: number;
+  pageSize?: number;
+  retryLimit?: number;
+  roomLimit?: number;
+  selectedRoomJid?: string | null;
+  defaultRoomJids?: string[];
+  forceReload?: boolean;
+}
+
+interface QueueItem {
+  jid: string;
+  priority: number;
+  activityScore: number;
+  attempts: number;
+  readyAt: number;
+}
+
+const DEFAULT_CONCURRENCY = 3;
+const DEFAULT_PAGE_SIZE = 10;
+const DEFAULT_RETRY_LIMIT = 2;
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const messageTimestamp = (m: IMessage): number => {
+  if (!m) {return 0;}
+  const t = (m as any).timestamp;
+  if (Number.isFinite(t) && t > 0) {return Number(t);}
+  const id = Number(m.id);
+  if (Number.isFinite(id) && id > 0) {return id;}
+  return 0;
+};
+
+const getRoomLastActivityScore = (room: IRoom): number => {
+  if (!room?.messages?.length) {return 0;}
+  return room.messages.reduce((max, m) => Math.max(max, messageTimestamp(m)), 0);
+};
+
+const computeUnreadCapped = (
+  room: IRoom,
+  messages: IMessage[],
+  pageSize: number
+): boolean => {
+  if (!room) {return false;}
+  if (!messages || messages.length < pageSize) {return false;}
+  if (room.historyComplete === true) {return false;}
+
+  const countable = messages.filter(
+    (msg) => !!msg && msg.id !== 'delimiter-new' && !msg.pending
+  );
+  if (countable.length < pageSize) {return false;}
+
+  const lastViewed = Number(room.lastViewedTimestamp) || 0;
+  if (lastViewed <= 0) {return true;}
+
+  const oldestTs = countable.reduce<number>((minTs, m) => {
+    const ts = messageTimestamp(m);
+    if (!Number.isFinite(ts) || ts <= 0) {return minTs;}
+    return Math.min(minTs, ts);
+  }, Number.MAX_SAFE_INTEGER);
+  if (!Number.isFinite(oldestTs) || oldestTs === Number.MAX_SAFE_INTEGER)
+    {return false;}
+  return oldestTs > lastViewed;
+};
+
+const getRoomPriority = (
+  jid: string,
+  _room: IRoom,
+  selectedRoomJid: string | null,
+  defaultRoomJids: Set<string>
+): number => {
+  if (selectedRoomJid && selectedRoomJid === jid) {return 0;}
+  if (defaultRoomJids.has(jid)) {return 1;}
+  return 2;
+};
+
+const shouldPauseForVisibility = (): boolean => {
+  return AppState.currentState !== 'active';
+};
+
+/**
+ * Background-loads message history for every room into the redux store,
+ * prioritized by selected/default rooms then by last activity. Coalesces
+ * with the XMPP client's MAM queue (so the active-room scroll fetch wins).
+ * Mirrors the web `runHistoryPreloadScheduler`.
+ */
+export const runHistoryPreloadScheduler = async (
+  options: HistoryPreloadSchedulerOptions
+): Promise<void> => {
+  const {
+    client,
+    signal,
+    concurrency = DEFAULT_CONCURRENCY,
+    pageSize = DEFAULT_PAGE_SIZE,
+    retryLimit = DEFAULT_RETRY_LIMIT,
+    roomLimit,
+    selectedRoomJid = null,
+    defaultRoomJids = [],
+    forceReload = false,
+  } = options;
+
+  if (signal?.aborted) {return;}
+
+  const state = store.getState();
+  const rooms = (state.rooms.rooms || {}) as Record<string, IRoom>;
+  const defaultSet = new Set(defaultRoomJids);
+
+  const sortedQueue: QueueItem[] = Object.entries(rooms)
+    .map(([jid, room]: [string, IRoom]) => ({
+      jid,
+      priority: getRoomPriority(jid, room, selectedRoomJid, defaultSet),
+      activityScore: getRoomLastActivityScore(room),
+      attempts: 0,
+      readyAt: Date.now(),
+    }))
+    .sort((a, b) => {
+      if (a.priority !== b.priority) {return a.priority - b.priority;}
+      if (a.activityScore !== b.activityScore) {
+        return b.activityScore - a.activityScore;
+      }
+      return a.jid.localeCompare(b.jid);
+    });
+
+  const queue: QueueItem[] =
+    roomLimit && roomLimit > 0
+      ? sortedQueue.slice(0, roomLimit)
+      : sortedQueue;
+
+  const inFlightByRoom = new Map<string, Promise<void>>();
+  let consecutiveErrorCount = 0;
+
+  while (queue.length > 0) {
+    if (signal?.aborted) {return;}
+
+    if (!client.isActiveRoomGateOpen()) {
+      await sleep(80);
+      continue;
+    }
+    if (shouldPauseForVisibility()) {
+      await sleep(250);
+      continue;
+    }
+
+    const now = Date.now();
+    const readyItems = queue.filter(
+      (item) => item.readyAt <= now && !inFlightByRoom.has(item.jid)
+    );
+    if (readyItems.length === 0) {
+      await sleep(60);
+      continue;
+    }
+
+    const batch = readyItems.slice(0, Math.max(1, concurrency));
+
+    store.dispatch(
+      applyRoomsPreloadBatch({
+        rooms: batch.map((item) => ({
+          jid: item.jid,
+          historyPreloadState: 'loading',
+        })),
+      })
+    );
+
+    await Promise.all(
+      batch.map(async (item) => {
+        const queueIndex = queue.findIndex((queued) => queued.jid === item.jid);
+        if (queueIndex !== -1) {queue.splice(queueIndex, 1);}
+
+        const task = (async () => {
+          const currentRoom = store.getState().rooms.rooms[item.jid];
+          if (
+            !currentRoom ||
+            (!forceReload && currentRoom.historyPreloadState === 'done')
+          ) {
+            store.dispatch(
+              applyRoomsPreloadBatch({
+                rooms: [{ jid: item.jid, historyPreloadState: 'done' }],
+              })
+            );
+            return;
+          }
+
+          try {
+            const fetchedMessages = await client.getHistoryStanza(
+              item.jid,
+              pageSize,
+              undefined,
+              undefined,
+              {
+                coalesceRoom: true,
+                skipIfPreloaded: !forceReload,
+                source: 'background',
+              }
+            );
+            if (signal?.aborted) {return;}
+            if (typeof fetchedMessages === 'undefined') {
+              throw new Error('history_timeout');
+            }
+
+            const nextRoom = store.getState().rooms.rooms[item.jid];
+            const unreadCapped = computeUnreadCapped(
+              nextRoom,
+              fetchedMessages || [],
+              pageSize
+            );
+
+            store.dispatch(
+              applyRoomsPreloadBatch({
+                rooms: [
+                  {
+                    jid: item.jid,
+                    messages: fetchedMessages || [],
+                    unreadCapped,
+                    historyPreloadState: 'done',
+                  },
+                ],
+              })
+            );
+            consecutiveErrorCount = 0;
+          } catch {
+            const retries = item.attempts + 1;
+            const canRetry = retries <= retryLimit;
+            if (canRetry) {
+              const jitter = Math.floor(Math.random() * 120);
+              const backoff = Math.min(1600, 240 * 2 ** item.attempts) + jitter;
+              queue.push({
+                ...item,
+                attempts: retries,
+                readyAt: Date.now() + backoff,
+              });
+            } else {
+              store.dispatch(
+                applyRoomsPreloadBatch({
+                  rooms: [{ jid: item.jid, historyPreloadState: 'error' }],
+                })
+              );
+            }
+            consecutiveErrorCount += 1;
+            if (consecutiveErrorCount >= 3) {
+              await sleep(300);
+              consecutiveErrorCount = 0;
+            }
+          }
+        })();
+
+        inFlightByRoom.set(item.jid, task);
+        await task.finally(() => inFlightByRoom.delete(item.jid));
+      })
+    );
+
+    // Yield to JS event loop (no requestIdleCallback in RN).
+    await new Promise((r) => setTimeout(r, 0));
+  }
+};
+
+export default runHistoryPreloadScheduler;

package/src/helpers/initRoomsPresence.ts

@@ -0,0 +1,32 @@
+import XmppClient from '../networking/xmppClient';
+import { IRoom } from '../types/types';
+import { presenceInRoom } from '../networking/xmpp/presenceInRoom.xmpp';
+import { pushSubscriptionService } from '../services/pushSubscriptionService';
+
+export const initRoomsPresence = async (
+  client: XmppClient,
+  rooms: { [jid: string]: IRoom }
+) => {
+  console.log('Persisted presence');
+  if (!client) {return null;}
+  const jids = Object.keys(rooms || {});
+  if (!jids.length) {return null;}
+  await Promise.allSettled(
+    jids.map(async (jid) => {
+      try {
+        await presenceInRoom(client.client, jid);
+      } catch (e) {}
+    })
+  );
+
+  if (jids.length > 0 && client.client) {
+    const userNick = client.client.jid?.getLocal();
+    await pushSubscriptionService.subscribeToRooms(
+      client.client,
+      jids,
+      userNick
+    ).catch((error) => {
+      console.error('Failed to subscribe to rooms for push:', error);
+    });
+  }
+};

package/src/helpers/initXmppRooms.tsx

@@ -0,0 +1,71 @@
+import { setCurrentRoom, setIsLoading } from '../roomStore/roomsSlice';
+import { updatedChatLastTimestamps } from './updatedChatLastTimestamps';
+import { initRoomsPresence } from './initRoomsPresence';
+import XmppClient from '../networking/xmppClient';
+import { IConfig, IRoom, User } from '../types/types';
+import { store } from '../roomStore';
+
+const initXmppRooms = async (
+  user: User,
+  config: IConfig,
+  xmmpClient: XmppClient,
+  rooms?: { [key: string]: IRoom },
+  roomJID?: string
+) => {
+  if (roomJID) {
+    store.dispatch(setCurrentRoom({ roomJID: roomJID }));
+  }
+
+  try {
+    if (!user.defaultWallet || !user.defaultWallet.walletAddress) {
+      console.log('Error, no user');
+      return;
+    }
+
+    if (!xmmpClient) {
+      console.log('No xmmpClient, initializing one');
+
+      if (rooms && Object.keys(rooms).length > 0) {
+        await initRoomsPresence(xmmpClient, rooms);
+      } else {
+        if (config?.newArch) {
+          // const rooms = await getRooms();
+          //     rooms.items.map((room) => {
+          //       dispatch(
+          //         addRoomViaApi({
+          //           room: createRoomFromApi(
+          //             room,
+          //             config?.xmppSettings?.conference
+          //           ),
+          //           xmpp: newClient,
+          //         })
+          //       );
+          //     });
+          return;
+        }
+        const res = await xmmpClient.getRoomsStanza();
+        console.log(res);
+      }
+
+      //@ts-ignore
+      const roomTimestampObject: [jid: string, timestamp: string] =
+        await xmmpClient.getChatsPrivateStoreRequestStanza();
+      updatedChatLastTimestamps(roomTimestampObject, store.dispatch);
+    } else {
+      //@ts-ignore
+      const roomTimestampObject: [jid: string, timestamp: string] =
+        await xmmpClient.getChatsPrivateStoreRequestStanza();
+      updatedChatLastTimestamps(roomTimestampObject, store.dispatch);
+    }
+
+    if (config?.refreshTokens?.enabled) {
+      config?.refreshTokens?.refreshFunction();
+    }
+  } catch (error) {
+    console.error(error);
+  } finally {
+    store.dispatch(setIsLoading({ loading: false }));
+  }
+};
+
+export default initXmppRooms;

package/src/helpers/insertMessageWithDelimiter.ts

@@ -0,0 +1,96 @@
+import { IMessage } from '../types/types';
+import { isDateAfter, isDateBefore } from './dateComparison';
+
+function deepMerge(target: any, source: any): any {
+  for (const key in source) {
+    if (
+      source[key] &&
+      typeof source[key] === 'object' &&
+      !Array.isArray(source[key])
+    ) {
+      target[key] = deepMerge(target[key] || {}, source[key]);
+    } else {
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+
+export function insertMessageWithDelimiter(
+  roomMessages: Partial<IMessage>[],
+  message: IMessage,
+  lastViewedTimestamp: { toString: () => string } | null,
+) {
+  const existingIndex = roomMessages.findIndex(
+    (msg) =>
+      msg.id === message.id ||
+      (message.xmppId && msg.id === message.xmppId) ||
+      (msg.xmppId && msg.xmppId === message.id)
+  );
+
+  if (existingIndex !== -1) {
+    roomMessages[existingIndex] = deepMerge(
+      { ...roomMessages[existingIndex] },
+      { ...message, pending: false }
+    );
+    return;
+  }
+
+  const newMessageDate = message.date;
+  const lastMessage = roomMessages[roomMessages.length - 1];
+  const firstMessage = roomMessages[0];
+
+  if (isDateAfter(newMessageDate.toString(), lastMessage.date.toString())) {
+    const index = roomMessages.findIndex(
+      (msg) => msg.id === message.xmppId || msg.id === message.id
+    );
+
+    if (index !== -1) {
+      roomMessages[index] = { ...message, id: message.id, pending: false };
+    } else {
+      roomMessages.push(message);
+    }
+
+    if (
+      lastViewedTimestamp &&
+      !roomMessages.some((msg) => msg.id === 'delimiter-new') &&
+      isDateAfter(newMessageDate.toString(), lastViewedTimestamp.toString())
+    ) {
+      const delimiterIndex = roomMessages.findIndex((msg) =>
+        isDateAfter(msg.date.toString(), lastViewedTimestamp.toString())
+      );
+
+      if (delimiterIndex !== -1) {
+        roomMessages.splice(delimiterIndex, 0, {
+          id: 'delimiter-new',
+          user: {
+            id: 'system',
+            name: null,
+            token: '',
+            refreshToken: '',
+          },
+          date: new Date().toString(),
+          body: 'New Messages',
+          roomJid: '',
+        });
+
+        if (lastViewedTimestamp.toString() === '0') {
+          roomMessages.splice(delimiterIndex, 1);
+        }
+      }
+    }
+  } else if (
+    isDateBefore(newMessageDate.toString(), firstMessage.date.toString())
+  ) {
+    roomMessages.unshift(message);
+  } else {
+    for (let i = 0; i < roomMessages.length; i++) {
+      if (
+        isDateBefore(newMessageDate.toString(), roomMessages[i].date.toString())
+      ) {
+        roomMessages.splice(i, 0, message);
+        break;
+      }
+    }
+  }
+}

package/src/helpers/isChatIdPresentInArray.ts

@@ -0,0 +1,54 @@
+import { ApiRoom, IRoom } from '../types/types';
+
+export function isChatIdPresentInArray(
+  chatIdToFind: string | null | undefined,
+  chatList: ApiRoom[] | { [jid: string]: IRoom }
+): boolean {
+  if (!chatList) {
+    return false;
+  }
+
+  if (Array.isArray(chatList)) {
+    if (chatList.length === 0) {
+      return false;
+    }
+  } else {
+    if (Object.keys(chatList).length === 0) {
+      return false;
+    }
+  }
+
+  if(!chatIdToFind || typeof chatIdToFind !== 'string') {
+    return false;
+  }
+
+  const trimmedId = chatIdToFind.split('@')[0].trim();
+
+  if (Array.isArray(chatList)) {
+    for (const chatObject of chatList) {
+      console.log('check', trimmedId === chatObject.name);
+
+      if (
+        chatObject &&
+        typeof chatObject.name === 'string' &&
+        chatObject.name === trimmedId
+      ) {
+        return true;
+      }
+    }
+  } else {
+    for (const jid in chatList) {
+      const chatObject = chatList[jid];
+
+      if (
+        chatObject &&
+        typeof chatObject.name === 'string' &&
+        chatObject.name === trimmedId
+      ) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}

package/src/helpers/localStorageUser.ts

@@ -0,0 +1,9 @@
+import { User } from '../types/types';
+import { localStorageConstants } from './constants/LOCAL_STORAGE';
+
+export const getLocalStorageUser = () => {
+  const user: User = JSON.parse(
+    localStorage.getItem(localStorageConstants.ETHORA_USER)
+  );
+  return user;
+};