@ethora/chat-component-rn 26.4.1

package/src/networking/xmpp/createRoomPresence.xmpp.ts

@@ -0,0 +1,74 @@
+import { Element } from 'ltx';
+import { Client, xml } from '@xmpp/client';
+import { createTimeoutPromise } from './createTimeoutPromise.xmpp';
+
+export function createRoomPresence(roomId: string, client: Client) {
+  let stanzaHdlrPointer: {
+    (el: Element): void;
+    (stanza: Element): void;
+    (el: Element): void;
+  };
+
+  const unsubscribe = () => {
+    client.off('stanza', stanzaHdlrPointer);
+  };
+
+  const responsePromise = new Promise((resolve, reject) => {
+    stanzaHdlrPointer = (stanza: Element) => {
+      if (
+        stanza.is('presence') &&
+        stanza.attrs.from.split('/')[0] === roomId
+      ) {
+        const xEls = stanza.getChildren('x');
+
+        if (xEls.length === 2) {
+          const x = xEls.find(
+            (el) => el.attrs.xmlns === 'http://jabber.org/protocol/muc#user'
+          );
+
+          if (x) {
+            const statuses = x.getChildren('status');
+
+            if (!statuses) {
+              unsubscribe();
+              reject('!statuses');
+            }
+
+            const codes = statuses.map((el) => el.attrs.code);
+
+            if (codes.includes('201') && codes.includes('110')) {
+              console.log('createRoomPresence:resolve true');
+              unsubscribe();
+              resolve(true);
+            } else {
+              console.log(
+                'createRoomPresence:reject, such room already exists'
+              );
+              unsubscribe();
+              resolve(true);
+            }
+          } else {
+            unsubscribe();
+            reject();
+          }
+        }
+      }
+    };
+
+    client.on('stanza', stanzaHdlrPointer);
+
+    const message = xml(
+      'presence',
+      {
+        to: `${roomId}/${client.jid.getLocal()}`,
+      },
+      xml('x', 'http://jabber.org/protocol/muc')
+    );
+
+    client.send(message);
+  });
+
+  const timeoutPromise = createTimeoutPromise(2000, unsubscribe);
+
+  return Promise.race([responsePromise, timeoutPromise]);
+}

package/src/networking/xmpp/createTimeoutPromise.xmpp.ts

@@ -0,0 +1,15 @@
+export function createTimeoutPromise(
+  ms: number | undefined,
+  unsubscribe?: () => void
+) {
+  return new Promise((_, reject) => {
+    setTimeout(() => {
+      try {
+        if (unsubscribe) {
+          unsubscribe();
+        }
+      } catch (e) {}
+      reject();
+    }, ms);
+  });
+}

package/src/networking/xmpp/deleteMessage.xmpp.ts

@@ -0,0 +1,19 @@
+import { Client, xml } from '@xmpp/client';
+
+export function deleteMessage(client: Client, room: string, msgId: string) {
+  const stanza = xml(
+    'message',
+    {
+      from: client.jid?.toString(),
+      to: room,
+      id: 'deleteMessageStanza',
+      type: 'groupchat',
+    },
+    xml('body', 'wow'),
+    xml('delete', {
+      id: msgId,
+    })
+  );
+
+  client.send(stanza);
+}

package/src/networking/xmpp/editMessage.xmpp.ts

@@ -0,0 +1,46 @@
+import { Client, xml } from '@xmpp/client';
+import { createTimeoutPromise } from './createTimeoutPromise.xmpp';
+
+export async function editMessage(client: Client, chatId: string, messageId: string, text: string) {
+  const id = `edit-message-${Date.now().toString()}`;
+  const xmlMessage = xml(
+    'message',
+    {
+      to: chatId,
+      type: 'groupchat',
+      id: id,
+    },
+    xml(
+      'replace',
+      {
+        id: messageId,
+        text: text,
+      }
+    )
+  );
+  // let stanzaHdlrPointer;
+  // const unsubscribe = () => {
+  //   client.off('stanza', stanzaHdlrPointer)
+  // }
+  // const responsePromise = new Promise((resolve, _) => {
+  //   stanzaHdlrPointer = (stanza) => {
+  //     if (stanza.is("message") && stanza.attrs["id"] === id) {
+  //         console.log("edit message response ", stanza.toString())
+  //         resolve(true)
+  //     //   const msg = stanza
+  //     //   const text = msg.getChild('body')?.getText()
+  //     //   if (text) {
+  //     //     let parsedEl: any = {}
+  //     //     const result = ws.realtimeMessageParser(msg)
+  //     //     unsubscribe()
+  //     //     resolve(true)
+  //     //   }
+  //     }
+  //   }
+  //   client.on("stanza", stanzaHdlrPointer)
+  //   console.log("editMessage:send:stanza ", xmlMessage.toString())
+    client.send(xmlMessage);
+  // })
+  // const timeoutPromise = createTimeoutPromise(10000, unsubscribe)
+  // return Promise.race([responsePromise, timeoutPromise]);
+}

