@ethora/chat-component-rn 26.8.4 → 26.8.6

package/src/networking/stanzaHandlers.ts

@@ -1,15 +1,22 @@
 import { Element } from 'ltx';
 import { store } from '../roomStore';
 import {
-  addRoom,
+  claimMamResult,
+  collectMamMessage,
+  collectMamReaction,
+} from './xmpp/mamRouter';
+import { extractReaction } from '../helpers/mamReactions';
+import {
+  addRooms,
   addRoomMessage,
   deleteRoomMessage,
   editRoomMessage,
   setComposing,
   setCurrentRoom,
   setRoomRole,
+  setReactions,
 } from '../roomStore/roomsSlice';
-import { IRoom } from '../types/types';
+import { IMessage, IRoom } from '../types/types';
 import { createMessageFromXml } from '../helpers/createMessageFromXml';
 import { getDataFromXml } from '../helpers/getDataFromXml';
 import { setDeleteModal } from '../roomStore/chatSettingsSlice';
@@ -33,7 +40,8 @@ const onRealtimeMessage = async (stanza: Element) => {
     !stanza.getChild('paused') &&
     !stanza.getChild('subject') &&
     !stanza.is('iq') &&
-    stanza.attrs.id !== 'deleteMessageStanza'
+    stanza.attrs.id !== 'deleteMessageStanza' &&
+    !stanza.getChild('reactions')
   ) {
     const body = stanza?.getChild('body');
     const archived = stanza?.getChild('archived');
@@ -47,8 +55,6 @@ const onRealtimeMessage = async (stanza: Element) => {
       ?.getChild('deleted');
 
     if (!data) {
-      console.log(stanza.toString());
-      console.log('Missing data elements in real-time message.');
       return;
     }
 
@@ -66,8 +72,6 @@ const onRealtimeMessage = async (stanza: Element) => {
     // to the same tolerance.
     const senderJID = data.attrs.senderJID || stanza.attrs.from;
     if (!senderJID) {
-      console.log(stanza.toString());
-      console.log('Missing sender information in real-time message.');
       return;
     }
 
@@ -189,11 +193,36 @@ const onEditMessage = async (stanza: Element) => {
   }
 };
 
-const onMessageHistory = async (stanza: any) => {
-  if (
-    stanza.is('message') &&
-    stanza.children[0].attrs.xmlns === 'urn:xmpp:mam:2'
-  ) {
+const isMamResult = (stanza: any): boolean =>
+  !!stanza?.is?.('message') &&
+  stanza.children?.[0]?.attrs?.xmlns === 'urn:xmpp:mam:2';
+
+const parseMamResult = async (stanza: any): Promise<IMessage | undefined> => {
+  {
+    const forwardedMsg = stanza
+      .getChild('result')
+      ?.getChild('forwarded')
+      ?.getChild('message');
+    if (forwardedMsg?.getChild?.('reactions')) {
+      const reaction = extractReaction(
+        forwardedMsg,
+        stanza.attrs?.from,
+        stanza.getChild('result')?.attrs?.id
+      );
+      if (reaction && !collectMamReaction(stanza, reaction)) {
+        store.dispatch(
+          setReactions({
+            roomJID: reaction.roomJID,
+            messageId: reaction.messageId,
+            from: reaction.from,
+            reactions: reaction.emoji,
+            data: reaction.data,
+            latestReactionTimestamp: reaction.ts,
+          })
+        );
+      }
+      return undefined;
+    }
     // console.log("stanza -->", stanza.toString());
     const body = stanza
       .getChild('result')
@@ -218,11 +247,9 @@ const onMessageHistory = async (stanza: any) => {
     const id = stanza.getChild('result')?.attrs.id;
     if (!delay) {
       if (stanza.getChild('subject')) {
-        console.log('Subject.');
         return;
       }
       if (!data || !body || !id) {
-        console.log('Missing required elements in message history.');
         return;
       }
     }
@@ -295,6 +322,22 @@ const onMessageHistory = async (stanza: any) => {
       rawMessage,
       store.getState().chatSettingStore.user?.xmppUsername || ''
     );
+    return message;
+  }
+};
+
+const onMessageHistory = async (stanza: any) => {
+  if (!isMamResult(stanza)) {return;}
+  const claimed = claimMamResult(stanza);
+  let message: IMessage | undefined;
+  try {
+    message = await parseMamResult(stanza);
+  } finally {
+    if (claimed) {
+      collectMamMessage(stanza, message);
+    }
+  }
+  if (!claimed && message) {
     store.dispatch(
       addRoomMessage({
         roomJID: stanza.attrs.from,
@@ -360,7 +403,9 @@ const onPresenceInRoom = (stanza: Element | any) => {
   ) {
     const roomJID: string = stanza.attrs.from.split('/')[0];
     const role: string = stanza?.children[1]?.children[0]?.attrs.role;
-    store.dispatch(setRoomRole({ chatJID: roomJID, role: role }));
+    if (role && store.getState().rooms.rooms?.[roomJID]?.role !== role) {
+      store.dispatch(setRoomRole({ chatJID: roomJID, role: role }));
+    }
   }
 };
 
@@ -423,53 +468,47 @@ const onGetChatRooms = (stanza: Element, xmpp: any) => {
     Array.isArray(stanza.getChild('query')?.children)
   ) {
     const children = stanza.getChild('query')?.children || [];
-    children.forEach(async (result: any) => {
-      const currentChatRooms = store.getState().rooms.rooms;
-
-      const isRoomAlreadyAdded = Object.values(currentChatRooms).some(
-        (element) => element.jid === result?.attrs?.jid
-      );
-
+    const known = store.getState().rooms.rooms;
+    const fresh: IRoom[] = [];
+    const jids: string[] = [];
+    for (const result of children as any[]) {
       const jid = result?.attrs?.jid;
-
-      if (!isRoomAlreadyAdded) {
-        try {
-          const roomData: IRoom = {
-            jid: jid || '',
-            name: result?.attrs?.name || '',
-            id: '',
-            title: result?.attrs?.name || '',
-            usersCnt: Number(result?.attrs?.users_cnt || 0),
-            messages: [],
-            isLoading: false,
-            roomBg:
-              result?.attrs?.room_background !== 'none'
-                ? result?.attrs?.room_background
-                : null,
-            icon:
-              result?.attrs?.room_thumbnail !== 'none'
-                ? result?.attrs?.room_thumbnail
-                : null,
-            unreadMessages: 0,
-            lastViewedTimestamp: 0,
-          };
-
-          store.dispatch(addRoom({ roomData: { ...roomData } }));
-
-          if (!store.getState().rooms.activeRoomJID) {
-            store.dispatch(setCurrentRoom({ roomJID: roomData.jid }));
-          }
-        } catch (error) {}
+      if (!jid) {continue;}
+      jids.push(jid);
+      if (known[jid]) {continue;}
+      fresh.push({
+        jid,
+        name: result?.attrs?.name || '',
+        id: '',
+        title: result?.attrs?.name || '',
+        usersCnt: Number(result?.attrs?.users_cnt || 0),
+        messages: [],
+        isLoading: false,
+        roomBg:
+          result?.attrs?.room_background !== 'none'
+            ? result?.attrs?.room_background
+            : null,
+        icon:
+          result?.attrs?.room_thumbnail !== 'none'
+            ? result?.attrs?.room_thumbnail
+            : null,
+        unreadMessages: 0,
+        lastViewedTimestamp: 0,
+      });
+    }
+    if (fresh.length) {
+      store.dispatch(addRooms({ rooms: fresh }));
+      if (!store.getState().rooms.activeRoomJID) {
+        store.dispatch(setCurrentRoom({ roomJID: fresh[0].jid }));
       }
-
-      if (jid) {
-        try {
-          xmpp.presenceInRoomStanza(jid);
-        } catch (e) {
-          console.warn('presenceInRoomStanza failed', jid, e);
-        }
+    }
+    for (const jid of jids) {
+      try {
+        xmpp.presenceInRoomStanza(jid);
+      } catch (e) {
+        console.warn('presenceInRoomStanza failed', jid, e);
       }
-    });
+    }
   }
 };
 
@@ -477,7 +516,24 @@ const onGetChatRooms = (stanza: Element, xmpp: any) => {
 // RN side hasn't ported yet. Without these the bundle compiles but
 // require() returns undefined at runtime → "X is not a function".
 const onMessageError = (_stanza: Element, _xmpp?: any) => {};
-const onReactionMessage = (_stanza: Element) => {};
+/** A live reaction: the reactor's full current list on one message. */
+const onReactionMessage = (stanza: Element) => {
+  if (!stanza?.is?.('message') || stanza.getChild('result')) {return;}
+  if (!stanza.getChild('reactions')) {return;}
+  const reaction = extractReaction(stanza, stanza.attrs?.from);
+  if (!reaction) {return;}
+  store.dispatch(
+    setReactions({
+      roomJID: reaction.roomJID,
+      messageId: reaction.messageId,
+      latestReactionTimestamp: reaction.ts,
+      reactions: reaction.emoji,
+      from: reaction.from,
+      data: reaction.data,
+    })
+  );
+};
+// Archived reactions are handled by parseMamResult + the MAM router.
 const onReactionHistory = (_stanza: Element) => {};
 const onRoomKicked = (_stanza: Element) => {};
 

package/src/networking/xmpp/getHistory.xmpp.ts

@@ -1,16 +1,19 @@
 import { Client, xml } from '@xmpp/client';
 import { createTimeoutPromise } from './createTimeoutPromise.xmpp';
-import { Element } from 'ltx';
 import { IMessage } from '../../types/types';
-import { getDataFromXml } from '../../helpers/getDataFromXml';
-import { createMessageFromXml } from '../../helpers/createMessageFromXml';
+import { beginMamQuery, cancelMamQuery } from './mamRouter';
+
+declare const __DEV__: boolean | undefined;
+
+let historyIdCounter = 0;
 
 export const getHistory = async (
   client: Client,
   chatJID: string,
   max: number,
   before?: number,
-  otherId?: string
+  otherId?: string,
+  options?: { selfApplied?: boolean }
 ): Promise<IMessage[] | undefined> => {
   if (typeof chatJID !== 'string') {return;}
   // If a caller passes a bare local-part (no `@host`), pick a default
@@ -25,121 +28,56 @@ export const getHistory = async (
         return `${chatJID}@conference.${host}`;
       })();
 
-  const id = otherId ?? `get-history:${Date.now().toString()}`;
-
-  let stanzaHdlrPointer: {
-    (el: Element): void;
-    (stanza: any): void;
-  };
-
-  const unsubscribe = () => {
-    client.off('stanza', stanzaHdlrPointer);
-  };
-
-  const responsePromise = new Promise((resolve, reject) => {
-    let messages: Element[] = [];
-
-    stanzaHdlrPointer = async (stanza) => {
-      const result = stanza.getChild('result');
-
-      if (
-        stanza.is('message') &&
-        stanza.attrs.from &&
-        stanza.attrs.from.startsWith(fixedChatJid) &&
-        result
-      ) {
-        const messageEl = result.getChild('forwarded')?.getChild('message');
-
-        messages.push(messageEl);
-      }
-
-      if (
-        stanza.is('iq') &&
-        stanza.attrs.id === id &&
-        stanza.attrs.type === 'result'
-      ) {
-        let mainMessages: IMessage[] = [];
 
-        for (const msg of messages) {
-          const reactions = msg?.getChild('reactions');
-          const text = msg.getChild('body')?.getText();
+  const id = otherId ?? `get-history:${Date.now().toString(36)}-${(++historyIdCounter).toString(36)}`;
 
-          if (text || reactions) {
-            const result = await getDataFromXml(msg);
-            if (!result) {
-              return;
-            }
-            const { data, id, body, ...rest } = result;
+  const page = beginMamQuery(id, fixedChatJid, !options?.selfApplied);
 
-            if (!data) {
-              console.log('No data in stanza');
-              return;
-            }
-
-            const message = await createMessageFromXml({
-              data,
-              id,
-              body: body || '',
-              ...rest,
-            } as any);
-
-            mainMessages.push(message);
-          }
-        }
-        resolve(mainMessages);
-      }
-
-      if (
-        stanza.is('iq') &&
-        stanza.attrs.id === id &&
-        stanza.attrs.type === 'error'
-      ) {
-        reject();
-      }
-    };
-
-    client?.on('stanza', stanzaHdlrPointer);
-
-    const message = xml(
-      'iq',
-      {
-        type: 'set',
-        to: fixedChatJid,
-        id: id,
-      },
+  const message = xml(
+    'iq',
+    {
+      type: 'set',
+      to: fixedChatJid,
+      id: id,
+    },
+    xml(
+      'query',
+      { xmlns: 'urn:xmpp:mam:2', queryid: id },
       xml(
-        'query',
-        { xmlns: 'urn:xmpp:mam:2' },
-        xml(
-          'set',
-          { xmlns: 'http://jabber.org/protocol/rsm' },
-          xml('max', {}, max.toString()),
-          before ? xml('before', {}, before.toString()) : xml('before')
-        )
+        'set',
+        { xmlns: 'http://jabber.org/protocol/rsm' },
+        xml('max', {}, max.toString()),
+        before ? xml('before', {}, before.toString()) : xml('before')
       )
-    );
+    )
+  );
 
-    client?.send(message).catch((err: any) => console.log('err on load', err));
-  });
+  client?.send(message).catch((err: any) => console.log('err on load', err));
 
   const timeoutPromise = createTimeoutPromise(10000);
 
   try {
-    // @ts-ignore
-    const res: IMessage[] | null = await Promise.race<[IMessage[] | null]>([
-      responsePromise as Promise<IMessage[] | null>,
+    const res = await Promise.race<IMessage[] | null>([
+      page,
       timeoutPromise as Promise<null>,
     ]);
-    return res === null ? [] : res;
+    if (res === null) {
+      const partial = cancelMamQuery(id);
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.log(
+          `[mam] history request for ${fixedChatJid} timed out after 10s (${partial.length} results arrived)`
+        );
+      }
+      return partial;
+    }
+    return res;
   } catch (e) {
-    // MAM rejects with no value when an iq error returns; the timeout
-    // path resolves with null instead of throwing. Either is expected
-    // for a room with no history yet — only log if `e` is meaningful.
-    if (e !== undefined) {
-      console.log('=-> error in', fixedChatJid, e);
+    const partial = cancelMamQuery(id);
+    if (typeof __DEV__ !== 'undefined' && __DEV__ && e === undefined) {
+      console.log(
+        `[mam] history request for ${fixedChatJid} got no closing iq within 10s (${partial.length} results arrived)`
+      );
     }
-    return [];
-  } finally {
-    unsubscribe();
+    return partial;
   }
 };

package/src/networking/xmpp/handleStanzas.xmpp.ts

@@ -1,4 +1,5 @@
 import { Element } from 'ltx';
+import { routeMamIq } from './mamRouter';
 import {
   onDeleteMessage,
   onEditMessage,
@@ -80,6 +81,7 @@ export function handleStanza(stanza: Element, xmppWs: XmppClient) {
       onPresenceInRoom(stanza);
       break;
     case 'iq':
+      if (routeMamIq(stanza)) {break;}
       onGetChatRooms(stanza, xmppWs);
       onRealtimeMessage(stanza);
       onPresenceInRoom(stanza);

package/src/networking/xmpp/mamRouter.ts

@@ -0,0 +1,176 @@
+import { store } from '../../roomStore';
+import { addRoomMessages, setReactions } from '../../roomStore/roomsSlice';
+import { IMessage } from '../../types/types';
+import { applyMamReactions, type ExtractedReaction } from '../../helpers/mamReactions';
+
+interface PendingQuery {
+  roomJID: string;
+  apply: boolean;
+  messages: IMessage[];
+  reactions: ExtractedReaction[];
+  inflight: number;
+  closed: null | { error: boolean };
+  resolve: (messages: IMessage[]) => void;
+  reject: (error: Error) => void;
+}
+
+const pending = new Map<string, PendingQuery>();
+
+const flush = (query: PendingQuery) => {
+  // Every step is guarded: a failure in one (a middleware throwing on a
+  // reaction, say) used to escape `settle` before the waiting request was
+  // resolved — the page was lost and the room stayed empty until opened.
+  let deferred: ExtractedReaction[] = [];
+  try {
+    // Reactions ride in the archive as their own entries: fold them onto
+    // the page's messages first, so they are stored together.
+    deferred = applyMamReactions(query.messages, query.reactions);
+  } catch (e) {
+    console.warn('[mam] applying reactions to a page failed', e);
+  }
+  if (query.apply && query.messages.length > 0) {
+    try {
+      store.dispatch(
+        addRoomMessages({ roomJID: query.roomJID, messages: query.messages })
+      );
+    } catch (e) {
+      console.warn('[mam] applying a history page failed', e);
+    }
+  }
+  for (const reaction of deferred) {
+    try {
+      store.dispatch(
+        setReactions({
+          roomJID: reaction.roomJID || query.roomJID,
+          messageId: reaction.messageId,
+          from: reaction.from,
+          reactions: reaction.emoji,
+          data: reaction.data,
+          latestReactionTimestamp: reaction.ts,
+        })
+      );
+    } catch (e) {
+      console.warn('[mam] applying a reaction failed', e);
+    }
+  }
+};
+
+export const beginMamQuery = (
+  queryId: string,
+  roomJID: string,
+  apply = true
+): Promise<IMessage[]> =>
+  new Promise((resolve, reject) => {
+    pending.set(queryId, {
+      roomJID,
+      apply,
+      messages: [],
+      reactions: [],
+      inflight: 0,
+      closed: null,
+      resolve,
+      reject,
+    });
+  });
+
+/**
+ * Give up waiting (timeout). Whatever arrived is still applied — a late
+ * page is better than a lost one — and handed back.
+ */
+export const cancelMamQuery = (queryId: string): IMessage[] => {
+  const query = pending.get(queryId);
+  if (!query) {return [];}
+  pending.delete(queryId);
+  flush(query);
+  query.resolve(query.messages);
+  return query.messages;
+};
+
+const bareLower = (jid: unknown): string =>
+  String(jid || '').split('/')[0].toLowerCase();
+
+// By the echoed `queryid` when the server provides one; otherwise by the
+// room the result came from — the oldest still-open query for that room.
+// (Results are per room anyway: a query only ever asks one archive.)
+const queryOf = (stanza: any): PendingQuery | undefined => {
+  const queryId = stanza?.getChild?.('result')?.attrs?.queryid;
+  const byId = queryId ? pending.get(queryId) : undefined;
+  if (byId) {return byId;}
+  const room = bareLower(stanza?.attrs?.from);
+  if (!room) {return undefined;}
+  for (const query of pending.values()) {
+    if (!query.closed && bareLower(query.roomJID) === room) {return query;}
+  }
+  return undefined;
+};
+
+const settle = (queryId: string, query: PendingQuery) => {
+  if (pending.get(queryId) === query) {pending.delete(queryId);}
+  try {
+    flush(query);
+  } finally {
+    // The waiting request is always answered, whatever happened above.
+    if (query.closed?.error) {
+      query.reject(new Error('mam query error'));
+    } else {
+      query.resolve(query.messages);
+    }
+  }
+};
+
+const settleIfDone = (query: PendingQuery) => {
+  if (!query.closed || query.inflight > 0) {return;}
+  const entry = [...pending.entries()].find(([, q]) => q === query);
+  settle(entry ? entry[0] : '', query);
+};
+
+/**
+ * Claim a result for its pending query — synchronously, the moment the
+ * stanza arrives — so the router knows a parse is outstanding. Returns
+ * true when a pending query owns it (the caller must then always follow
+ * up with `collectMamMessage`, even when the parse yields nothing).
+ */
+export const claimMamResult = (stanza: any): boolean => {
+  const query = queryOf(stanza);
+  if (!query) {return false;}
+  query.inflight += 1;
+  return true;
+};
+
+/** The parsed result of a claimed stanza (undefined: dropped). */
+export const collectMamReaction = (
+  stanza: any,
+  reaction: ExtractedReaction
+): boolean => {
+  const query = queryOf(stanza);
+  if (!query) {return false;}
+  query.reactions.push(reaction);
+  return true;
+};
+
+export const collectMamMessage = (
+  stanza: any,
+  message: IMessage | undefined
+): boolean => {
+  const query = queryOf(stanza);
+  if (!query) {return false;}
+  if (message) {query.messages.push(message);}
+  query.inflight = Math.max(0, query.inflight - 1);
+  settleIfDone(query);
+  return true;
+};
+
+/** The query's closing iq; true when it belonged to a pending query. */
+export const routeMamIq = (stanza: any): boolean => {
+  if (!stanza?.is?.('iq')) {return false;}
+  const query = pending.get(stanza.attrs?.id);
+  if (!query) {return false;}
+  query.closed = { error: stanza.attrs.type === 'error' };
+  // Results that are still being parsed settle the page when they land;
+  // until then the query stays registered so they can find it.
+  if (query.inflight === 0) {settle(stanza.attrs.id, query);}
+  return true;
+};
+
+/** Test hook. */
+export const __resetMamRouter = () => pending.clear();