@ethora/chat-component-rn 26.9.1 → 26.10.0

package/src/helpers/notificationPolicy.ts

@@ -0,0 +1,82 @@
+import { isOwnMessage } from './isOwnMessage';
+import type { IMessage } from '../types/types';
+
+/**
+ * Who decides whether an incoming live message raises an in-app toast.
+ * Same rules as the web client's notificationPolicy, plus the room-level
+ * one RN shows: a toast is for a message in ANOTHER chat, from SOMEONE
+ * ELSE, while the app is on screen.
+ */
+
+/** `Room@Conference.Host/nick` → `room@conference.host`. */
+export const bareJid = (jid: unknown): string =>
+  String(jid ?? '').split('/')[0].trim().toLowerCase();
+
+/** `user@host/res` → `user`; a bare id stays as it is. Lowercased. */
+const localPart = (id: unknown): string =>
+  String(id ?? '').split('/')[0].split('@')[0].trim().toLowerCase();
+
+export interface CurrentUserIds {
+  xmppUsername?: string | null;
+  walletAddress?: string | null;
+  id?: string | null;
+}
+
+/**
+ * The reader's own message, coming back from the room. Any one of these is
+ * enough, because each sender path fills a different one:
+ *   • the MUC nickname (the occupant resource of the stanza's `from`),
+ *     which is the sender's XMPP local part;
+ *   • the `senderJID` the sender put in `<data>`;
+ *   • the parsed message's user id (what the bubble's own/other side uses).
+ * The old check only looked for the wallet address inside `senderJID`, so
+ * an account whose XMPP name is not its wallet got toasts for its own
+ * messages.
+ */
+export const isOwnIncomingMessage = ({
+  message,
+  stanzaFrom,
+  senderJID,
+  user,
+}: {
+  message: Pick<IMessage, 'user'> | null | undefined;
+  stanzaFrom?: string | null;
+  senderJID?: string | null;
+  user: CurrentUserIds | null | undefined;
+}): boolean => {
+  const mine = [user?.xmppUsername, user?.walletAddress]
+    .map(localPart)
+    .filter(Boolean);
+  if (!mine.length) {return false;}
+  const nickname = String(stanzaFrom ?? '').split('/')[1];
+  const candidates = [nickname, senderJID].map(localPart).filter(Boolean);
+  if (candidates.some((id) => mine.includes(id))) {return true;}
+  return isOwnMessage(message, user ?? undefined);
+};
+
+/**
+ * Whether a toast for a message in `roomJID` should show right now. Read
+ * at the moment the message arrives (not from a render closure).
+ */
+export const shouldToastForRoom = ({
+  roomJID,
+  visibleRoomJID,
+  appActive,
+  muted,
+}: {
+  roomJID: string;
+  visibleRoomJID?: string | null;
+  appActive: boolean;
+  muted?: boolean;
+}): boolean => {
+  // Off screen: the OS push is the channel; a banner would only pop up,
+  // stale, when the user comes back.
+  if (!appActive) {return false;}
+  // The user is reading that chat: the message is already on screen.
+  if (visibleRoomJID && bareJid(visibleRoomJID) === bareJid(roomJID)) {
+    return false;
+  }
+  // Notifications for that chat are off.
+  if (muted) {return false;}
+  return true;
+};

package/src/helpers/openRoomAtMessage.ts

