@ethora/chat-component-rn 26.8.5 → 26.8.7

package/src/helpers/insertMessageWithDelimiter.ts

@@ -1,5 +1,4 @@
 import { IMessage } from '../types/types';
-import { isDateAfter, isDateBefore } from './dateComparison';
 import { msgSortableMs } from './msgSortableMs';
 
 // Robustly resolve a caller-supplied read marker to epoch milliseconds.
@@ -90,17 +89,29 @@ export function insertMessageWithDelimiter(
     return;
   }
 
-  const newMessageDate = message.date;
   const lastMessage = roomMessages[roomMessages.length - 1];
-  const firstMessage = roomMessages[0];
+  // Ordered by the id-encoded server timestamp (msgSortableMs), the same
+  // key the list and the unread logic use. The old `date` string compare
+  // had a hole: a message neither strictly after the last one nor
+  // strictly before the first (same second, or an unparseable date) fell
+  // through every branch and was silently DROPPED.
+  const newMs = msgSortableMs(message);
+  const lastMs = lastMessage ? msgSortableMs(lastMessage) : 0;
 
-  if (isDateAfter(newMessageDate.toString(), lastMessage?.date?.toString() ?? '')) {
+  if (!lastMessage || !newMs || newMs >= lastMs) {
     const index = roomMessages.findIndex(
       (msg) => msg.id === message.xmppId || msg.id === message.id
     );
 
     if (index !== -1) {
-      roomMessages[index] = { ...message, id: message.id, pending: false };
+      // Keep an open thread open when its parent is replaced by the echo.
+      const keepThread = (roomMessages[index] as any)?.activeMessage;
+      roomMessages[index] = {
+        ...message,
+        id: message.id,
+        pending: false,
+        ...(keepThread ? { activeMessage: true } : {}),
+      };
     } else {
       roomMessages.push(message);
     }
@@ -153,18 +164,14 @@ export function insertMessageWithDelimiter(
         });
       }
     }
-  } 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;
-      }
+    // Before the first message strictly newer than it; equal keys keep
+    // arrival order.
+    const at = roomMessages.findIndex((msg) => msgSortableMs(msg) > newMs);
+    if (at === -1) {
+      roomMessages.push(message);
+    } else {
+      roomMessages.splice(at, 0, message);
     }
   }
 }

package/src/helpers/mamReactions.ts

@@ -0,0 +1,59 @@
+import { IMessage } from '../types/models/message.model';
+import { applyReactionToMessage, compareStanzaIds } from '../roomStore/roomsSlice';
+
+export interface ExtractedReaction {
+  messageId: string;
+  from: string;
+  emoji: string[];
+  data: Record<string, string>;
+  roomJID: string;
+  /** Server stanza id (microsecond timestamp) — orders reactions. */
+  ts?: string;
+}
+
+export const extractReaction = (
+  msg: any,
+  fallbackRoomJID?: string,
+  archiveId?: string
+): ExtractedReaction | null => {
+  const reactionsEl = msg?.getChild?.('reactions');
+  if (!reactionsEl) {return null;}
+  const messageId = reactionsEl.attrs?.id;
+  const from = String(reactionsEl.attrs?.from || '');
+  if (!messageId || !from.split('@')[0]) {return null;}
+  const emoji: string[] = (reactionsEl.getChildren?.('reaction') || [])
+    .map((reaction: any) => (reaction.text ? reaction.text() : ''))
+    .filter(Boolean);
+  const data = (msg.getChild?.('data')?.attrs || {}) as Record<string, string>;
+  const stanzaId = msg.getChild?.('stanza-id');
+  const roomJID = String(
+    stanzaId?.attrs?.by || fallbackRoomJID || msg.attrs?.from || ''
+  ).split('/')[0];
+  const rawTs = String(archiveId || stanzaId?.attrs?.id || '');
+  const ts = /^\d+$/.test(rawTs) ? rawTs : undefined;
+  return { messageId, from, emoji, data, roomJID, ...(ts ? { ts } : {}) };
+};
+
+export const applyMamReactions = (
+  messages: IMessage[],
+  reactions: ExtractedReaction[]
+): ExtractedReaction[] => {
+  const byId = new Map<string, IMessage>();
+  for (const message of messages) {
+    if (message?.id) {byId.set(String(message.id), message);}
+  }
+  const deferred: ExtractedReaction[] = [];
+  // Oldest first, so the newest state of each reactor wins.
+  const ordered = reactions
+    .slice()
+    .sort((a, b) => (a.ts && b.ts ? compareStanzaIds(a.ts, b.ts) : 0));
+  for (const reaction of ordered) {
+    const target = byId.get(String(reaction.messageId));
+    if (target) {
+      applyReactionToMessage(target, reaction.from, reaction.emoji, reaction.data, reaction.ts);
+    } else {
+      deferred.push(reaction);
+    }
+  }
+  return deferred;
+};