package/src/networking/xmpp/getChatsPrivateStoreRequest.xmpp.ts

@@ -0,0 +1,57 @@
+import { Client, xml } from '@xmpp/client';
+import { Element } from 'ltx';
+
+export async function getChatsPrivateStoreRequest(client: Client) {
+  const id = `get-chats-private-req:${Date.now().toString()}`;
+
+  return new Promise((resolve, reject) => {
+    let stanzaHdlrPointer: (stanza: Element) => void;
+
+    const timeout = setTimeout(() => {
+      client.off('stanza', stanzaHdlrPointer);
+      reject(new Error('get-chats-private timed out'));
+    }, 10000);
+
+    stanzaHdlrPointer = (stanza: Element) => {
+      if (stanza.is('iq') && stanza.attrs.id === id) {
+        clearTimeout(timeout);
+        client.off('stanza', stanzaHdlrPointer);
+
+        if (stanza.attrs.type === 'error') {
+          reject(new Error('Error response from server'));
+          return;
+        }
+
+        const chatjson = stanza.getChild('query')?.getChild('chatjson');
+        if (chatjson && chatjson.attrs.value) {
+          try {
+            const roomTimestampObject = JSON.parse(chatjson.attrs.value);
+            resolve(roomTimestampObject);
+          } catch (e) {
+            reject(e);
+          }
+        } else {
+          resolve(null);
+        }
+      }
+    };
+
+    client.on('stanza', stanzaHdlrPointer);
+
+    const message = xml(
+      'iq',
+      { id, type: 'get' },
+      xml(
+        'query',
+        { xmlns: 'jabber:iq:private' },
+        xml('chatjson', { xmlns: 'chatjson:store' })
+      )
+    );
+
+    client.send(message).catch((err) => {
+      clearTimeout(timeout);
+      client.off('stanza', stanzaHdlrPointer);
+      reject(err);
+    });
+  });
+}

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

@@ -0,0 +1,140 @@
+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';
+
+export const getHistory = async (
+  client: Client,
+  chatJID: string,
+  max: number,
+  before?: number,
+  otherId?: string
+): Promise<IMessage[] | undefined> => {
+  if (typeof chatJID !== 'string') {return;}
+  // If a caller passes a bare local-part (no `@host`), pick a default
+  // conference based on the client's actual service URL — never leak a
+  // hard-coded dev domain.
+  const fixedChatJid = chatJID.includes('@')
+    ? chatJID
+    : (() => {
+        const service: string = (client as any)?.options?.service || '';
+        const host =
+          service.match(/wss?:\/\/([^:/]+)/)?.[1] || 'xmpp.chat.ethora.com';
+        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();
+
+          if (text || reactions) {
+            const result = await getDataFromXml(msg);
+            if (!result) {
+              return;
+            }
+            const { data, id, body, ...rest } = result;
+
+            if (!data) {
+              console.log('No data in stanza');
+              return;
+            }
+
+            const message = await createMessageFromXml({
+              data,
+              id,
+              body,
+              ...rest,
+            });
+
+            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,
+      },
+      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')
+        )
+      )
+    );
+
+    client?.send(message).catch((err) => 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>,
+      timeoutPromise as Promise<null>,
+    ]);
+    return res === null ? [] : res;
+  } catch (e) {
+    console.log('=-> error in', fixedChatJid, e);
+    return [];
+  } finally {
+    unsubscribe();
+  }
+};