@@ -0,0 +1,38 @@
+import { AppDispatch } from '../roomStore';
+import { requestJumpToMessage, setCurrentRoom } from '../roomStore/roomsSlice';
+
+type MaybeId = string | number | null | undefined;
+
+/**
+ * Every id a caller may know the target message by, without blanks and
+ * duplicates. A notification, a push payload or a link can carry the client
+ * (xmpp) message id, the archive stanza id or the stored message id, and the
+ * jump matcher checks message.id and message.xmppId, so all of them go in.
+ */
+export const collectMessageIds = (...candidates: MaybeId[]): string[] => {
+  const ids: string[] = [];
+  for (const candidate of candidates) {
+    const id =
+      candidate === null || candidate === undefined
+        ? ''
+        : String(candidate).trim();
+    if (id && !ids.includes(id)) {ids.push(id);}
+  }
+  return ids;
+};
+
+/**
+ * Open a room and, when the caller knows which message it is about, ask the
+ * mounted room to land on it (see useJumpToMessage). With no message id this
+ * is just "open the room".
+ */
+export const openRoomAtMessage = (
+  dispatch: AppDispatch,
+  roomJID: string,
+  ...messageIds: MaybeId[]
+): void => {
+  if (!roomJID) {return;}
+  dispatch(setCurrentRoom({ roomJID }));
+  const ids = collectMessageIds(...messageIds);
+  if (ids.length > 0) {dispatch(requestJumpToMessage({ roomJID, ids }));}
+};

package/src/helpers/openThreadForJump.ts

@@ -0,0 +1,96 @@
+import type { AppDispatch } from '../roomStore';
+import { setActiveMessage } from '../roomStore/roomsSlice';
+import { IMessage } from '../types/types';
+import {
+  HistoryWindowClient,
+  loadJumpWindow,
+} from './jumpWindow';
+import {
+  mergeById,
+  replyParentId,
+  setJumpThread,
+} from './jumpThread';
+
+const isIn = (messages: IMessage[], id: string) =>
+  messages.find(
+    (message) => String(message.id) === id || String(message.xmppId) === id
+  );
+
+const repliesOf = (messages: IMessage[], parentId: string) =>
+  messages.filter((message) => replyParentId(message) === parentId);
+
+export interface OpenThreadForJumpParams {
+  client?: HistoryWindowClient | null;
+  dispatch: AppDispatch;
+  roomJID: string;
+  /** The pending request this opens a thread for. */
+  at: number;
+  /** The reply the jump named. */
+  reply: IMessage;
+  /** The room's live messages, unfiltered. */
+  live: IMessage[];
+  /** Messages found alongside the reply (a window), unfiltered. */
+  nearby?: IMessage[];
+}
+
+/**
+ * Opens the thread a reply belongs to, so a jump to the reply can highlight it
+ * there. Resolves true when the thread is open (or about to be), false when
+ * the parent could not be obtained.
+ *
+ * The parent comes from the live list (the usual thread flag), from the
+ * messages found next to the reply, or, when it is in neither, from a window
+ * around the parent fetched for the purpose.
+ */
+export async function openThreadForJump({
+  client,
+  dispatch,
+  roomJID,
+  at,
+  reply,
+  live,
+  nearby = [],
+}: OpenThreadForJumpParams): Promise<boolean> {
+  const parentId = replyParentId(reply);
+  if (!parentId) return false;
+
+  const known = mergeById(live, nearby);
+  const liveParent = isIn(live, parentId);
+  if (liveParent) {
+    setJumpThread({
+      roomJID,
+      parentId: String(liveParent.id),
+      at,
+      parent: null,
+      replies: repliesOf(known, parentId).concat(reply),
+    });
+    dispatch(setActiveMessage({ id: String(liveParent.id), chatJID: roomJID }));
+    return true;
+  }
+
+  let parent = isIn(nearby, parentId);
+  let replies = repliesOf(known, parentId).concat(reply);
+
+  if (!parent) {
+    if (!client) return false;
+    let result;
+    try {
+      result = await loadJumpWindow(client, roomJID, [parentId]);
+    } catch {
+      return false;
+    }
+    if (result.status !== 'found') return false;
+    parent = isIn(result.window.messages, parentId);
+    if (!parent) return false;
+    replies = replies.concat(repliesOf(result.window.messages, parentId));
+  }
+
+  setJumpThread({
+    roomJID,
+    parentId: String(parent.id),
+    at,
+    parent,
+    replies: mergeById(replies, []),
+  });
+  return true;
+}

package/src/helpers/parseMessageReference.ts

@@ -6,17 +6,46 @@ export interface MessageReference {
   userName?: string;
 }
 
