@ethora/chat-component-rn 26.9.1 → 26.10.1

package/src/helpers/initRoomsPresence.ts

@@ -2,7 +2,15 @@ import XmppClient from '../networking/xmppClient';
 import { IRoom } from '../types/types';
 import { presenceInRoom } from '../networking/xmpp/presenceInRoom.xmpp';
 import { pushSubscriptionService } from '../services/pushSubscriptionService';
+import { startBackgroundJoinSweep } from './backgroundJoinSweep';
 
+/**
+ * Joins the known rooms and subscribes them for push. Callers should NOT
+ * await it on a path that gates first paint: with a real XmppClient the
+ * joins are the shared background sweep (open room first, then recent
+ * activity, bounded concurrency), started here and not waited for. Only a
+ * bare client without the sweep falls back to joining every room at once.
+ */
 export const initRoomsPresence = async (
   client: XmppClient,
   rooms: { [jid: string]: IRoom }
@@ -11,13 +19,18 @@ export const initRoomsPresence = async (
   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 (typeof (client as any).sendAllPresencesAndMarkReady === 'function') {
+    startBackgroundJoinSweep(client);
+  } else {
+    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();

package/src/helpers/insertMessageWithDelimiter.ts

@@ -1,5 +1,6 @@
 import { IMessage } from '../types/types';
 import { msgSortableMs } from './msgSortableMs';
+import { isSafeKey } from '../roomStore/safeKey';
 
 // Robustly resolve a caller-supplied read marker to epoch milliseconds.
 // Callers pass a plain number (the redux read boundary, or a room's
@@ -32,6 +33,8 @@ function resolveMarkerMs(
 
 function deepMerge(target: any, source: any): any {
   for (const key in source) {
+    // Never walk into the prototype chain through attacker-shaped keys.
+    if (!isSafeKey(key)) {continue;}
     if (source[key] === undefined) {
       // `for...in` visits a key even when its value is `undefined` — every
       // stanza parser (getDataFromXml/createMessageFromXml) returns an

package/src/helpers/isLikelyMucJid.ts

@@ -0,0 +1,72 @@
+// Real MUC room JIDs always look like `<localpart>@conference.<host>`. Various
+// state-map iterations over `rooms.rooms` (history preload, presence sweeps,
+// catch-up sync) can encounter non-room entries - corrupted/legacy persisted
+// state where root-slice keys (`activeRoomJID`, `usersSet`, `subscribedRooms`,
+// `pushSubscriptionStatus`, `rooms` itself) leaked into the rooms map, or a
+// bare app ID without the conference suffix. Treating those as room JIDs sends
+// MAM/presence requests for garbage names, wasting queue slots and network
+// round-trips that could go to real rooms instead. Filter with this before
+// any operation that fans out over "all rooms".
+export const isLikelyMucJid = (jid: unknown): jid is string => {
+  if (typeof jid !== 'string' || !jid) return false;
+  const at = jid.indexOf('@');
+  if (at <= 0) return false;
+  const domain = jid.slice(at + 1).split('/')[0];
+  return domain.includes('.') && domain.startsWith('conference.');
+};
+
+/**
+ * Root keys of the rooms slice. When a caller fans out over the slice itself
+ * instead of `slice.rooms`, these leak through as if they were room ids, and
+ * anything that appends the conference domain then produces real-looking but
+ * nonexistent JIDs (`usersSet@conference.host`), which the server answers with
+ * "Conference room does not exist". Cheap explicit denylist so the failure is
+ * named rather than mysterious.
+ */
+const ROOMS_SLICE_ROOT_KEYS = new Set([
+  'rooms',
+  'activeRoomJID',
+  'isChatUiVisible',
+  'isLoading',
+  'editAction',
+  'usersSet',
+  'presenceByRoom',
+  'reportRoom',
+  'subscribedRooms',
+  'pushSubscriptionStatus',
+  'loadingText',
+]);
+
+/**
+ * True when `value` can be used as the localpart of a MUC room JID, i.e. it is
+ * safe to build `${value}@conference.<host>` from it.
+ *
+ * Ethora room localparts are always `<appId>_<roomId>`, so the underscore is a
+ * reliable discriminator against slice keys, plain flags and stray strings.
+ * Callers that already hold a full JID should use `isLikelyMucJid` instead.
+ */
+export const isLikelyRoomLocalpart = (value: unknown): value is string => {
+  if (typeof value !== 'string') return false;
+  const v = value.trim();
+  if (!v || v.includes('@')) return false;
+  if (ROOMS_SLICE_ROOT_KEYS.has(v)) return false;
+  return v.includes('_');
+};
+
+/**
+ * Normalise a room reference into a full MUC JID, or return null when the
+ * input cannot be one. Use at every point that would otherwise blindly do
+ * `chatJID.includes('@') ? chatJID : chatJID + '@' + conference`: that pattern
+ * silently manufactures a valid-looking JID out of any garbage handed to it,
+ * which is how slice keys ended up being joined as rooms.
+ */
+export const toRoomJid = (
+  chatJID: unknown,
+  conference: string | undefined
+): string | null => {
+  if (typeof chatJID !== 'string' || !chatJID) return null;
+  if (chatJID.includes('@')) return chatJID;
+  if (!conference) return null;
+  if (!isLikelyRoomLocalpart(chatJID)) return null;
+  return `${chatJID}@${conference}`;
+};

package/src/helpers/isMessageSearchEnabled.ts

@@ -0,0 +1,18 @@
+import type { IConfig } from '../types/types';
+
+/**
+ * Single gate for every message search entry point (header button, chat
+ * profile row, the search screen and its request).
+ *
+ * Search is opt-in: it needs `enableMessageSearch: true` and an `appId` (the
+ * archive it queries is scoped by app). The deprecated `disableMessageSearch`
+ * is still honoured as a hard off.
+ */
+export const isMessageSearchEnabled = (
+  config?: Pick<IConfig, 'enableMessageSearch' | 'disableMessageSearch' | 'appId'> | null
+): boolean =>
+  Boolean(config?.enableMessageSearch) &&
+  Boolean(config?.appId) &&
+  !config?.disableMessageSearch;
+
+export default isMessageSearchEnabled;

package/src/helpers/joiningRoom.ts

@@ -0,0 +1,13 @@
+/**
+ * True while the pane should say "joining" instead of "choose a chat": the
+ * requested room is not in the list yet and a join for exactly that room is
+ * in flight (see useRoomInitialization).
+ */
+export const isJoiningRoom = (
+  activeRoomJID: string | null | undefined,
+  roomsList: Record<string, unknown> | undefined,
+  joiningRoomJID: string | null | undefined
+): boolean =>
+  Boolean(activeRoomJID) &&
+  !roomsList?.[activeRoomJID as string] &&
+  joiningRoomJID === activeRoomJID;

package/src/helpers/jumpThread.ts

@@ -0,0 +1,102 @@
+import { useSyncExternalStore } from 'react';
+import { IMessage } from '../types/types';
+import { parseMessageReference } from './parseMessageReference';
+import { findMessageIndex } from './jumpToMessage';
+
+// The id/content lookup is shared with the jump-to-message scroll helper.
+export { findMessageIndex };
+
+/** How long a jump request may stay pending before it is dropped. */
+export const JUMP_TTL_MS = 60_000;
+
+/**
+ * Where a jump to a thread REPLY lands, and the thread panel's parent message
+ * when that message is not in the room's live list.
+ *
+ * Replies never appear in the main list (it hides them unless they are also
+ * shown in the channel), so a jump to one has to open its parent's thread and
+ * highlight the reply there. Two things have to be remembered for that:
+ *  - which list owns the jump: `at` is the pending request this entry serves,
+ *    `parentId` the thread that owns it. The main list stays inert for a jump
+ *    that has an owner thread, and a thread list stays inert for any jump that
+ *    is not its own (see useJumpToMessage);
+ *  - the parent and the replies when they exist only in a jump window or came
+ *    from a separate fetch: the thread panel reads them from here, so it does
+ *    not depend on the window that found them still being on screen.
+ *
+ * Kept outside redux on purpose: the room slice's thread flag lives on
+ * messages of the live list, which is exactly what these messages are not in.
+ */
+export interface JumpThreadState {
+  roomJID: string;
+  parentId: string;
+  /** The pending request this entry serves; null for a thread opened by hand. */
+  at: number | null;
+  /** Set only when the parent is not in the room's live messages. */
+  parent: IMessage | null;
+  /** Replies known to belong to the thread beyond the live list. */
+  replies: IMessage[];
+}
+
+let state: JumpThreadState | null = null;
+const listeners = new Set<() => void>();
+
+const emit = () => listeners.forEach((listener) => listener());
+
+export const getJumpThread = (): JumpThreadState | null => state;
+
+export const setJumpThread = (next: JumpThreadState | null): void => {
+  state = next;
+  emit();
+};
+
+export const clearJumpThread = (): void => {
+  if (state === null) return;
+  state = null;
+  emit();
+};
+
+export const subscribeJumpThread = (listener: () => void): (() => void) => {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+};
+
+export const useJumpThread = (): JumpThreadState | null =>
+  useSyncExternalStore(subscribeJumpThread, getJumpThread, getJumpThread);
+
+/** The thread that owns the jump `at`, or null when the main list does. */
+export const ownerThreadFor = (
+  thread: JumpThreadState | null,
+  at: number | undefined
+): string | null =>
+  thread && at !== undefined && thread.at === at ? thread.parentId : null;
+
+/**
+ * The parent id of a message that is a thread reply and nothing else, or null:
+ * a reply also shown in the channel is in the main list, so it needs no thread.
+ */
+export const replyParentId = (message: IMessage): string | null => {
+  if (!message || String(message.isReply) !== 'true') return null;
+  if (String(message.showInChannel) === 'true') return null;
+  const id = parseMessageReference(message.mainMessage)?.id;
+  return id ? String(id) : null;
+};
+
+/** `a` then `b`, one entry per message id, oldest first. */
+export const mergeById = (a: IMessage[], b: IMessage[]): IMessage[] => {
+  const seen = new Set<string>();
+  const merged: IMessage[] = [];
+  for (const message of [...a, ...b]) {
+    const key = String(message.id);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(message);
+  }
+  const time = (message: IMessage) => {
+    const value = new Date(message.date).getTime();
+    return Number.isNaN(value) ? 0 : value;
+  };
+  return merged.sort((x, y) => time(x) - time(y));
+};

package/src/helpers/jumpToMessage.ts

@@ -0,0 +1,57 @@
+import type { IMessage } from '../types/types';
+
+// How far apart the archive's timestamp and the transcript's may be for the
+// same message. They are recorded by different components, so they are not
+// identical, but never more than a moment apart.
+export const CONTENT_MATCH_WINDOW_MS = 5000;
+
+/**
+ * Index of the message a jump names.
+ *
+ * By id first (message.id is the MAM stanza id for history, xmppId the client
+ * message id). When the request has no id at all, which is common for archive
+ * rows, by content: same text, sent within a few seconds of the same time.
+ */
+export const findMessageIndex = (
+  messages: IMessage[],
+  ids: string[],
+  content?: { createdAt?: string; body?: string }
+): number => {
+  if (ids.length > 0) {
+    const byId = messages.findIndex(
+      (message) =>
+        ids.includes(String(message.id)) ||
+        (message.xmppId ? ids.includes(String(message.xmppId)) : false)
+    );
+    if (byId >= 0) {return byId;}
+  }
+
+  if (!content?.createdAt || !content.body) {return -1;}
+  const wanted = new Date(content.createdAt).getTime();
+  if (Number.isNaN(wanted)) {return -1;}
+  const body = content.body.trim();
+  return messages.findIndex((message) => {
+    if (String(message.body ?? '').trim() !== body) {return false;}
+    return (
+      Math.abs(new Date(message.date).getTime() - wanted) <=
+      CONTENT_MATCH_WINDOW_MS
+    );
+  });
+};
+
+export const MAX_SCROLL_RETRIES = 4;
+
+/**
+ * FlatList only knows the position of rows it has measured, so
+ * scrollToIndex fails for a row far from the rendered window. The usual
+ * remedy: scroll to an estimated offset (which renders that region), then
+ * try scrollToIndex again. Returns the offset to estimate to, or null once
+ * the retry budget is spent.
+ */
+export const scrollRetryOffset = (
+  info: { index: number; averageItemLength: number },
+  attempt: number
+): number | null => {
+  if (attempt >= MAX_SCROLL_RETRIES) {return null;}
+  return Math.max(0, info.averageItemLength * info.index);
+};

package/src/helpers/jumpWindow.ts

@@ -0,0 +1,212 @@
+import type { HistoryWindowPage } from '../networking/xmppClient';
+import type { JumpWindow } from '../roomStore/roomsSlice';
+import { IMessage } from '../types/types';
+
+/** Messages shown above / below the target when a window opens (tunable). */
+export const JUMP_WINDOW_BEFORE = 10;
+export const JUMP_WINDOW_AFTER = 10;
+/** Page size for loading more once the reader scrolls toward either edge. */
+export const JUMP_WINDOW_PAGE = 20;
+
+/** The slice of the XMPP client the window helpers need. */
+export interface HistoryWindowClient {
+  getHistoryWindow: (
+    chatJID: string,
+    max: number,
+    cursor: { before?: number; after?: number; start?: string; end?: string }
+  ) => Promise<HistoryWindowPage>;
+}
+
+export type JumpWindowResult =
+  /** The window around the target is ready to be shown. */
+  | { status: 'found'; window: JumpWindow }
+  /** The server answered, and the target is not in the archive. */
+  | { status: 'missing' }
+  /** No usable id, or a request failed: use the paging path instead. */
+  | { status: 'unavailable' };
+
+// MAM stanza ids are microsecond timestamps (16 digits today).
+const MAM_ID = /^\d{13,}$/;
+
+/**
+ * How far apart the archive's timestamp and the transcript's may be for the
+ * same message. They are recorded by different components, so they are not
+ * identical, but never more than a moment apart.
+ */
+export const CONTENT_MATCH_WINDOW_MS = 5000;
+/** Rows asked for per page while locating a row by its time. */
+const TIME_LOOKUP_PAGE = 50;
+/** Pages of the time range read before giving up (a very busy 10 seconds). */
+const TIME_LOOKUP_MAX_PAGES = 4;
+
+/** What a hit with no archive id can be located by. */
+export interface JumpContent {
+  createdAt?: string;
+  body?: string;
+}
+
+export const mamIdCandidates = (ids: string[]): string[] =>
+  Array.from(new Set(ids.map(String).filter((id) => MAM_ID.test(id))));
+
+/**
+ * Fetches about JUMP_WINDOW_BEFORE messages before the target, the target and
+ * about JUMP_WINDOW_AFTER after it: two MAM queries in parallel (the target
+ * itself comes with the "after" page, asked from one microsecond before it).
+ * Nothing is written to the store here.
+ */
+export async function loadJumpWindow(
+  client: HistoryWindowClient,
+  roomJID: string,
+  ids: string[],
+  content?: JumpContent
+): Promise<JumpWindowResult> {
+  const candidates = mamIdCandidates(ids);
+  if (candidates.length === 0) {
+    return content?.createdAt && content.body
+      ? loadJumpWindowByTime(client, roomJID, content)
+      : { status: 'unavailable' };
+  }
+
+  // Almost always one candidate; a second is only tried when the first one is
+  // not an archive id after all (the server then simply does not return it).
+  for (const candidate of candidates) {
+    const id = Number(candidate);
+    const [older, newer] = await Promise.all([
+      client.getHistoryWindow(roomJID, JUMP_WINDOW_BEFORE, { before: id }),
+      client.getHistoryWindow(roomJID, JUMP_WINDOW_AFTER + 1, {
+        after: id - 1,
+      }),
+    ]);
+    if (!older.ok || !newer.ok) return { status: 'unavailable' };
+
+    const target = newer.messages.find(
+      (message) => String(message.id) === candidate
+    );
+    if (!target) continue;
+
+    return {
+      status: 'found',
+      window: {
+        roomJID,
+        messages: [...older.messages, ...newer.messages],
+        targetId: String(target.id),
+        olderCursor: older.first ?? id,
+        hasOlder: !older.complete && older.first !== null,
+        newerCursor: newer.last ?? id,
+        hasNewer: !newer.complete && newer.last !== null,
+      },
+    };
+  }
+  // None of the ids was an archive id. A hit that also knows its text and time
+  // can still be located by them.
+  if (content?.createdAt && content.body) {
+    return loadJumpWindowByTime(client, roomJID, content);
+  }
+  return { status: 'missing' };
+}
+
+/**
+ * For a hit with no usable archive id (older archive documents carry neither a
+ * stanza id nor a message id): ask the server for the rows within a few
+ * seconds of its timestamp (MAM start/end filter), find the one with the same
+ * text, and continue exactly as the id-based window does with that row's id.
+ * The server's answer is final: 'missing' only when it said the range holds no
+ * such row.
+ */
+export async function loadJumpWindowByTime(
+  client: HistoryWindowClient,
+  roomJID: string,
+  content: JumpContent
+): Promise<JumpWindowResult> {
+  const wanted = new Date(content.createdAt ?? '').getTime();
+  const body = (content.body ?? '').trim();
+  if (Number.isNaN(wanted) || !body) return { status: 'unavailable' };
+
+  const start = new Date(wanted - CONTENT_MATCH_WINDOW_MS).toISOString();
+  const end = new Date(wanted + CONTENT_MATCH_WINDOW_MS).toISOString();
+
+  let after: number | undefined;
+  let best: IMessage | null = null;
+  for (let page = 0; page < TIME_LOOKUP_MAX_PAGES; page += 1) {
+    const result = await client.getHistoryWindow(
+      roomJID,
+      TIME_LOOKUP_PAGE,
+      after === undefined ? { start, end } : { start, end, after }
+    );
+    if (!result.ok) return { status: 'unavailable' };
+    for (const message of result.messages) {
+      if (String(message.body ?? '').trim() !== body) continue;
+      const gap = Math.abs(new Date(message.date).getTime() - wanted);
+      if (gap > CONTENT_MATCH_WINDOW_MS) continue;
+      if (
+        !best ||
+        gap < Math.abs(new Date(best.date).getTime() - wanted)
+      ) {
+        best = message;
+      }
+    }
+    if (best) break;
+    if (result.complete || result.last === null) {
+      return { status: 'missing' };
+    }
+    after = result.last;
+  }
+  if (!best) return { status: 'unavailable' };
+
+  const id = String(best.id);
+  if (!MAM_ID.test(id)) return { status: 'unavailable' };
+  return loadJumpWindow(client, roomJID, [id]);
+}
+
+export interface OlderWindowPage {
+  messages: IMessage[];
+  olderCursor: number | null;
+  hasOlder: boolean;
+}
+
+export interface NewerWindowPage {
+  messages: IMessage[];
+  newerCursor: number | null;
+  hasNewer: boolean;
+}
+
+/** The page above the window; null when the request failed. */
+export async function loadOlderWindowPage(
+  client: HistoryWindowClient,
+  window: JumpWindow
+): Promise<OlderWindowPage | null> {
+  if (window.olderCursor === null) {
+    return { messages: [], olderCursor: null, hasOlder: false };
+  }
+  const page = await client.getHistoryWindow(window.roomJID, JUMP_WINDOW_PAGE, {
+    before: window.olderCursor,
+  });
+  if (!page.ok) return null;
+  // A page that does not move the cursor would be asked for again forever.
+  const progressed = page.first !== null && page.first < window.olderCursor;
+  return {
+    messages: page.messages,
+    olderCursor: progressed ? page.first : window.olderCursor,
+    hasOlder: progressed && !page.complete,
+  };
+}
+
+/** The page below the window; null when the request failed. */
+export async function loadNewerWindowPage(
+  client: HistoryWindowClient,
+  window: JumpWindow
+): Promise<NewerWindowPage | null> {
+  if (window.newerCursor === null) {
+    return { messages: [], newerCursor: null, hasNewer: false };
+  }
+  const page = await client.getHistoryWindow(window.roomJID, JUMP_WINDOW_PAGE, {
+    after: window.newerCursor,
+  });
+  if (!page.ok) return null;
+  const progressed = page.last !== null && page.last > window.newerCursor;
+  return {
+    messages: page.messages,
+    newerCursor: progressed ? page.last : window.newerCursor,
+    hasNewer: progressed && !page.complete,
+  };
+}

package/src/helpers/loadRoomHistory.ts

@@ -0,0 +1,83 @@
+import type { IRoom } from '../types/types';
+
+/** The slice of the XMPP client the history loader needs. */
+export interface HistoryPageClient {
+  getHistoryStanza: (
+    chatJID: string,
+    max: number,
+    before?: number,
+    id?: string,
+    options?: { source?: 'active' | 'send_ack' | 'background' | 'default' }
+  ) => Promise<unknown>;
+}
+
+/**
+ * Where the next page of older history starts when the caller names no
+ * anchor: the server's own paging cursor, or the oldest message that carries a
+ * numeric archive id, whichever is older. Never a position in the message
+ * list: a page made only of receipts or reactions adds nothing to it, so a
+ * position keeps pointing at the same message and paging stalls.
+ */
+export const resolveHistoryBefore = (
+  room: Pick<IRoom, 'messages' | 'messageStats'> | undefined,
+  explicit?: number
+): number | undefined => {
+  if (typeof explicit === 'number' && Number.isFinite(explicit)) {return explicit;}
+  if (!room) {return undefined;}
+  const candidates: number[] = [];
+  const cursor = room.messageStats?.firstMessageTimestamp;
+  if (typeof cursor === 'number' && Number.isFinite(cursor)) {
+    candidates.push(cursor);
+  }
+  for (const message of room.messages ?? []) {
+    const id = Number(message.id);
+    if (Number.isFinite(id) && id > 0) {candidates.push(id);}
+  }
+  return candidates.length > 0 ? Math.min(...candidates) : undefined;
+};
+
+export interface LoadRoomHistoryParams {
+  client: HistoryPageClient | null | undefined;
+  /** The room as it is in the store NOW (read at call time, not from a render). */
+  room: IRoom | undefined;
+  /** Rooms with a request in flight: one request per room at a time. */
+  inFlight: Set<string>;
+  chatJID: string;
+  max: number;
+  before?: number;
+  /** Told when the first request starts and when the last one ends. */
+  onBusyChange?: (busy: boolean) => void;
+}
+
+/**
+ * One page of older history for a room. Always settles and never rejects: a
+ * failed page must not leave the room blocked or reject into the caller's
+ * chain. Does nothing for a room that is complete, unknown, or already loading.
+ */
+export async function loadRoomHistory({
+  client,
+  room,
+  inFlight,
+  chatJID,
+  max,
+  before,
+  onBusyChange,
+}: LoadRoomHistoryParams): Promise<void> {
+  if (!client || !chatJID) {return;}
+  if (inFlight.has(chatJID)) {return;}
+  if (!room || room.historyComplete) {return;}
+
+  const anchor = resolveHistoryBefore(room, before);
+  inFlight.add(chatJID);
+  onBusyChange?.(true);
+  try {
+    await client.getHistoryStanza(chatJID, max, anchor, undefined, {
+      source: 'active',
+    });
+  } catch {
+    // swallowed on purpose, see above
+  } finally {
+    inFlight.delete(chatJID);
+    onBusyChange?.(inFlight.size > 0);
+  }
+}