@ethora/chat-component-rn 26.4.1

package/src/networking/xmpp/listenerManager.ts

@@ -0,0 +1,116 @@
+import { Client } from '@xmpp/client';
+import { Element } from '@xmpp/xml';
+
+const activeListeners = new Map<
+  string,
+  {
+    handler: (stanza: Element) => void;
+    client: Client;
+    eventType: string;
+    timestamp: number;
+  }
+>();
+
+export class XmppListenerManager {
+  static addListener(
+    client: Client,
+    eventType: string,
+    listenerKey: string,
+    handler: (stanza: Element) => void
+  ): void {
+    this.removeListener(listenerKey);
+
+    activeListeners.set(listenerKey, {
+      handler,
+      client,
+      eventType,
+      timestamp: Date.now(),
+    });
+
+    client.on(eventType, handler);
+
+    if (process.env.NODE_ENV === 'development') {
+      console.log(
+        `[XmppListenerManager] Added listener: ${listenerKey}, Total: ${activeListeners.size}`
+      );
+    }
+  }
+
+  static removeListener(listenerKey: string): boolean {
+    const listener = activeListeners.get(listenerKey);
+    if (listener) {
+      listener.client.off(listener.eventType, listener.handler);
+      activeListeners.delete(listenerKey);
+
+      if (process.env.NODE_ENV === 'development') {
+        console.log(
+          `[XmppListenerManager] Removed listener: ${listenerKey}, Total: ${activeListeners.size}`
+        );
+      }
+      return true;
+    }
+    return false;
+  }
+
+  static removeAllListenersForClient(client: Client): void {
+    let removedCount = 0;
+    for (const [key, listener] of activeListeners.entries()) {
+      if (listener.client === client) {
+        listener.client.off(listener.eventType, listener.handler);
+        activeListeners.delete(key);
+        removedCount++;
+      }
+    }
+
+    if (process.env.NODE_ENV === 'development' && removedCount > 0) {
+      console.log(
+        `[XmppListenerManager] Removed ${removedCount} listeners for client, Total: ${activeListeners.size}`
+      );
+    }
+  }
+
+  static getListenerKey(operation: string, identifier: string): string {
+    return `${operation}-${identifier}`;
+  }
+
+  static clearAllListeners(): void {
+    const count = activeListeners.size;
+    for (const [key, listener] of activeListeners.entries()) {
+      listener.client.off(listener.eventType, listener.handler);
+    }
+    activeListeners.clear();
+
+    if (process.env.NODE_ENV === 'development') {
+      console.log(`[XmppListenerManager] Cleared all ${count} listeners`);
+    }
+  }
+
+  static getActiveListenerCount(): number {
+    return activeListeners.size;
+  }
+
+  static getActiveListenersInfo(): Array<{
+    key: string;
+    eventType: string;
+    timestamp: number;
+    age: number;
+  }> {
+    const now = Date.now();
+    return Array.from(activeListeners.entries()).map(([key, listener]) => ({
+      key,
+      eventType: listener.eventType,
+      timestamp: listener.timestamp,
+      age: now - listener.timestamp,
+    }));
+  }
+
+  static logActiveListeners(): void {
+    if (process.env.NODE_ENV === 'development') {
+      const info = this.getActiveListenersInfo();
+      console.log(
+        `[XmppListenerManager] Active listeners (${info.length}):`,
+        info
+      );
+    }
+  }
+}

package/src/networking/xmpp/presenceInRoom.xmpp.ts

