@ethora/chat-component-rn 26.9.1 → 26.10.0

package/src/helpers/createRoomFromApi.tsx

@@ -1,7 +1,14 @@
 import { ApiRoom, IRoom } from '../types/types';
 import type { LastMessage } from '../types/models/message.model';
 
-const mapApiLastMessage = (
+/**
+ * Maps the flattened `lastMessage` doc `GET /v1/chats/my` embeds per room
+ * into the shape a live message already takes. Backends differ in whether
+ * they send it at all, so every field is optional and its absence changes
+ * nothing. It is only ever a SEED for the room-list preview (and for the
+ * unread middleware's "read past the API's last message" check).
+ */
+export const mapApiLastMessage = (
   apiLastMessage: ApiRoom['lastMessage'],
   roomJid: string
 ): LastMessage | undefined => {
@@ -24,6 +31,37 @@ const mapApiLastMessage = (
   } as LastMessage;
 };
 
+/**
+ * The unread count the server reported for a room, or undefined when the
+ * backend sends none (then the local MAM-based count is the only source).
+ */
+export const readApiUnreadCount = (item: {
+  unreadCount?: unknown;
+}): number | undefined => {
+  const raw = item?.unreadCount;
+  return typeof raw === 'number' && Number.isFinite(raw)
+    ? Math.max(0, Math.floor(raw))
+    : undefined;
+};
+
+/**
+ * Room user count from a /chats/my item: the API total (`usersCnt`, or the
+ * older `participants`) when it is bigger than the page of members the
+ * response carries (big public rooms list at most 30), else the members
+ * length, else the supplied fallback.
+ */
+export const readApiUsersCnt = (
+  item: Pick<ApiRoom, 'members' | 'usersCnt'> & { participants?: unknown },
+  fallback: number = 0
+): number => {
+  const membersLen = Array.isArray(item?.members) ? item.members.length : 0;
+  const total = Number(item?.usersCnt ?? item?.participants);
+  if (Number.isFinite(total) && total > 0) {
+    return Math.max(total, membersLen);
+  }
+  return membersLen || fallback;
+};
+
 const seedTimestamp = (seed: LastMessage | undefined): number | undefined => {
   if (!seed) {return undefined;}
   const id = Number(seed.id);
@@ -39,6 +77,7 @@ export const createRoomFromApi = (
 ): IRoom | null => {
   try {
     const jid = `${room?.name}@${service}` || '';
+    const apiUnreadCount = readApiUnreadCount(room);
     const lastMessage = mapApiLastMessage(room?.lastMessage, jid);
     const roomData: IRoom = {
       ...room,
@@ -46,16 +85,18 @@ export const createRoomFromApi = (
       jid,
       name: room?.title || '',
       title: room?.title || '',
-      usersCnt: Number(room?.members?.length || usersArrayLength + 1),
+      usersCnt: readApiUsersCnt(room, usersArrayLength + 1),
       messages: [],
       isLoading: false,
       roomBg: null,
       icon: room?.picture !== 'none' ? room?.picture : null,
-      unreadMessages: 0,
+      unreadMessages: apiUnreadCount ?? 0,
+      apiUnreadCount,
+      apiUnreadSeededAt: apiUnreadCount === undefined ? undefined : Date.now(),
       lastViewedTimestamp: 0,
       lastMessage,
       lastMessageTimestamp: seedTimestamp(lastMessage),
-    };
+    } as IRoom;
     return roomData;
   } catch (error) {
     console.log(error);

package/src/helpers/dedupeMembers.ts

@@ -0,0 +1,29 @@
+import type { RoomMember } from '../types/types';
+
+/** Stable identity of a member: normalised xmppUsername local part, else _id. */
+export const memberKey = (m: Partial<RoomMember> | null | undefined): string => {
+  const x = String(m?.xmppUsername || '').split('@')[0].trim().toLowerCase();
+  if (x) return x;
+  return String(m?._id || (m as any)?.jid || '').split('@')[0].trim().toLowerCase();
+};
+
+/**
+ * Drops repeated members (keeps the first occurrence, order preserved).
+ * The room directory endpoint can return the same user on several pages;
+ * duplicates would produce duplicate React keys and inflated counts.
+ * Members without any identity are dropped.
+ */
+export const dedupeMembers = <T extends Partial<RoomMember>>(
+  list: ReadonlyArray<T> | null | undefined
+): T[] => {
+  if (!list?.length) return [];
+  const seen = new Set<string>();
+  const out: T[] = [];
+  for (const m of list) {
+    const k = memberKey(m);
+    if (!k || seen.has(k)) continue;
+    seen.add(k);
+    out.push(m);
+  }
+  return out;
+};

package/src/helpers/ethoraLogger.ts

@@ -0,0 +1,50 @@
+// Verbose console output is on in development builds (React Native's
+// `__DEV__`) and, in release builds, only when the host set
+// `config.useStoreConsoleEnabled`. The store is read lazily so this module
+// can be imported from the reducer graph without an import cycle.
+const isVerboseConsoleEnabled = (): boolean => {
+  if (typeof __DEV__ !== 'undefined' && __DEV__ === true) {
+    return true;
+  }
+  try {
+    const { store } = require('../roomStore');
+    return (
+      store.getState().chatSettingStore?.config?.useStoreConsoleEnabled === true
+    );
+  } catch {
+    return false;
+  }
+};
+
+export const ethoraLogger = {
+  log: (...args: unknown[]) => {
+    if (isVerboseConsoleEnabled()) {
+      console.log(...args);
+    }
+  },
+  info: (...args: unknown[]) => {
+    if (isVerboseConsoleEnabled()) {
+      console.info(...args);
+    }
+  },
+  debug: (...args: unknown[]) => {
+    if (isVerboseConsoleEnabled()) {
+      console.debug(...args);
+    }
+  },
+  error: (...args: unknown[]) => {
+    if (isVerboseConsoleEnabled()) {
+      console.error(...args);
+    }
+  },
+  always: (...args: unknown[]) => {
+    console.log(...args);
+  },
+  /**
+   * For failures that must never be silent, whatever the verbose-console
+   * setting is.
+   */
+  criticalError: (...args: unknown[]) => {
+    console.error(...args);
+  },
+};

package/src/helpers/getUnnamedUsers.ts

@@ -5,7 +5,9 @@ import { IMessage, IUser, RoomMember } from '../types/types';
 function getUniqueUsers(messages: IMessage[]): Set<IUser> {
   const userMap = new Map<string, IUser>();
 
-  messages.forEach(({ user }) => {
+  messages.forEach((message) => {
+    const user = message?.user;
+    if (!user) {return;}
     if (!userMap.has(user.id)) {
       userMap.set(user.id, user);
     }
@@ -17,9 +19,10 @@ function getUniqueUsers(messages: IMessage[]): Set<IUser> {
 export const getUnnamedUsers = (messages: IMessage[]): IUser[] => {
   const uniqueUsers = getUniqueUsers(messages);
 
-  return [...uniqueUsers].filter((user) =>
-    user?.name?.toLowerCase().includes('deleted')
-  );
+  return [...uniqueUsers].filter((user) => {
+    const name = typeof user?.name === 'string' ? user.name.toLowerCase() : '';
+    return name.includes('deleted');
+  });
 };
 
 export const fixUnnamedArrayFromApi = async (

package/src/helpers/historyPreloadConfig.ts

@@ -0,0 +1,68 @@
+import type { IConfig } from '../types/types';
+
+export type HistoryPreloadMode = 'staged' | 'all' | 'off';
+
+export interface ResolvedHistoryPreload {
+  /**
+   * 'legacy' only when a host explicitly pinned
+   * `historyQoS.stagedPreloadEnabled: false`: the old cache catch-up path
+   * (updateMessagesTillLast). Everything else resolves to a public mode.
+   */
+  mode: HistoryPreloadMode | 'legacy';
+  /** Rooms (by recent activity) the background sweep covers. 0 = no cap. */
+  topRooms: number;
+  concurrency: number;
+  firstPassSize: number;
+  secondPassSize: number;
+}
+
+export const DEFAULT_PRELOAD_TOP_ROOMS = 8;
+export const DEFAULT_PRELOAD_CONCURRENCY = 3;
+// The one-message preview pass covers this many times `topRooms` rooms that
+// still have no preview (it is a tiny query next to a full page).
+export const TEASER_ROOM_FACTOR = 4;
+
+const positiveInt = (value: unknown): number | undefined => {
+  const n = Math.floor(Number(value));
+  return Number.isFinite(n) && n > 0 ? n : undefined;
+};
+
+/**
+ * One place that turns `config.historyPreload` (and the older
+ * `historyQoS.stagedPreload*` / `preloadTopKRooms` names, still honoured)
+ * into the numbers the preload sweeps use. Staged preload is the default:
+ * the sweep covers the top N rooms, every other room loads when it is opened.
+ */
+export const resolveHistoryPreloadConfig = (
+  config?: Pick<IConfig, 'historyPreload' | 'historyQoS'> | null
+): ResolvedHistoryPreload => {
+  const hp = config?.historyPreload;
+  const qos = config?.historyQoS;
+
+  let mode: ResolvedHistoryPreload['mode'];
+  if (hp?.mode === 'staged' || hp?.mode === 'all' || hp?.mode === 'off') {
+    mode = hp.mode;
+  } else if (qos?.stagedPreloadEnabled === false) {
+    mode = 'legacy';
+  } else {
+    mode = 'staged';
+  }
+
+  const topRooms =
+    mode === 'all'
+      ? 0
+      : (positiveInt(hp?.topRooms) ??
+        positiveInt(qos?.preloadTopKRooms) ??
+        DEFAULT_PRELOAD_TOP_ROOMS);
+
+  return {
+    mode,
+    topRooms,
+    concurrency:
+      positiveInt(hp?.concurrency) ??
+      positiveInt(qos?.stagedPreloadConcurrency) ??
+      DEFAULT_PRELOAD_CONCURRENCY,
+    firstPassSize: positiveInt(qos?.stagedPreloadFirstPassSize) ?? 1,
+    secondPassSize: positiveInt(qos?.stagedPreloadSecondPassSize) ?? 15,
+  };
+};