@ethora/chat-component-rn 26.4.1

package/src/utils/clientRegistry.ts

@@ -0,0 +1,80 @@
+import XmppClient from '../networking/xmppClient';
+import { xmppSettingsInterface } from '../types/types';
+
+let currentClient: XmppClient | null = null;
+let currentClientKey = '';
+const initLocks = new Map<string, Promise<XmppClient>>();
+
+const DEFAULT_DEV_SERVER = 'xmpp.chat.ethora.com';
+
+export function buildXmppClientKey(
+  username: string,
+  xmppSettings?: xmppSettingsInterface
+): string {
+  const devServer = xmppSettings?.devServer || DEFAULT_DEV_SERVER;
+  const host = xmppSettings?.host || '';
+  const conference = xmppSettings?.conference || '';
+  return `${username}|${devServer}|${host}|${conference}`;
+}
+
+export function isXmppClientReusable(client: XmppClient | null): boolean {
+  if (!client) {return false;}
+  return client.status === 'online' || client.status === 'connecting';
+}
+
+export function setGlobalXmppClient(
+  client: XmppClient | null,
+  key?: string
+): void {
+  currentClient = client;
+  currentClientKey = client ? key || currentClientKey || '' : '';
+}
+
+export function getGlobalXmppClient(): XmppClient | null {
+  return currentClient;
+}
+
+export function getGlobalXmppClientKey(): string {
+  return currentClientKey;
+}
+
+export function getReusableXmppClientByKey(key: string): XmppClient | null {
+  if (!key || key !== currentClientKey) {return null;}
+  if (!isXmppClientReusable(currentClient)) {return null;}
+  return currentClient;
+}
+
+export async function withXmppClientInitLock(
+  key: string,
+  init: () => Promise<XmppClient>
+): Promise<XmppClient> {
+  const existing = initLocks.get(key);
+  if (existing) {return existing;}
+
+  const createdPromise = init().finally(() => {
+    if (initLocks.get(key) === createdPromise) {
+      initLocks.delete(key);
+    }
+  });
+
+  initLocks.set(key, createdPromise);
+  return createdPromise;
+}
+
+export function requireXmppClient(): XmppClient {
+  if (!currentClient) {
+    throw new Error('XMPP client is not initialized');
+  }
+  return currentClient;
+}
+
+export default {
+  buildXmppClientKey,
+  isXmppClientReusable,
+  setGlobalXmppClient,
+  getGlobalXmppClient,
+  getGlobalXmppClientKey,
+  getReusableXmppClientByKey,
+  withXmppClientInitLock,
+  requireXmppClient,
+};

package/src/utils/devLogger.ts