@@ -0,0 +1,57 @@
+import { Client, xml } from '@xmpp/client';
+import { createTimeoutPromise } from './createTimeoutPromise.xmpp';
+import { Element } from '@xmpp/xml';
+export const presenceInRoom = async (
+  client: Client,
+  roomJID: string,
+  delay = 2000
+): Promise<Element> => {
+  let stanzaHandler: (stanza: Element) => void;
+
+  const unsubscribe = () => client.off('stanza', stanzaHandler);
+
+  return new Promise(async (resolve, reject) => {
+    let settled = false;
+
+    const finish = (cb: (value?: any) => void, value?: any) => {
+      if (settled) {return;}
+      settled = true;
+
+      setTimeout(() => {
+        unsubscribe();
+        cb(value);
+      }, delay);
+    };
+
+    stanzaHandler = (stanza) => {
+      if (
+        stanza.is('presence') &&
+        stanza.attrs.id === 'presenceInRoom' &&
+        stanza.attrs.from?.startsWith(roomJID)
+      ) {
+        finish(resolve, stanza);
+      }
+    };
+
+    client.on('stanza', stanzaHandler);
+
+    const presence = xml(
+      'presence',
+      {
+        from: client.jid?.toString(),
+        to: `${roomJID}/${client.jid?.getLocal()}`,
+        id: 'presenceInRoom',
+      },
+      xml('x', { xmlns: 'http://jabber.org/protocol/muc' })
+    );
+
+    try {
+      await client.send(presence);
+    } catch (err) {
+      unsubscribe();
+      return [];
+    }
+
+    await createTimeoutPromise(2000, unsubscribe).catch(reject);
+  });
+};

package/src/networking/xmpp/roomConfig.xmpp.ts

@@ -0,0 +1,71 @@
+import { Client, xml } from '@xmpp/client';
+import { createTimeoutPromise } from './createTimeoutPromise.xmpp';
+import { Element } from 'ltx';
+
+export function roomConfig(
+  roomId: string,
+  roomTitle: string,
+  roomDescription: string,
+  client: Client
+) {
+  const id = `room-config:${Date.now().toString()}`;
+
+  let stanzaHdlrPointer: {
+    (el: Element): void;
+    (stanza: any): void;
+    (el: Element): void;
+  };
+
+  const unsubscribe = () => {
+    client.off('stanza', stanzaHdlrPointer);
+  };
+
+  const responsePromise = new Promise((resolve) => {
+    stanzaHdlrPointer = (stanza: { attrs: { [x: string]: string } }) => {
+      if (stanza.attrs.id === id && stanza.attrs.type === 'result') {
+        unsubscribe();
+        resolve(true);
+      }
+    };
+
+    client.on('stanza', stanzaHdlrPointer);
+
+    const message = xml(
+      'iq',
+      {
+        id: id,
+        to: roomId,
+        type: 'set',
+      },
+      xml(
+        'query',
+        { xmlns: 'http://jabber.org/protocol/muc#owner' },
+        xml(
+          'x',
+          { xmlns: 'jabber:x:data', type: 'submit' },
+          xml(
+            'field',
+            { var: 'FORM_TYPE' },
+            xml('value', {}, 'http://jabber.org/protocol/muc#roomconfig')
+          ),
+          xml(
+            'field',
+            { var: 'muc#roomconfig_roomname' },
+            xml('value', {}, roomTitle)
+          ),
+          xml(
+            'field',
+            { var: 'muc#roomconfig_roomdesc' },
+            xml('value', {}, roomDescription)
+          )
+        )
+      )
+    );
+
+    client.send(message);
+  });
+
+  const timeoutPromise = createTimeoutPromise(2000, unsubscribe);
+
+  return Promise.race([responsePromise, timeoutPromise]);
+}

package/src/networking/xmpp/sendMediaMessage.xmpp.ts