+/** Loose view of a raw `mainMessage` JSON string (fields as sent). */
+export interface ParsedMessageReference {
+  id?: string;
+  text?: string;
+  roomJid?: string;
+  userName?: string;
+}
+
 const cache = new WeakMap<object, MessageReference | null>();
 
 /**
- * Safe read of `message.mainMessage` (a JSON string on the wire). Null for
- * a missing or malformed value — a bad payload must not crash a bubble.
- * Cached per message object.
+ * Safe read of a reply's parent reference. Null for a missing or malformed
+ * value: a bad payload must not crash a bubble.
+ *
+ * Two call forms are supported:
+ *  - `parseMessageReference(message)` reads `message.mainMessage`, returns a
+ *    normalised MessageReference (id always a string) and is cached per
+ *    message object;
+ *  - `parseMessageReference(rawJsonString)` returns the parsed object as sent.
  */
-export const parseMessageReference = (message: {
-  mainMessage?: string;
-} | null | undefined): MessageReference | null => {
-  if (!message?.mainMessage) {return null;}
+export function parseMessageReference(
+  input: { mainMessage?: string } | null | undefined
+): MessageReference | null;
+export function parseMessageReference(
+  input: unknown
+): ParsedMessageReference | null;
+export function parseMessageReference(input: unknown): any {
+  if (typeof input === 'string') {
+    if (input.trim() === '') {return null;}
+    try {
+      const parsed = JSON.parse(input);
+      return parsed && typeof parsed === 'object' ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+  const message = input as { mainMessage?: string } | null | undefined;
+  if (!message || typeof message !== 'object' || !message.mainMessage) {
+    return null;
+  }
   const cached = cache.get(message);
   if (cached !== undefined) {return cached;}
   let ref: MessageReference | null = null;
@@ -35,4 +64,4 @@ export const parseMessageReference = (message: {
   }
   cache.set(message, ref);
   return ref;
-};
+}

package/src/helpers/publicChatsEntry.ts

@@ -0,0 +1,15 @@
+import type { IConfig } from '../types/types';
+
+/**
+ * "Discover chats" lives in the room list menu sheet. A host that takes the
+ * burger over (`headerMenu` as a function) or hides the menu
+ * (`chatHeaderSettings.disableMenu`) would otherwise have no obvious way to
+ * reach the directory, so it also gets a button of its own in the room list
+ * header. `disableRoomMenu` removes the menu entry point, and with it the
+ * button; `disablePublicChatsDirectory` removes the feature altogether.
+ */
+export const showsStandaloneDiscoverButton = (config?: IConfig): boolean =>
+  !config?.disablePublicChatsDirectory &&
+  !config?.disableRoomMenu &&
+  (Boolean(config?.chatHeaderSettings?.disableMenu) ||
+    typeof config?.headerMenu === 'function');

package/src/helpers/roomActivityScore.ts

@@ -0,0 +1,45 @@
+import { IMessage, IRoom } from '../types/types';
+import { getTimestampFromUnknown, normalizeTimestampValue } from './timestamp';
+
+export const getMessageTimestamp = (message?: IMessage): number => {
+  if (!message) return 0;
+
+  const hasExplicitTimestamp = Object.prototype.hasOwnProperty.call(
+    message || {},
+    'messageTimestampMs'
+  );
+  if (hasExplicitTimestamp) {
+    return getTimestampFromUnknown((message as any)?.messageTimestampMs);
+  }
+
+  return (
+    getTimestampFromUnknown(message?.date) ||
+    getTimestampFromUnknown((message as any)?.timestamp) ||
+    getTimestampFromUnknown(message?.id)
+  );
+};
+
+export const getLastLocalMessageTimestamp = (room?: IRoom): number => {
+  if (!room?.messages?.length) return 0;
+  for (let i = room.messages.length - 1; i >= 0; i -= 1) {
+    const message = room.messages[i];
+    if (!message || message.id === 'delimiter-new' || message.pending) continue;
+    const ts = getMessageTimestamp(message);
+    if (ts > 0) return ts;
+  }
+  return 0;
+};
+
+export const getRoomLastActivityScore = (room?: IRoom): number => {
+  if (!room) return 0;
+  // Everything normalised to milliseconds: the MAM-derived timestamps are
+  // archive ids (microseconds), which made any room that had one outrank a
+  // room whose only signal is in ms. `lastMessage.date` is the API's seed
+  // for a room that has loaded nothing yet - the newest of all signals wins.
+  return Math.max(
+    normalizeTimestampValue(Number(room.lastMessageTimestamp || 0)),
+    normalizeTimestampValue(Number(room.messageStats?.lastMessageTimestamp || 0)),
+    getLastLocalMessageTimestamp(room),
+    getTimestampFromUnknown(room.lastMessage?.date)
+  );
+};

package/src/helpers/roomUserCount.ts

@@ -0,0 +1,44 @@
+import { IRoom } from '../types/types';
+
+type CountSource =
+  | Pick<IRoom, 'members' | 'usersCnt'>
+  | { members?: unknown; usersCnt?: unknown }
+  | null
+  | undefined;
+
+/**
+ * User count to DISPLAY for a room. /chats/my returns `usersCnt` (the true
+ * total) but at most 30 members for big public rooms, so the truncated
+ * members array must never win over usersCnt.
+ */
+export const getRoomUserCount = (room: CountSource): number => {
+  const members = Array.isArray(room?.members) ? room.members.length : 0;
+  const cnt =
+    typeof room?.usersCnt === 'number' && Number.isFinite(room.usersCnt)
+      ? room.usersCnt
+      : 0;
+  return Math.max(cnt, members);
+};
+
+/** True when the room is known to have more users than members loaded. */
+export const isRoomMembersTruncated = (room: CountSource): boolean => {
+  const members = Array.isArray(room?.members) ? room.members.length : 0;
+  const cnt =
+    typeof room?.usersCnt === 'number' && Number.isFinite(room.usersCnt)
+      ? room.usersCnt
+      : 0;
+  return cnt > members;
+};
+
+/**
+ * Next usersCnt after a live join (+1) or leave (-1). Adjusts the CURRENT
+ * count instead of recomputing from the (possibly truncated) members array.
+ */
+export const adjustUsersCnt = (
+  room: CountSource,
+  delta: 1 | -1,
+  nextMembersLength: number
+): number => {
+  const current = getRoomUserCount(room);
+  return Math.max(nextMembersLength, current + delta, 0);
+};

package/src/helpers/runConfiguredHistoryPreload.ts

@@ -0,0 +1,76 @@
+import XmppClient from '../networking/xmppClient';
+import { store } from '../roomStore';
+import { IConfig } from '../types/types';
+import { runHistoryPreloadScheduler } from './historyPreloadScheduler';
+import {
+  resolveHistoryPreloadConfig,
+  TEASER_ROOM_FACTOR,
+} from './historyPreloadConfig';
+
+export interface ConfiguredPreloadOptions {
+  client: XmppClient;
+  config?: Pick<IConfig, 'historyPreload' | 'historyQoS' | 'defaultRooms'> | null;
+  signal?: AbortSignal;
+}
+
+/**
+ * The preload a host's config asks for, in one place (the provider's
+ * initBeforeLoad bootstrap and any other start point share it):
+ * - 'off': nothing, rooms load when opened.
+ * - 'all': every room, one pass (the old behaviour for small accounts).
+ * - 'staged' (default): rooms still lacking a list preview get a one-message
+ *   page first, then the top-N rooms by activity get a full first page;
+ *   everything else loads when opened.
+ * - 'legacy' (historyQoS.stagedPreloadEnabled === false): the previous single
+ *   pass over every room (capped by preloadTopKRooms when set).
+ */
+export const runConfiguredHistoryPreload = async ({
+  client,
+  config,
+  signal,
+}: ConfiguredPreloadOptions): Promise<void> => {
+  const cfg = resolveHistoryPreloadConfig(config as any);
+  if (cfg.mode === 'off') {return;}
+
+  const common = {
+    client,
+    signal,
+    concurrency: cfg.concurrency,
+    selectedRoomJid: store.getState().rooms.activeRoomJID || null,
+    defaultRoomJids: (config?.defaultRooms || [])
+      .map((room: any) => (typeof room === 'string' ? room : room?.jid))
+      .filter(Boolean) as string[],
+  };
+
+  if (cfg.mode === 'legacy') {
+    await runHistoryPreloadScheduler({
+      ...common,
+      pageSize: config?.historyQoS?.stagedPreloadFirstPassSize,
+      roomLimit: config?.historyQoS?.preloadTopKRooms,
+    });
+    return;
+  }
+
+  if (cfg.mode === 'staged') {
+    // Pass 1 (preview): a one-message page for rooms the list cannot render
+    // a preview for yet. Rooms with an API `lastMessage` cost nothing.
+    await runHistoryPreloadScheduler({
+      ...common,
+      pageSize: cfg.firstPassSize,
+      retryLimit: 2,
+      roomLimit: cfg.topRooms ? cfg.topRooms * TEASER_ROOM_FACTOR : undefined,
+      skipApiPreview: true,
+      // 'partial' so pass 2 still fetches the real page for these rooms.
+      completionState: 'partial',
+    });
+  }
+
+  // Pass 2: the real page, for the top-N rooms only (all rooms in 'all').
+  await runHistoryPreloadScheduler({
+    ...common,
+    pageSize: cfg.secondPassSize,
+    roomLimit: cfg.topRooms || undefined,
+  });
+};
+
+export default runConfiguredHistoryPreload;

package/src/helpers/sessionAppId.ts

@@ -0,0 +1,17 @@
+import { store } from '../roomStore';
+
+/**
+ * The appId of the current session. RN's chat store has no standalone
+ * `appId` field the way web's does, so it is read from the signed-in user
+ * (`user.appId`), then the host config (`config.appId`), then the prefix of
+ * the user's own `<appId>_<userId>` xmppUsername. Empty when unknown.
+ */
+export const getSessionAppId = (): string => {
+  const state = store.getState().chatSettingStore as any;
+  const fromUser = String(state?.user?.appId || '').trim();
+  if (fromUser) return fromUser;
+  const fromConfig = String(state?.config?.appId || '').trim();
+  if (fromConfig) return fromConfig;
+  const own = String(state?.user?.xmppUsername || '');
+  return own.includes('_') ? own.split('_')[0] : '';
+};

package/src/helpers/timestamp.ts

@@ -0,0 +1,44 @@
+const MILLISECONDS_LOWER_BOUND = 1e11;
+const MICROSECONDS_UPPER_BOUND = 1e14;
+const NANOS_UPPER_BOUND = 1e17;
+
+export const normalizeTimestampValue = (value: number): number => {
+  if (!Number.isFinite(value) || value <= 0) return 0;
+  if (value < MILLISECONDS_LOWER_BOUND) return value * 1000; // seconds -> milliseconds
+  if (value > NANOS_UPPER_BOUND) return Math.floor(value / 1_000_000); // nanoseconds -> milliseconds
+  if (value > MICROSECONDS_UPPER_BOUND) return Math.floor(value / 1000); // microseconds -> milliseconds
+  return value; // already milliseconds
+};
+
+export const getTimestampFromUnknown = (value: unknown): number => {
+  if (value == null) return 0;
+
+  if (value instanceof Date) {
+    const ts = value.getTime();
+    return Number.isFinite(ts) && ts > 0 ? ts : 0;
+  }
+
+  if (typeof value === 'number') {
+    return normalizeTimestampValue(value);
+  }
+
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if (!trimmed) return 0;
+
+    if (/^\d+$/.test(trimmed)) {
+      return normalizeTimestampValue(Number(trimmed));
+    }
+
+    const parsedDate = new Date(trimmed).getTime();
+    if (Number.isFinite(parsedDate) && parsedDate > 0) return parsedDate;
+
+    const numericChunk = trimmed.match(/\d{10,}/)?.[0];
+    if (numericChunk) {
+      return normalizeTimestampValue(Number(numericChunk));
+    }
+  }
+
+  return 0;
+};
+