@@ -0,0 +1,197 @@
+/**
+ * Dev-only log bus used by the testbed `Logs` tab. Stores a bounded
+ * ring-buffer of entries that arrive from:
+ *   - `console.log/info/warn/error` (patched in `installDevLogCapture`)
+ *   - `axios` request/response interceptors (HTTP)
+ *   - `XmppClient.attachEventListeners` (XMPP stanzas in/out)
+ *
+ * Pure module-level singleton — no React, callable from anywhere
+ * (reducers, services, helpers). React side reads via
+ * `useDevLogs()` which uses `useSyncExternalStore`.
+ */
+
+export type LogKind = 'log' | 'info' | 'warn' | 'error' | 'http' | 'xmpp' | 'rn';
+
+export interface LogEntry {
+  id: number;
+  kind: LogKind;
+  ts: number;
+  message: string;
+  details?: string;
+}
+
+const MAX_ENTRIES = 500;
+
+let entries: LogEntry[] = [];
+let listeners: Set<() => void> = new Set();
+let nextId = 1;
+
+export function pushLog(
+  kind: LogKind,
+  message: string,
+  details?: any
+): void {
+  const detailsStr =
+    details === undefined
+      ? undefined
+      : typeof details === 'string'
+        ? details
+        : safeStringify(details);
+  entries = [
+    ...entries,
+    { id: nextId++, kind, ts: Date.now(), message, details: detailsStr },
+  ];
+  if (entries.length > MAX_ENTRIES) {
+    entries = entries.slice(-MAX_ENTRIES);
+  }
+  // Defer subscriber notifications via microtask so a `pushLog` called
+  // during a React render (e.g. via the captured `console.log`) doesn't
+  // trigger a setState-during-render warning in subscribers using
+  // `useSyncExternalStore`.
+  const notify = () =>
+    listeners.forEach((fn) => {
+      try {
+        fn();
+      } catch {
+        /* noop */
+      }
+    });
+  if (typeof queueMicrotask === 'function') {
+    queueMicrotask(notify);
+  } else {
+    Promise.resolve().then(notify);
+  }
+}
+
+export function clearLogs(): void {
+  entries = [];
+  listeners.forEach((fn) => fn());
+}
+
+export function getLogs(): LogEntry[] {
+  return entries;
+}
+
+export function subscribeLogs(fn: () => void): () => void {
+  listeners.add(fn);
+  return () => {
+    listeners.delete(fn);
+  };
+}
+
+function safeStringify(value: any): string {
+  try {
+    return JSON.stringify(
+      value,
+      (_key, v) => {
+        if (typeof v === 'bigint') {return v.toString();}
+        if (v instanceof Error)
+          {return { name: v.name, message: v.message, stack: v.stack };}
+        return v;
+      },
+      2
+    );
+  } catch {
+    try {
+      return String(value);
+    } catch {
+      return '[unstringifiable]';
+    }
+  }
+}
+
+// ---------------------------------------------------------------------
+// console.* capture
+// ---------------------------------------------------------------------
+let consolePatched = false;
+
+export function installConsoleCapture() {
+  if (consolePatched) {return;}
+  consolePatched = true;
+  (['log', 'info', 'warn', 'error'] as const).forEach((level) => {
+    const original = (console as any)[level].bind(console);
+    (console as any)[level] = (...args: any[]) => {
+      try {
+        const msg = args
+          .map((a) =>
+            typeof a === 'string' ? a : safeStringify(a)
+          )
+          .join(' ');
+        pushLog(level === 'log' ? 'log' : (level as LogKind), msg);
+      } catch {
+        /* swallow */
+      }
+      original(...args);
+    };
+  });
+}
+
+// ---------------------------------------------------------------------
+// axios interceptor
+// ---------------------------------------------------------------------
+let axiosPatched = false;
+
+export function installAxiosCapture(axiosInstance: any) {
+  if (axiosPatched || !axiosInstance?.interceptors) {return;}
+  axiosPatched = true;
+
+  axiosInstance.interceptors.request.use(
+    (config: any) => {
+      const method = (config.method || 'get').toUpperCase();
+      const url = (config.baseURL || '') + (config.url || '');
+      pushLog('http', `→ ${method} ${url}`, {
+        headers: redactHeaders(config.headers),
+        data: config.data,
+      });
+      return config;
+    },
+    (error: any) => {
+      pushLog('http', '→ request error', error?.message || String(error));
+      return Promise.reject(error);
+    }
+  );
+
+  axiosInstance.interceptors.response.use(
+    (response: any) => {
+      const method = (response.config?.method || 'get').toUpperCase();
+      const url = (response.config?.baseURL || '') + (response.config?.url || '');
+      pushLog(
+        'http',
+        `← ${response.status} ${method} ${url}`,
+        truncateBody(response.data)
+      );
+      return response;
+    },
+    (error: any) => {
+      const method = (error.config?.method || '?').toUpperCase();
+      const url = (error.config?.baseURL || '') + (error.config?.url || '');
+      const status = error.response?.status || 'no-status';
+      pushLog('http', `← ERR ${status} ${method} ${url}`, {
+        data: error.response?.data,
+        message: error.message,
+      });
+      return Promise.reject(error);
+    }
+  );
+}
+
+function redactHeaders(headers: any) {
+  if (!headers || typeof headers !== 'object') {return headers;}
+  const out: any = {};
+  for (const k of Object.keys(headers)) {
+    const v = headers[k];
+    if (/^(authorization|x-custom-token|cookie)$/i.test(k)) {
+      out[k] = typeof v === 'string' ? v.slice(0, 16) + '…' : '[redacted]';
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+function truncateBody(body: any) {
+  if (body == null) {return body;}
+  const str = typeof body === 'string' ? body : safeStringify(body);
+  if (str.length <= 2000) {return str;}
+  return str.slice(0, 2000) + `… [+${str.length - 2000} chars]`;
+}

package/src/utils/messageNotificationManager.ts

@@ -0,0 +1,108 @@
+// RN port of web messageNotificationManager — no DOM, queues pending
+// notifications until a callback subscriber registers, dedupes within a
+// short window.
+import { IMessage } from '../types/types';
+
+export interface MessageNotificationCallback {
+  (
+    message: IMessage,
+    roomName: string,
+    senderName: string,
+    roomJID: string
+  ): void;
+}
+
+interface PendingNotification {
+  message: IMessage;
+  roomName: string;
+  senderName: string;
+  roomJID: string;
+  ts: number;
+}
+
+class MessageNotificationManager {
+  private callbacks: Set<MessageNotificationCallback> = new Set();
+  private pending: PendingNotification[] = [];
+  private maxPending = 50;
+  private pendingTtlMs = 30_000;
+  private dedupeWindowMs = 5000;
+  private recentlyDelivered = new Map<string, number>();
+
+  addCallback(callback: MessageNotificationCallback): () => void {
+    this.callbacks.add(callback);
+    this.flushPending();
+    return () => {
+      this.callbacks.delete(callback);
+    };
+  }
+
+  getCallbackCount() {
+    return this.callbacks.size;
+  }
+
+  private flushPending() {
+    if (this.callbacks.size === 0 || this.pending.length === 0) {return;}
+    const now = Date.now();
+    const valid = this.pending.filter(
+      (item) => now - item.ts <= this.pendingTtlMs
+    );
+    this.pending = [];
+    valid.forEach((item) => {
+      this.callbacks.forEach((cb) =>
+        cb(item.message, item.roomName, item.senderName, item.roomJID)
+      );
+    });
+  }
+
+  private buildDedupeKey(message: IMessage, roomJID: string): string | null {
+    const msgId = String((message as any)?.xmppId || message?.id || '').trim();
+    if (msgId) {return `${roomJID}:${msgId}`;}
+    return null;
+  }
+
+  private shouldSkipDuplicate(message: IMessage, roomJID: string): boolean {
+    const now = Date.now();
+    const key = this.buildDedupeKey(message, roomJID);
+    if (!key) {return false;}
+    const prev = this.recentlyDelivered.get(key) || 0;
+    if (prev && now - prev < this.dedupeWindowMs) {return true;}
+    this.recentlyDelivered.set(key, now);
+    if (this.recentlyDelivered.size > 500) {
+      const threshold = now - this.dedupeWindowMs;
+      this.recentlyDelivered.forEach((ts, k) => {
+        if (ts < threshold) {this.recentlyDelivered.delete(k);}
+      });
+    }
+    return false;
+  }
+
+  showNotification(
+    message: IMessage,
+    roomName: string,
+    senderName: string,
+    roomJID: string
+  ) {
+    const body = typeof message?.body === 'string' ? message.body.trim() : '';
+    if (!body) {return;}
+    if (this.shouldSkipDuplicate(message, roomJID)) {return;}
+
+    if (this.callbacks.size > 0) {
+      this.callbacks.forEach((cb) =>
+        cb(message, roomName, senderName, roomJID)
+      );
+    } else {
+      this.pending.push({
+        message,
+        roomName,
+        senderName,
+        roomJID,
+        ts: Date.now(),
+      });
+      if (this.pending.length > this.maxPending) {
+        this.pending = this.pending.slice(-this.maxPending);
+      }
+    }
+  }
+}
+
+export const messageNotificationManager = new MessageNotificationManager();

package/src/utils/resendMessage.ts

@@ -0,0 +1,87 @@
+import { requireXmppClient } from './clientRegistry';
+import { store } from '../roomStore';
+import { addRoomMessage } from '../roomStore/roomsSlice';
+import { v4 as uuidv4 } from 'uuid';
+import { IMessage } from '../types/types';
+
+type ResendOptions = {
+  respectTranslateConfig?: boolean;
+};
+
+export async function resendMessage(
+  message: Pick<IMessage, 'body' | 'roomJid'> & {
+    isReply?: boolean;
+    showInChannel?: string;
+    mainMessage?: string;
+  },
+  options: ResendOptions = {}
+): Promise<string> {
+  const client = requireXmppClient();
+  const state = store.getState();
+  const user = state.chatSettingStore.user;
+  const config = state.chatSettingStore.config;
+  const activeRoomJID = message.roomJid;
+
+  const id = `resend-text-message-${uuidv4()}`;
+
+  store.dispatch(
+    addRoomMessage({
+      roomJID: activeRoomJID,
+      message: {
+        id,
+        user: {
+          ...user,
+          id: user.xmppUsername,
+          name: user.firstName + ' ' + user.lastName,
+        },
+        date: new Date().toISOString(),
+        body: message.body,
+        roomJid: activeRoomJID,
+        xmppFrom: `${activeRoomJID}/${user.xmppUsername}`,
+        pending: true,
+        isReply: message.isReply || false,
+        showInChannel: (message.showInChannel as any) || ('false' as any),
+        mainMessage: message.mainMessage || '',
+      },
+    })
+  );
+
+  const useTranslate = !!(
+    options.respectTranslateConfig && config?.translates?.enabled
+  );
+
+  if (useTranslate) {
+    client.sendTextMessageWithTranslateTagStanza(
+      activeRoomJID,
+      user.firstName,
+      user.lastName,
+      '',
+      user.walletAddress,
+      message.body,
+      '',
+      message.isReply || false,
+      message.showInChannel === 'true' || false,
+      message.mainMessage || '',
+      (state.chatSettingStore.langSource as any) || 'en',
+      id
+    );
+  } else {
+    client.sendMessage(
+      activeRoomJID,
+      user.firstName,
+      user.lastName,
+      '',
+      user.walletAddress,
+      message.body,
+      '',
+      message.isReply || false,
+      message.showInChannel === 'true' || false,
+      message.mainMessage || '',
+      id
+    );
+  }
+
+  return id;
+}
+
+export default resendMessage;

package/src/utils/toastEmitter.ts

@@ -0,0 +1,27 @@
+/**
+ * Tiny pub/sub used by `ToastContext` so non-React code can fire a
+ * toast. Replaces an out-of-tree port artifact (`../../../../utils/...`).
+ */
+import type { ToastType } from '../components/Toast';
+
+type Listener = (toast: ToastType) => void;
+
+const listeners = new Set<Listener>();
+
+export const toastEmitter = {
+  subscribe(fn: Listener) {
+    listeners.add(fn);
+    return () => {
+      listeners.delete(fn);
+    };
+  },
+  emit(toast: ToastType) {
+    listeners.forEach((fn) => {
+      try {
+        fn(toast);
+      } catch {
+        /* swallow */
+      }
+    });
+  },
+};

package/src/utils/xmppMemoryMonitor.ts

@@ -0,0 +1,63 @@
+import { XmppListenerManager } from '../networking/xmpp/listenerManager';
+
+export class XmppMemoryMonitor {
+  private static monitoringInterval: NodeJS.Timeout | null = null;
+  private static warningThreshold = 10;
+  private static criticalThreshold = 20;
+
+  static startMonitoring(intervalMs: number = 5000): void {
+    if (this.monitoringInterval) {
+      this.stopMonitoring();
+    }
+
+    this.monitoringInterval = setInterval(() => {
+      const count = XmppListenerManager.getActiveListenerCount();
+
+      if (count >= this.criticalThreshold) {
+        console.warn(
+          `[XmppMemoryMonitor] CRITICAL: ${count} active XMPP listeners detected!`
+        );
+        XmppListenerManager.logActiveListeners();
+      } else if (count >= this.warningThreshold) {
+        console.warn(
+          `[XmppMemoryMonitor] WARNING: ${count} active XMPP listeners detected`
+        );
+      } else if (process.env.NODE_ENV === 'development') {
+        console.log(`[XmppMemoryMonitor] Active XMPP listeners: ${count}`);
+      }
+    }, intervalMs);
+
+    console.log('[XmppMemoryMonitor] Started monitoring XMPP listeners');
+  }
+
+  static stopMonitoring(): void {
+    if (this.monitoringInterval) {
+      clearInterval(this.monitoringInterval);
+      this.monitoringInterval = null;
+      console.log('[XmppMemoryMonitor] Stopped monitoring XMPP listeners');
+    }
+  }
+
+  static setThresholds(warning: number, critical: number): void {
+    this.warningThreshold = warning;
+    this.criticalThreshold = critical;
+  }
+
+  static getCurrentCount(): number {
+    return XmppListenerManager.getActiveListenerCount();
+  }
+
+  static forceCleanup(): void {
+    console.warn('[XmppMemoryMonitor] Force cleaning up all XMPP listeners');
+    XmppListenerManager.clearAllListeners();
+  }
+
+  static getListenerInfo(): Array<{
+    key: string;
+    eventType: string;
+    timestamp: number;
+    age: number;
+  }> {
+    return XmppListenerManager.getActiveListenersInfo();
+  }
+}

package/src/version.ts

@@ -0,0 +1 @@
+export const ETHORA_CHAT_COMPONENT_VERSION = '25.7.5';