@@ -0,0 +1,97 @@
+import { Client, xml } from '@xmpp/client';
+
+/**
+ * Same xmlns derivation as sendTextMessage — the server registers app
+ * messages under the WSS service URL (`wss://<host>/ws`), and stanzas
+ * carrying a bare hostname (or no xmlns at all) get silently dropped.
+ */
+const toServiceXmlns = (devServer: string | undefined, client: Client): string => {
+  const clientService = (client as any)?.options?.service as string | undefined;
+  if (clientService && /^wss?:\/\//.test(clientService)) {return clientService;}
+  const ds = (devServer || '').trim();
+  if (!ds) {return 'wss://xmpp.ethoradev.com/ws';}
+  if (/^wss?:\/\//.test(ds)) {return ds;}
+  if (ds.includes('://')) {return ds;}
+  return `wss://${ds.replace(/^\/+|\/+$/g, '')}/ws`;
+};
+
+export function sendMediaMessage(
+  client: Client,
+  roomJID: string,
+  data: any,
+  customId?: string,
+  devServer?: string
+) {
+  const id =
+    customId || `send-media-message-${Date.now().toString()}`;
+
+  const dataToSend = {
+    xmlns: toServiceXmlns(devServer, client),
+    senderJID: client.jid?.toString(),
+    senderFirstName: data.firstName,
+    senderLastName: data.lastName,
+    senderWalletAddress: data.walletAddress,
+    isSystemMessage: false,
+    tokenAmount: '0',
+    receiverMessageId: '0',
+    mucname: data.chatName,
+    photoURL: data.userAvatar ? data.userAvatar : '',
+    isMediafile: true,
+    createdAt: data.createdAt,
+    expiresAt: data.expiresAt,
+    fileName: data.fileName,
+    isVisible: data.isVisible,
+    location: data.location,
+    locationPreview: data.locationPreview,
+    mimetype: data.mimetype,
+    originalName: data.originalName,
+    ownerKey: data.ownerKey,
+    size: data.size,
+    duration: data?.duration,
+    updatedAt: data.updatedAt,
+    userId: data.userId,
+    waveForm: data.waveForm,
+    attachmentId: data?.attachmentId,
+    isReply: data?.isReply,
+    showInChannel: data?.showInChannel,
+    mainMessage: data?.mainMessage,
+    roomJid: data?.roomJid,
+    push: 'true',
+  };
+
+  const message = xml(
+    'message',
+    {
+      id: id,
+      type: 'groupchat',
+      from: client.jid?.toString(),
+      to: roomJID,
+    },
+    xml('body', {}, 'media'),
+    xml('store', { xmlns: 'urn:xmpp:hints' }),
+    xml('data', dataToSend)
+  );
+
+  console.log('🟢 [sendMediaMessage] sending stanza', {
+    id,
+    to: roomJID,
+    mime: data?.mimetype,
+    name: data?.fileName,
+  });
+  try {
+    const sendResult = client.send(message);
+    if (sendResult && typeof (sendResult as any).then === 'function') {
+      (sendResult as Promise<unknown>)
+        .then(() => console.log('🟢 [sendMediaMessage] client.send resolved', { id }))
+        .catch((err) =>
+          console.error('🔴 [sendMediaMessage] client.send REJECTED', {
+            id,
+            message: (err as any)?.message,
+          })
+        );
+    }
+  } catch (error) {
+    console.error('🔴 [sendMediaMessage] sync error', error);
+  }
+  return id;
+}

package/src/networking/xmpp/sendMessageReaction.xmpp.ts

@@ -0,0 +1,41 @@
+import { Client, xml } from '@xmpp/client';
+
+export function sendMessageReaction(
+  client: Client,
+  messageId: string,
+  roomJid: string,
+  reactionsList: string[],
+  data: any,
+  reactionSymbol?: any,
+) {
+  const id = `message-reaction:${Date.now().toString()}`;
+
+  const dataReaction = {
+    senderFirstName: data.firstName,
+    senderLastName: data.lastName,
+  };
+
+  const message = xml(
+    'message',
+    {
+      id: id,
+      type: 'groupchat',
+      from: client.jid?.toString(),
+      to: roomJid,
+    },
+    xml(
+      'reactions',
+      {
+        id: messageId,
+        from: client.jid?.toString(),
+        xmlns: 'urn:xmpp:reactions:0',
+      },
+      ...reactionsList.map((reaction) => xml('reaction', {}, reaction ?? ''))
+      // xml('reaction', {}, reactionSymbol ?? '👋'),
+    ),
+    xml('data', dataReaction),
+    xml('store', { xmlns: 'urn:xmpp:hints' })
+  );
+
+  client.send(message);
+}

package/src/networking/xmpp/sendPing.xmpp.ts

@@ -0,0 +1,21 @@
+import { xml } from '@xmpp/client';
+
+export function sendPing(client: any, to: string, id?: string) {
+  if (
+    client.status !== 'online' ||
+    client._status === 'closing' ||
+    client._status === 'closed'
+  ) {
+    return null;
+  }
+
+  const pingId =
+    id || 'ping-' + Date.now() + '-' + Math.floor(Math.random() * 10000);
+  const pingStanza = xml(
+    'iq',
+    { type: 'get', to, id: pingId },
+    xml('ping', 'urn:xmpp:ping')
+  );
+  client.send(pingStanza);
+  return pingId;
+}

package/src/networking/xmpp/sendTextMessage.xmpp.ts

@@ -0,0 +1,99 @@
+import { Client, xml } from '@xmpp/client';
+
+/**
+ * Normalize devServer to the WSS service URL that the server uses as
+ * the data-element xmlns. The user-facing `xmppDevServer` config
+ * typically holds a bare hostname (`xmpp.chat.ethora.com`); the server
+ * registers messages under the full `wss://<host>/ws` URL, and stanzas
+ * carrying just the bare host as xmlns get silently dropped.
+ *
+ * Mirrors web's `SERVICE` derivation (utils/runtimeHostConfig.ts).
+ */
+const toServiceXmlns = (devServer: string | undefined, client: Client): string => {
+  // Prefer the URL the client is actually connected to — guaranteed to
+  // be the one the server expects.
+  const clientService = (client as any)?.options?.service as string | undefined;
+  if (clientService && /^wss?:\/\//.test(clientService)) {return clientService;}
+  const ds = (devServer || '').trim();
+  if (!ds) {return 'wss://xmpp.ethoradev.com/ws';}
+  if (/^wss?:\/\//.test(ds)) {return ds;}
+  if (ds.includes('://')) {return ds;}
+  // Bare host → wss://<host>/ws
+  return `wss://${ds.replace(/^\/+|\/+$/g, '')}/ws`;
+};
+
+export const sendTextMessage = (
+  client: Client,
+  roomJID: string,
+  firstName: string,
+  lastName: string,
+  photo: string,
+  walletAddress: string,
+  userMessage: string,
+  notDisplayedValue?: string,
+  isReply?: boolean,
+  showInChannel?: boolean,
+  mainMessage?: string,
+  devServer?: string,
+  customId?: string
+) => {
+  const id = customId
+    ? customId
+    : isReply
+      ? `send-reply-message-${Date.now().toString()}`
+      : `send-text-message-${Date.now().toString()}`;
+
+  try {
+    const message = xml(
+      'message',
+      {
+        to: roomJID,
+        type: 'groupchat',
+        id: id,
+      },
+      xml('data', {
+        xmlns: toServiceXmlns(devServer, client),
+        senderFirstName: firstName,
+        senderLastName: lastName,
+        fullName: `${firstName} ${lastName}`,
+        photoURL: photo,
+        senderJID: client.jid?.toString(),
+        senderWalletAddress: walletAddress,
+        roomJid: roomJID,
+        isSystemMessage: false,
+        tokenAmount: 0,
+        quickReplies: '',
+        notDisplayedValue: '',
+        showInChannel: showInChannel || false,
+        isReply: isReply || false,
+        mainMessage: mainMessage || '',
+        push: 'true',
+      }),
+      xml('body', {}, userMessage)
+    );
+    console.log('🟢 [sendTextMessage] sending stanza', {
+      id,
+      to: roomJID,
+      bodyLen: userMessage?.length,
+      clientJid: client.jid?.toString(),
+      xmlns: toServiceXmlns(devServer, client),
+    });
+    const sendResult = client.send(message);
+    if (sendResult && typeof (sendResult as any).then === 'function') {
+      (sendResult as Promise<unknown>)
+        .then(() => console.log('🟢 [sendTextMessage] client.send resolved', { id }))
+        .catch((err) =>
+          console.error('🔴 [sendTextMessage] client.send REJECTED', {
+            id,
+            message: (err as any)?.message,
+            name: (err as any)?.name,
+            stack: (err as any)?.stack,
+          })
+        );
+    } else {
+      console.log('🟡 [sendTextMessage] client.send returned non-promise', { id, type: typeof sendResult });
+    }
+  } catch (error) {
+    console.error('🔴 [sendTextMessage] sync error', error);
+  }
+};

package/src/networking/xmpp/sendTextMessageWithTranslateTag.xmpp.ts

@@ -0,0 +1,44 @@
+import { Client, xml } from '@xmpp/client';
+import { Iso639_1Codes } from '../../types/types';
+
+export const sendTextMessageWithTranslateTag = (
+  client: Client,
+  stanzaMessage: {
+    roomJID: string;
+    firstName: string;
+    lastName: string;
+    photo: string;
+    walletAddress: string;
+    userMessage: string;
+    notDisplayedValue?: string;
+    isReply?: boolean;
+    showInChannel?: boolean;
+    mainMessage?: string;
+    devServer?: string;
+  },
+  source: Iso639_1Codes,
+  customId?: string
+) => {
+  const id = customId || `get-translate-messsage:${Date.now().toString()}`;
+
+  try {
+    const message = xml(
+      'message',
+      {
+        to: stanzaMessage.roomJID,
+        type: 'groupchat',
+        id: id,
+      },
+      xml('data', {
+        ...stanzaMessage,
+        push: 'true',
+      }),
+      xml('body', {}, stanzaMessage.userMessage),
+      xml('translate', { source: source })
+    );
+
+    client.send(message);
+  } catch (error) {
+    console.error('An error occurred while sending message:', error);
+  }
+};

package/src/networking/xmpp/sendTypingRequest.xmpp.ts

@@ -0,0 +1,26 @@
+import { Client, xml } from '@xmpp/client';
+
+export function sendTypingRequest(
+  client: Client,
+  chatId: string,
+  fullName: string,
+  start: boolean
+) {
+  let id = start ? `typing-${Date.now()}` : `stop-typing-${Date.now()}`;
+  const stanza = xml(
+    'message',
+    {
+      type: 'groupchat',
+      id: id,
+      to: chatId,
+    },
+    xml(start ? 'composing' : 'paused', {
+      xmlns: 'http://jabber.org/protocol/chatstates',
+    }),
+    xml('data', {
+      fullName: fullName,
+    })
+  );
+
+  client.send(stanza);
+}

package/src/networking/xmpp/setChatsPrivateStoreRequest.xmpp.ts

@@ -0,0 +1,48 @@
+import { Client, xml } from '@xmpp/client';
+import { Element } from 'ltx';
+import { createTimeoutPromise } from './createTimeoutPromise.xmpp';
+
+export async function setChatsPrivateStoreRequest(
+  client: Client,
+  jsonObj: string
+) {
+  const id = `set-chats-private-req:${Date.now().toString()}`;
+  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('iq') && stanza.attrs.id === id) {
+        resolve(true);
+      }
+    };
+
+    client?.on('stanza', stanzaHdlrPointer);
+
+    const message = xml(
+      'iq',
+      {
+        id: id,
+        type: 'set',
+      },
+      xml(
+        'query',
+        { xmlns: 'jabber:iq:private' },
+        xml('chatjson', { xmlns: 'chatjson:store', value: jsonObj })
+      )
+    );
+
+    client?.send(message);
+  });
+
+  const timeoutPromise = createTimeoutPromise(2000, unsubscribe);
+
+  return Promise.race([responsePromise, timeoutPromise]);
+}