package/src/networking/xmpp/getLastMessageArchive.xmpp.ts

@@ -0,0 +1,24 @@
+import { Client, xml } from '@xmpp/client';
+
+export function getLastMessage(client: Client, roomJID: string) {
+  const message = xml(
+    'iq',
+    {
+      type: 'set',
+      to: roomJID,
+      id: 'GetArchive',
+    },
+    xml(
+      'query',
+      { xmlns: 'urn:xmpp:mam:2' },
+      xml(
+        'set',
+        { xmlns: 'http://jabber.org/protocol/rsm' },
+        xml('max', {}, '1'),
+        xml('before')
+      )
+    )
+  );
+
+  client.send(message);
+}

package/src/networking/xmpp/getRoomInfo.xmpp.ts

@@ -0,0 +1,15 @@
+import { Client, xml } from '@xmpp/client';
+
+export const getRoomInfo = (roomJID: string, client: Client) => {
+  //main info, descrription etc
+  const message = xml(
+    'iq',
+    {
+      id: 'roomInfo',
+      to: roomJID,
+      type: 'get',
+    },
+    xml('query', { xmlns: 'http://jabber.org/protocol/disco#info' })
+  );
+  client.send(message);
+};

package/src/networking/xmpp/getRoomMembers.xmpp.ts

@@ -0,0 +1,13 @@
+import { xml } from '@xmpp/client';
+
+export const getRoomMembers = (roomJID: string, client: any) => {
+  const message = xml(
+    'iq',
+    {
+      id: 'roomMemberInfo',
+      type: 'get',
+    },
+    xml('query', { xmlns: 'ns:room:last', room: roomJID })
+  );
+  client.send(message);
+};

package/src/networking/xmpp/getRooms.xmpp.ts

@@ -0,0 +1,43 @@
+import { Client, xml } from '@xmpp/client';
+import { createTimeoutPromise } from './createTimeoutPromise.xmpp';
+import { Element } from 'ltx';
+
+export const getRooms = async (client: Client): Promise<any> => {
+  let stanzaHdlrPointer: (stanza: Element) => void;
+
+  const unsubscribe = () => {
+    client.off('stanza', stanzaHdlrPointer);
+  };
+
+  const responsePromise = new Promise<void>((resolve, reject) => {
+    stanzaHdlrPointer = (stanza) => {};
+
+    client.on('stanza', stanzaHdlrPointer);
+
+    const message = xml(
+      'iq',
+      {
+        type: 'get',
+        from: client.jid?.toString(),
+        id: 'getUserRooms',
+      },
+      xml('query', { xmlns: 'ns:getrooms' })
+    );
+
+    client.send(message).catch((err) => {
+      console.error('Error sending getRooms request:', err);
+      unsubscribe();
+      reject(err);
+    });
+    resolve();
+  });
+
+  const timeoutPromise = createTimeoutPromise(2000, unsubscribe);
+
+  try {
+    return await Promise.race([responsePromise, timeoutPromise]);
+  } catch (e) {
+    console.error('Error in getRooms:', e);
+    return null;
+  }
+};

package/src/networking/xmpp/getRoomsPaged.xmpp.ts

@@ -0,0 +1,59 @@
+import { Client, xml } from '@xmpp/client';
+import { createTimeoutPromise } from './createTimeoutPromise.xmpp';
+import { Element } from '@xmpp/xml';
+
+export const getRoomsPaged = async (
+  client: Client,
+  maxResults = 3,
+  before = null
+) => {
+  let stanzaHdlrPointer: {
+    (el: Element): void;
+    (stanza: any): void;
+    (el: Element): void;
+  };
+
+  const unsubscribe = () => {
+    client.off('stanza', stanzaHdlrPointer);
+  };
+
+  return new Promise(async (resolve, reject) => {
+    stanzaHdlrPointer = (stanza) => {
+      if (stanza.is('iq') && stanza.attrs.id === 'getUserRooms') {
+        unsubscribe();
+        resolve(stanza);
+      }
+    };
+
+    client.on('stanza', stanzaHdlrPointer);
+
+    const query = xml('query', { xmlns: 'ns:getrooms' });
+    const set = xml(
+      'set',
+      { xmlns: 'http://jabber.org/protocol/rsm' },
+      xml('max', {}, maxResults.toString())
+    );
+
+    if (before) {
+      set.append(xml('before', {}, before));
+    }
+
+    query.append(set);
+
+    const message = xml(
+      'iq',
+      { type: 'get', from: client.jid?.toString(), id: 'getUserRoomsPaged' },
+      query
+    );
+
+    try {
+      client.send(message);
+    } catch (err) {
+      console.error('Error sending getRooms request:', err);
+      unsubscribe();
+      reject(err);
+    }
+
+    await createTimeoutPromise(2000, unsubscribe).catch(reject);
+  });
+};