package/src/helpers/parseMessageReference.ts

@@ -0,0 +1,38 @@
+/** The parent a reply points at, read from its `mainMessage` JSON. */
+export interface MessageReference {
+  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.
+ */
+export const parseMessageReference = (message: {
+  mainMessage?: string;
+} | null | undefined): MessageReference | null => {
+  if (!message?.mainMessage) {return null;}
+  const cached = cache.get(message);
+  if (cached !== undefined) {return cached;}
+  let ref: MessageReference | null = null;
+  try {
+    const parsed = JSON.parse(message.mainMessage);
+    if (parsed && parsed.id != null) {
+      ref = {
+        id: String(parsed.id),
+        text: typeof parsed.text === 'string' ? parsed.text : '',
+        roomJid: typeof parsed.roomJid === 'string' ? parsed.roomJid : '',
+        userName: typeof parsed.userName === 'string' ? parsed.userName : undefined,
+      };
+    }
+  } catch {
+    ref = null;
+  }
+  cache.set(message, ref);
+  return ref;
+};

package/src/helpers/persistCrypto.ts

@@ -69,6 +69,11 @@ const loadOrCreateKey = (): Promise<CryptoJS.lib.WordArray> => {
   return cachedKeyPromise;
 };
 
+export async function isPersistKeyKept(): Promise<boolean> {
+  const key = await loadOrCreateKey();
+  return (await secureGet(CIPHER_KEY_STORE_KEY)) === CryptoJS.enc.Base64.stringify(key);
+}
+
 /** Encrypt a JSON-serialisable payload for storage. Returns the string to persist. */
 export async function encryptForPersist(plaintext: string): Promise<string> {
   const key = await loadOrCreateKey();

package/src/helpers/reactionsConfig.ts

@@ -0,0 +1,13 @@
+import { IConfig } from '../types/types';
+import { DEFAULT_QUICK_REACTIONS } from './emoji';
+
+export const reactionsEnabled = (config?: IConfig | null): boolean =>
+  !config?.disableReactions && config?.reactions?.enabled !== false;
+
+export const quickReactionIds = (config?: IConfig | null): string[] => {
+  const ids = config?.reactions?.quickReactions;
+  return Array.isArray(ids) && ids.length ? ids.slice(0, 8) : DEFAULT_QUICK_REACTIONS;
+};
+
+export const reactionPickerEnabled = (config?: IConfig | null): boolean =>
+  reactionsEnabled(config) && config?.reactions?.picker !== false;

package/src/helpers/secureKeyValue.ts

@@ -74,6 +74,21 @@ export async function secureRemove(key: string): Promise<void> {
   await AsyncStorage.removeItem(FALLBACK_PREFIX + key).catch(() => undefined);
 }
 
+export async function secureGetOrCreate(
+  key: string,
+  create: () => string
+): Promise<{ value: string; created: boolean } | null> {
+  const existing = await secureGet(key);
+  if (existing) {return { value: existing, created: false };}
+  const value = create();
+  await secureSet(key, value);
+  if ((await secureGet(key)) !== value) {
+    pushLog('warn', `secureStore: ${key} was not kept`);
+    return null;
+  }
+  return { value, created: true };
+}
+
 /** Test seam only. */
 export const __resetSecureKeyValueWarningForTests = (): void => {
   warnedFallback = false;

package/src/helpers/updateMessagesTillLast.tsx

@@ -31,10 +31,20 @@ export const updateMessagesTillLast = async (
         processedIndex + batchSize
       );
 
+
       const lastTimestampsByJid = currentBatch.reduce(
         (acc: Record<string, number>, current: string) => {
           const room = (store.getState() as any).rooms?.rooms?.[current];
-          acc[current] = Number(room?.lastMessageTimestamp ?? 0) || 0;
+          const cached: IMessage[] = Array.isArray(room?.messages)
+            ? room.messages
+            : [];
+          let newest = 0;
+          for (const m of cached) {
+            if (!m || m.pending || m.id === 'delimiter-new') {continue;}
+            const id = Number(m.id);
+            if (Number.isFinite(id) && id > newest) {newest = id;}
+          }
+          acc[current] = newest;
           return acc;
         },
         {} as Record<string, number>
@@ -59,7 +69,9 @@ export const updateMessagesTillLast = async (
               const fetchedMessages = await client.getHistoryStanza(
                 jid,
                 messagesPerFetch,
-                Number(lastMessageId)
+                Number(lastMessageId),
+                undefined,
+                { coalesceRoom: true, source: 'background', selfApplied: true }
               );
 
               if (!fetchedMessages.length) {break;}

package/src/helpers/videoCache.ts

@@ -0,0 +1,138 @@
+import * as FileSystem from 'expo-file-system/legacy';
+import { filenameFromUrl, getExtensionForMime } from './mimeToExtension';
+
+// Containers the native players open from a local file by extension.
+const VIDEO_EXT_RE = /\.(mp4|mov|m4v|webm|3gp|mkv|mpeg)$/i;
+
+const hashString = (value: string) => {
+  let hash = 5381;
+  for (let i = 0; i < value.length; i++) {
+    hash = (hash * 33) ^ value.charCodeAt(i);
+  }
+  return (hash >>> 0).toString(36);
+};
+
+export const isRemoteUrl = (url?: string | null): boolean =>
+  /^https?:\/\//i.test(url || '');
+
+const hostOf = (url: string): string =>
+  (/^https?:\/\/(?:[^@/]+@)?([^:/?#]+)/i.exec(url)?.[1] || '').toLowerCase();
+
+// The query carries the short-lived file token; the file is the same.
+const withoutQuery = (url: string): string => url.split('#')[0]!.split('?')[0]!;
+
+/**
+ * Where a remote video is kept once downloaded. The extension matters:
+ * AVFoundation picks the demuxer of a local file by it.
+ */
+export const getVideoCacheUri = (
+  url: string,
+  mimetype: string | undefined | null,
+  cacheDirectory: string
+): string => {
+  const fromUrl = VIDEO_EXT_RE.exec(filenameFromUrl(url))?.[0];
+  const fromMime = getExtensionForMime(mimetype);
+  const ext = (
+    fromUrl || (VIDEO_EXT_RE.test(fromMime) ? fromMime : '.mp4')
+  ).toLowerCase();
+  return `${cacheDirectory}ethora-video-${hashString(withoutQuery(url))}${ext}`;
+};
+
+/**
+ * Hosts that answered a streaming attempt with an error. AVPlayer refuses a
+ * server that replies 200 to a byte-range request ("server is not correctly
+ * configured"), so for those the next video skips the doomed stream and
+ * downloads straight away.
+ */
+const hostsWithoutStreaming = new Set<string>();
+
+export const markStreamingUnsupported = (url: string): void => {
+  const host = hostOf(url);
+  if (host) {hostsWithoutStreaming.add(host);}
+};
+
+export const isStreamingUnsupported = (url: string): boolean =>
+  hostsWithoutStreaming.has(hostOf(url));
+
+export const findCachedVideo = async (
+  url: string,
+  mimetype?: string | null
+): Promise<string | null> => {
+  const cacheDirectory = FileSystem.cacheDirectory;
+  if (!cacheDirectory || !isRemoteUrl(url)) {return null;}
+  try {
+    const uri = getVideoCacheUri(url, mimetype, cacheDirectory);
+    const info = await FileSystem.getInfoAsync(uri);
+    return info.exists ? uri : null;
+  } catch {
+    return null;
+  }
+};
+
+type ProgressListener = (fraction: number) => void;
+
+const inFlight = new Map<
+  string,
+  { promise: Promise<string>; listeners: Set<ProgressListener> }
+>();
+
+/**
+ * Downloads the video next to the app's other caches and resolves with the
+ * local uri. One download per file however many callers ask; `onProgress`
+ * gets 0..1 when the server reports a length.
+ */
+export const downloadVideoToCache = (
+  url: string,
+  mimetype?: string | null,
+  onProgress?: ProgressListener
+): Promise<string> => {
+  const cacheDirectory = FileSystem.cacheDirectory;
+  if (!cacheDirectory) {
+    return Promise.reject(new Error('video_cache_unavailable'));
+  }
+  const finalUri = getVideoCacheUri(url, mimetype, cacheDirectory);
+
+  const running = inFlight.get(finalUri);
+  if (running) {
+    if (onProgress) {running.listeners.add(onProgress);}
+    return running.promise;
+  }
+
+  const listeners = new Set<ProgressListener>();
+  if (onProgress) {listeners.add(onProgress);}
+
+  const run = async (): Promise<string> => {
+    // Download under another name: an interrupted download must not be
+    // mistaken for the cached file next time.
+    const part = `${finalUri}.part`;
+    await FileSystem.deleteAsync(part, { idempotent: true }).catch(() => {});
+    const task = FileSystem.createDownloadResumable(url, part, {}, (p) => {
+      if (p.totalBytesExpectedToWrite > 0) {
+        const fraction = Math.min(
+          1,
+          p.totalBytesWritten / p.totalBytesExpectedToWrite
+        );
+        listeners.forEach((listener) => listener(fraction));
+      }
+    });
+    const result = await task.downloadAsync();
+    if (!result || result.status < 200 || result.status >= 300) {
+      await FileSystem.deleteAsync(part, { idempotent: true }).catch(() => {});
+      throw new Error(`video_download_status_${result?.status ?? 'cancelled'}`);
+    }
+    await FileSystem.deleteAsync(finalUri, { idempotent: true }).catch(() => {});
+    await FileSystem.moveAsync({ from: part, to: finalUri });
+    return finalUri;
+  };
+
+  const promise = run().finally(() => {
+    inFlight.delete(finalUri);
+  });
+  inFlight.set(finalUri, { promise, listeners });
+  return promise;
+};
+
+export const __resetVideoCacheForTests = (): void => {
+  hostsWithoutStreaming.clear();
+  inFlight.clear();
+};

package/src/hooks/useHeapSender.tsx

@@ -50,8 +50,9 @@ export const useHeapSender = (client: XmppClient | null) => {
               msg.user.walletAddress || '',
               msg.body,
               '',
-              !!msg.isReply,
-              !!msg.showInChannel,
+              // Wire values are strings: '"false"' is truthy.
+              String(msg.isReply) === 'true',
+              String(msg.showInChannel) === 'true',
               msg.mainMessage,
               msg.id
             );

package/src/hooks/useLogout.tsx

@@ -12,6 +12,7 @@ import { clearRoomsRestCache } from '../networking/api-requests/rooms.api';
 import { clearPersistedState } from '../roomStore/persistence';
 import { secureUserStorage } from '../helpers/secureUserStorage';
 import { getFlushBoundaryTs } from '../helpers/getServerReadTimestamp';
+import { stopOmemo } from '../e2ee';
 
 // AsyncStorage keys the library writes but that aren't cleared by any
 // slice reducer. Listed here so a single logout call wipes the full
@@ -109,6 +110,14 @@ const logoutService = {
       console.warn('logoutService: push reset failed', e);
     }
 
+    stopOmemo();
+    try {
+      const { clearOpenedFiles } =
+        require('../e2ee/sealedFiles') as typeof import('../e2ee/sealedFiles');
+      clearOpenedFiles();
+    } catch {
+    }
+
     // 3. REST: nuke the in-memory `/chats/my` cache so the next login
     //    doesn't read user A's rooms while user B is bootstrapping.
     try {

package/src/hooks/useMessageHeapState.tsx

@@ -1,3 +1,4 @@
+import { useMemo } from 'react';
 import { useSelector } from 'react-redux';
 import { RootState } from '../roomStore';
 
@@ -8,8 +9,11 @@ export const useMessageHeapState = () => {
   const failedMessages = useSelector(
     (state: RootState) => state.roomHeapSlice?.failedMessages
   );
-  const idSet = new Set(queue?.map((m) => m.id) ?? []);
-  const failedIdSet = new Set(Object.keys(failedMessages || {}));
+  const idSet = useMemo(() => new Set(queue?.map((m) => m.id) ?? []), [queue]);
+  const failedIdSet = useMemo(
+    () => new Set(Object.keys(failedMessages || {})),
+    [failedMessages]
+  );
 
   return { queue, idSet, failedMessages, failedIdSet };
 };

package/src/hooks/useRoomInitialization.tsx

@@ -2,8 +2,9 @@ import { useEffect } from 'react';
 import { setIsLoading } from '../roomStore/roomsSlice';
 import { useXmppClient } from '../context/xmppProvider';
 import { IConfig, IMessage, IRoom } from '../types/types';
-import { useDispatch } from 'react-redux';
+import { useDispatch, useSelector, useStore } from 'react-redux';
 import useGetNewArchRoom from './useGetNewArchRoom';
+import type { RootState } from '../roomStore';
 
 const countUndefinedText = (arr: IMessage[]) =>
   (Array.isArray(arr) ? arr : []).filter(
@@ -21,14 +22,32 @@ const hasLoadedRoomHistory = (room?: IRoom): boolean => {
   );
 };
 
+const defaultRoomJids = (config: IConfig): string[] =>
+  (config?.defaultRooms || []).map((room: any) =>
+    typeof room === 'string' ? room : room?.jid
+  );
+
 export const useRoomInitialization = (
   activeRoomJID: string,
-  roomsList: Record<string, IRoom>,
-  config: IConfig,
-  messageLength: number
+  config: IConfig
 ) => {
   const { client } = useXmppClient();
   const dispatch = useDispatch();
+  const reduxStore = useStore<RootState>();
+
+  const hasRooms = useSelector(
+    (state: RootState) => Object.keys(state.rooms.rooms || {}).length > 0
+  );
+  const activeRoomExists = useSelector(
+    (state: RootState) => !!activeRoomJID && !!state.rooms.rooms?.[activeRoomJID]
+  );
+  const activeHistoryLoaded = useSelector((state: RootState) =>
+    hasLoadedRoomHistory(state.rooms.rooms?.[activeRoomJID])
+  );
+  const defaultRoomsMissing = useSelector((state: RootState) => {
+    const jids = defaultRoomJids(config);
+    return jids.length > 0 && jids.some((jid) => !state.rooms.rooms?.[jid]);
+  });
 
   const syncRooms = useGetNewArchRoom();
 
@@ -59,9 +78,8 @@ export const useRoomInitialization = (
   }, [client, activeRoomJID]);
 
   useEffect(() => {
-    const activeRoom = roomsList?.[activeRoomJID];
-    const shouldLoadActiveHistory =
-      !!activeRoomJID && !hasLoadedRoomHistory(activeRoom);
+    const roomsList = reduxStore.getState().rooms.rooms || {};
+    const shouldLoadActiveHistory = !!activeRoomJID && !activeHistoryLoaded;
 
     const getDefaultHistory = async () => {
       if (!client || !activeRoomJID) {return;}
@@ -129,7 +147,7 @@ export const useRoomInitialization = (
         // real, non-pending message in the room counts as "loaded").
         dispatch(setIsLoading({ loading: true, chatJID: activeRoomJID }));
         getDefaultHistory();
-      } else {
+      } else if (roomsList?.[activeRoomJID]?.isLoading) {
         dispatch(setIsLoading({ loading: false, chatJID: activeRoomJID }));
       }
     } else if (!roomsList?.[activeRoomJID]) {
@@ -137,10 +155,7 @@ export const useRoomInitialization = (
     }
 
     if (client && config?.defaultRooms) {
-      const allExist = config?.defaultRooms.every(
-        (room) => roomsList[typeof room === 'string' ? room : room.jid] !== undefined
-      );
-      if (roomsList && !allExist) {
+      if (defaultRoomsMissing) {
         config?.defaultRooms.map(async (room) => {
           client.presenceInRoomStanza(typeof room === 'string' ? room : room.jid);
         });
@@ -151,10 +166,12 @@ export const useRoomInitialization = (
         }
       }
     }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [
     activeRoomJID,
-    Object.keys(roomsList).length,
-    messageLength,
-    roomsList?.[activeRoomJID]?.messages?.length,
+    hasRooms,
+    activeRoomExists,
+    activeHistoryLoaded,
+    defaultRoomsMissing,
   ]);
 };