package/src/networking/xmpp/setMeAsOwner.xmpp.ts

@@ -0,0 +1,52 @@
+import { Element } from 'ltx';
+import { Client, xml } from '@xmpp/client';
+import { createTimeoutPromise } from './createTimeoutPromise.xmpp';
+
+export function setMeAsOwner(roomId: string, client: Client) {
+  const id = `set-me-as-owner:${Date.now().toString()}`;
+
+  let stanzaHdlrPointer: {
+    (el: Element): void;
+    (stanza: Element): void;
+    (el: Element): void;
+  };
+
+  const unsubscribe = () => {
+    client.off('stanza', stanzaHdlrPointer);
+  };
+
+  const responsePromise = new Promise((resolve) => {
+    stanzaHdlrPointer = (stanza: Element) => {
+      if (
+        stanza.is('iq') &&
+        stanza.attrs.id === id &&
+        stanza.attrs.type === 'result'
+      ) {
+        unsubscribe();
+        resolve(true);
+      }
+    };
+
+    client.on('stanza', stanzaHdlrPointer);
+
+    const message = xml(
+      'iq',
+      {
+        to: roomId,
+        id: id,
+        type: 'set',
+      },
+      xml(
+        'query',
+        { xmlns: 'http://jabber.org/protocol/muc#owner' },
+        xml('x', { xmlns: 'jabber:x:data', type: 'submit' })
+      )
+    );
+
+    client.send(message);
+  });
+
+  const timeoutPromise = createTimeoutPromise(2000, unsubscribe);
+
+  return Promise.race([responsePromise, timeoutPromise]);
+}