package/src/networking/xmpp/handlePong.xmpp.ts

@@ -0,0 +1,7 @@
+export function isPong(stanza: any, pingId: string): boolean {
+  return (
+    stanza.is('iq') &&
+    stanza.attrs.id === pingId &&
+    stanza.attrs.type === 'result'
+  );
+}

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

@@ -0,0 +1,55 @@
+import { Element } from 'ltx';
+import {
+  onDeleteMessage,
+  onEditMessage,
+  onRealtimeMessage,
+  onMessageHistory,
+  onGetLastMessageArchive,
+  handleComposing,
+  onChatInvite,
+  onPresenceInRoom,
+  onGetChatRooms,
+  onGetMembers,
+  onGetRoomInfo,
+  onNewRoomCreated,
+  onReactionMessage,
+  onReactionHistory,
+  onRoomKicked,
+  onMessageError,
+} from '../stanzaHandlers';
+import XmppClient from '../xmppClient';
+
+export function handleStanza(stanza: Element, xmppWs: XmppClient) {
+  if (stanza?.attrs?.type === 'headline') {return;}
+  switch (stanza.name) {
+    case 'message':
+      onMessageError(stanza, xmppWs);
+      onReactionMessage(stanza);
+      onReactionHistory(stanza);
+      onDeleteMessage(stanza);
+      onEditMessage(stanza);
+      onChatInvite(stanza, xmppWs);
+      onRealtimeMessage(stanza);
+      onMessageHistory(stanza);
+      handleComposing(stanza, xmppWs.username);
+      onPresenceInRoom(stanza);
+      break;
+    case 'presence':
+      onRoomKicked(stanza);
+      onPresenceInRoom(stanza);
+      break;
+    case 'iq':
+      onGetChatRooms(stanza, xmppWs);
+      onRealtimeMessage(stanza);
+      onPresenceInRoom(stanza);
+      onGetMembers(stanza);
+      onGetRoomInfo(stanza);
+      onGetLastMessageArchive(stanza);
+      break;
+    case 'room-config':
+      onNewRoomCreated(stanza, xmppWs);
+      break;
+    default:
+      console.log('Unhandled stanza type:', stanza.name);
+  }
+}

package/src/networking/xmpp/inviteRoomRequest.xmpp.ts

@@ -0,0 +1,25 @@
+import { Client, xml } from '@xmpp/client';
+import { CHAT_DOMAIN } from '../../helpers/constants/PLATFORM_CONSTANTS';
+
+export async function inviteRoomRequest(
+  client: Client,
+  to: string,
+  roomJid: string
+) {
+  const id = `invite-rooms:${Date.now().toString()}`;
+
+  const xmlMessage = xml(
+    'message',
+    {
+      to: roomJid,
+      id: id,
+    },
+    xml(
+      'x',
+      'http://jabber.org/protocol/muc#user',
+      xml('invite', { to: to + CHAT_DOMAIN })
+    )
+  );
+
+  client.send(xmlMessage);
+}

package/src/networking/xmpp/leaveTheRoom.xmpp.ts

@@ -0,0 +1,15 @@
+import { Client, xml } from '@xmpp/client';
+
+export const leaveTheRoom = (roomJID: string, client: Client) => {
+  if (!client.jid) {
+    throw new Error(
+      'Client JID is not set. Ensure the client is authenticated before calling this function.'
+    );
+  }
+  const message = xml('presence', {
+    to: `${roomJID}/${client.jid.getLocal()}`,
+    type: 'unavailable',
+  });
+
+  client.send(message);
+};