@ethora/chat-component-rn 26.4.1

package/src/helpers/createMessageFromXml.ts

@@ -0,0 +1,118 @@
+import { IMessage } from '../types/types';
+
+interface IMessageWithNewData extends IMessage {
+  [x: string]: any;
+}
+
+/**
+ * Build an IMessage from XML.
+ *
+ * Two calling conventions are supported:
+ *
+ * 1. **Wrapped (used by getHistory.xmpp.ts)**:
+ *      createMessageFromXml({ data, id, body, roomJid, date, user, ...rest })
+ *    where `data` is the inner XML `<data>` element's attrs.
+ *
+ * 2. **Positional (used by onRealtimeMessage / onMessageHistory)**:
+ *      createMessageFromXml(dataAttrs, bodyElement, id, fromJid, deleted)
+ *
+ * Both fan into the same merge logic that flattens senderFirstName /
+ * senderLastName / senderJID into `user.{name, firstName, lastName, id}`.
+ */
+export const createMessageFromXml = async (
+  arg: IMessageWithNewData,
+  bodyEl?: any,
+  positionalId?: string,
+  positionalFrom?: string,
+  positionalDeleted?: boolean
+): Promise<IMessage> => {
+  if (!arg) {
+    console.log('createMessageFromXml: arg is required.');
+    // Return a stub so callers don't crash; the reducer will discard
+    // messages without a usable id/date anyway.
+    return { id: '', body: '', date: '', user: { id: '', name: '' } as any, roomJid: '' } as IMessage;
+  }
+
+  // Detect positional vs wrapped. Wrapped always has a top-level
+  // `data` key holding the flat attrs; positional passes the attrs
+  // directly so `arg.data` is undefined.
+  const isPositional = bodyEl !== undefined || positionalId !== undefined;
+
+  let inner: any; // flat XML <data> attrs
+  let outerExtras: any = {};
+
+  if (isPositional) {
+    inner = arg; // arg IS the dataAttrs in this convention
+    const bodyText =
+      typeof bodyEl === 'string'
+        ? bodyEl
+        : bodyEl?.getText
+          ? bodyEl.getText()
+          : bodyEl?.text;
+    outerExtras = {
+      id: positionalId,
+      body: bodyText,
+      roomJid: (positionalFrom || '').split('/')[0],
+      xmppFrom: positionalFrom,
+      deleted: !!positionalDeleted,
+    };
+  } else {
+    inner = arg?.data || {};
+    outerExtras = { ...arg };
+    delete outerExtras.data;
+  }
+
+  const merged: any = {
+    ...inner,
+    ...outerExtras,
+    isDeleted: !!outerExtras?.deleted || !!(arg as any)?.isDeleted,
+  };
+
+  // Date fallback: when called via the realtime path, the stanza may
+  // not carry a date attr — derive it from the message id (server
+  // timestamps are encoded in the stanza-id microseconds prefix), and
+  // ultimately fall back to "now" so the reducer's date-based ordering
+  // doesn't crash on `undefined.toString()`.
+  if (!merged.date) {
+    const numericPart = /\d{13,}/.exec(String(merged.id || ''))?.[0];
+    merged.date = numericPart
+      ? new Date(+numericPart.slice(0, 13)).toISOString()
+      : new Date().toISOString();
+  }
+  if (!merged.id) {
+    merged.id = String(Date.now());
+  }
+
+  // Synthesize user.name from sender attrs (web reads usersSet from
+  // redux in <Message>; we fix it once at the source so Avatar /
+  // MessageHeader render the actual sender instead of "??").
+  const firstName = (merged.senderFirstName || '').toString().trim();
+  const lastName = (merged.senderLastName || '').toString().trim();
+  const fullName = (merged.fullName || '').toString().trim();
+  const senderJID = (merged.senderJID || '').toString();
+  const senderLocal = senderJID.includes('@')
+    ? senderJID.split('@')[0]
+    : senderJID;
+  const composed = [firstName, lastName].filter(Boolean).join(' ').trim();
+  const existingName = String(merged?.user?.name || '').trim();
+  const resolvedName =
+    existingName ||
+    composed ||
+    fullName ||
+    senderLocal ||
+    merged?.user?.id ||
+    '';
+
+  const message: IMessage = {
+    ...merged,
+    user: {
+      ...(merged.user || {}),
+      id: merged?.user?.id || senderLocal,
+      name: resolvedName,
+      firstName: firstName || merged?.user?.firstName,
+      lastName: lastName || merged?.user?.lastName,
+    },
+  };
+
+  return message;
+};

package/src/helpers/createRoomFromApi.tsx

@@ -0,0 +1,27 @@
+import { ApiRoom, IRoom } from '../types/types';
+
+export const createRoomFromApi = (
+  room: ApiRoom,
+  service: string = 'conference.dev.xmpp.ethoradev.com',
+  usersArrayLength: number = 0
+): IRoom | null => {
+  try {
+    const roomData: IRoom = {
+      ...room,
+      jid: `${room?.name}@${service}` || '',
+      name: room?.title || '',
+      title: room?.title || '',
+      usersCnt: Number(room?.members?.length || usersArrayLength + 1),
+      messages: [],
+      isLoading: false,
+      roomBg: null,
+      icon: room?.picture !== 'none' ? room?.picture : null,
+      unreadMessages: 0,
+      lastViewedTimestamp: 0,
+    };
+    return roomData;
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};

package/src/helpers/createUserNameFromSetUser.ts

@@ -0,0 +1,15 @@
+import { RoomMember } from '../types/types';
+
+export const createUserNameFromSetUser = (
+  usersSet: Record<string, RoomMember>,
+  userId: string
+): string => {
+  const user = usersSet[userId];
+
+  if (!user) {return 'Deleted User';}
+
+  const firstName = user.firstName?.trim() || '';
+  const lastName = user.lastName?.trim() || '';
+
+  return `${firstName} ${lastName}`.trim() || userId;
+};

package/src/helpers/dateComparison.ts

@@ -0,0 +1,12 @@
+export const isDateBefore = (date1: string, date2: string): boolean => {
+  return new Date(date1) < new Date(date2);
+};
+export const isDateAfter = (date1: string, date2: string): boolean => {
+  return new Date(date1) > new Date(date2);
+};
+
+export const getHighResolutionTimestamp = () => {
+  const milliseconds = Date.now();
+  const microseconds = Math.floor(performance.now() * 10);
+  return `${milliseconds}${microseconds.toString().padStart(6, '0')}`;
+};

package/src/helpers/debounce.ts

@@ -0,0 +1,10 @@
+export function debounce<T extends (...args: any[]) => void>(
+  func: T,
+  delay: number
+): (...args: Parameters<T>) => void {
+  let timeoutId: ReturnType<typeof setTimeout>;
+  return (...args: Parameters<T>) => {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => func(...args), delay);
+  };
+}

package/src/helpers/ensureScopedChatCache.ts

@@ -0,0 +1,61 @@
+import { IConfig } from '../types/types';
+import { store } from '../roomStore';
+import { logout } from '../roomStore/chatSettingsSlice';
+import { setLogoutState } from '../roomStore/roomsSlice';
+import { asyncLocalStorage } from '../hooks/useLocalStorage';
+import { localStorageConstants } from './constants/LOCAL_STORAGE';
+import { clearRoomsRestCache } from '../networking/api-requests/rooms.api';
+import { clearPersistedState } from '../roomStore/persistence';
+import {
+  getGlobalXmppClient,
+  setGlobalXmppClient,
+} from '../utils/clientRegistry';
+
+const SCOPE_KEY = '@ethora/chat-component-scope';
+
+interface ScopeRecord {
+  appId?: string;
+  baseUrl?: string;
+}
+
+/**
+ * Detect an app-scope change (different appId / baseUrl). When detected,
+ * purge the persisted user, redux user/client/rooms state, REST caches,
+ * and the global xmpp client singleton so the next bootstrap re-resolves
+ * against the new tenant. Mirrors web ensureScopedChatCache.
+ */
+export async function ensureScopedChatCache(config?: IConfig): Promise<void> {
+  if (!config?.appId && !config?.baseUrl) {return;}
+
+  const next: ScopeRecord = {
+    appId: config.appId,
+    baseUrl: config.baseUrl,
+  };
+
+  const scopeStore = asyncLocalStorage<ScopeRecord>(SCOPE_KEY);
+  const previous = await scopeStore.get();
+
+  const changed =
+    previous &&
+    (previous.appId !== next.appId || previous.baseUrl !== next.baseUrl);
+
+  if (changed) {
+    try {
+      const client = getGlobalXmppClient();
+      if (client) {
+        await client.disconnect?.({ suppressReconnect: true });
+      }
+    } catch {
+      /* noop */
+    }
+    setGlobalXmppClient(null);
+
+    clearRoomsRestCache();
+    store.dispatch(setLogoutState());
+    store.dispatch(logout());
+    await asyncLocalStorage(localStorageConstants.ETHORA_USER).remove();
+    await clearPersistedState();
+  }
+
+  await scopeStore.set(next);
+}

package/src/helpers/extractUniqueMembersFromRooms.ts

@@ -0,0 +1,45 @@
+import { RoomMember, ApiRoom } from '../types/types';
+
+interface MemberExtractionResult {
+  array: RoomMember[];
+  object: Record<string, RoomMember>;
+  map: Map<string, RoomMember>;
+  set: Set<string>;
+}
+
+export function extractUniqueMembersFromRooms(
+  rooms: ApiRoom[]
+): MemberExtractionResult {
+  const uniqueMembersMap = new Map<string, RoomMember>();
+
+  rooms.forEach((room) => {
+    if (room.members) {
+      room.members.forEach((member) => {
+        if (member && member?.xmppUsername) {
+          uniqueMembersMap.set(member.xmppUsername, member);
+        }
+      });
+    }
+  });
+
+  const uniqueMembersArray = Array.from(uniqueMembersMap.values());
+
+  const uniqueMembersObject = uniqueMembersArray.reduce(
+    (acc, member) => {
+      if (member.xmppUsername) {
+        acc[member.xmppUsername] = member;
+      }
+      return acc;
+    },
+    {} as Record<string, RoomMember>
+  );
+
+  const uniqueMembersSet = new Set(uniqueMembersMap.keys());
+
+  return {
+    array: uniqueMembersArray,
+    object: uniqueMembersObject,
+    map: uniqueMembersMap,
+    set: uniqueMembersSet,
+  };
+}

package/src/helpers/formatNumberWithCommas.ts

@@ -0,0 +1,3 @@
+export function formatNumberWithCommas(num: number | string): string {
+  return num.toLocaleString('en-US');
+}

package/src/helpers/getBooleanFromString.ts

@@ -0,0 +1,7 @@
+export function getBooleanFromString(value: string): boolean | null {
+  if (!value) {return null;}
+  const normalized = value.trim().toLowerCase();
+  if (normalized === 'true') {return true;}
+  if (normalized === 'false') {return false;}
+  return null;
+}

package/src/helpers/getDataFromXml.ts

@@ -0,0 +1,80 @@
+import { Element } from 'ltx';
+import { Iso639_1Codes, IUser } from '../types/types';
+import { transformArrayToObject } from './transformTranslatations';
+
+const extractTimestamp = (str: string, stanza?: any): string | null => {
+  if (!str) {return null;}
+  if (typeof str !== 'string') {
+    console.log(str, stanza.toString());
+    return null;
+  }
+  const timestamp = str.slice(-16);
+  return timestamp;
+};
+
+interface DataXml {
+  id: string;
+  body?: string;
+  roomJid: string;
+  date: string;
+  user: IUser;
+  deleted?: boolean;
+  translations?: any;
+  langSource?: Iso639_1Codes;
+  xmppId?: string;
+  xmppFrom?: string;
+  data: { [x: string]: any };
+}
+export const getDataFromXml = async (stanza: Element): Promise<DataXml | undefined> => {
+  const fullData =
+    stanza.getChild('result')?.getChild('forwarded')?.getChild('message') ||
+    stanza;
+
+  const xmppId = fullData?.attrs.id;
+  const xmppFrom = fullData?.attrs?.from;
+  const [roomJid, userWallet] = xmppFrom.split('/');
+  let id =
+    stanza.getChild('result')?.attrs.id ||
+    extractTimestamp(stanza?.getChild('stanza-id')?.attrs?.id, stanza);
+
+  if (!id) {
+    id = xmppId || Date.now().toString();
+  }
+
+  const body = fullData?.getChild('body')?.getText() || undefined;
+  const deleted = !!fullData?.getChild('deleted');
+  const translations = fullData?.getChild('translations')?.attrs?.value
+    ? transformArrayToObject(
+        JSON.parse(fullData.getChild('translations')!.attrs.value).translates
+      )
+    : undefined;
+  const langSource = fullData?.getChild('translate')?.attrs?.source;
+  const numericPart = /\d{13,}/.exec(id || '')?.[0];
+  const date = numericPart
+    ? new Date(+numericPart.slice(0, 13)).toISOString()
+    : new Date().toISOString();
+
+  const data = fullData?.getChild('data') || stanza?.getChild('data');
+  const photoURL = data?.attrs?.photo;
+
+  const user = {
+    id: userWallet,
+    photoURL,
+  };
+
+  const dataAttrs = data?.attrs || {};
+
+  return {
+    data: dataAttrs,
+    id,
+    body,
+    roomJid,
+    date,
+    user,
+    deleted,
+    translations,
+    langSource,
+    xmppId,
+    xmppFrom,
+  };
+};

package/src/helpers/getNumberFromString.ts

@@ -0,0 +1,5 @@
+export function getNumberFromString(value: string): number | null {
+  if (!value) {return null;}
+  const num = Number(value.trim());
+  return isNaN(num) ? null : num;
+}

package/src/helpers/getRoomsWithRetry.ts

@@ -0,0 +1,45 @@
+import { ApiRoom } from '../types/types';
+import { isChatIdPresentInArray } from './isChatIdPresentInArray';
+
+export async function getRoomsWithRetry(
+  client: any,
+  config: any,
+  syncRoomsFunction: (arg0: any, arg1: any) => any[] | PromiseLike<any[]>,
+  activeChatJid?: string | null,
+  maxRetries = 10,
+  delayBetweenRetriesMs = 7500
+): Promise<ApiRoom[] | null> {
+  let attempts = 0;
+  let rooms = [];
+
+  while (attempts <= maxRetries) {
+    try {
+      rooms = await syncRoomsFunction(client, config);
+
+      if (activeChatJid && Array.isArray(rooms)) {
+        const isSelectedRoomPresent = isChatIdPresentInArray(
+          activeChatJid,
+          rooms
+        );
+        if (isSelectedRoomPresent) {
+          return rooms;
+        }
+      } else if (Array.isArray(rooms) && rooms.length > 0) {
+        return rooms;
+      }
+    } catch (error) {
+      console.error(`Error during attempt ${attempts + 1}:`, error);
+    }
+
+    attempts++;
+    if (attempts <= maxRetries) {
+      await delay(delayBetweenRetriesMs);
+    }
+  }
+
+  return null;
+}
+
+function delay(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/helpers/getTintedColor.ts

@@ -0,0 +1,28 @@
+export const getTintedColor = (hex: string, amount: number = 0.2) => {
+  if (hex.startsWith('#')) {
+    hex = hex.slice(1);
+  }
+
+  if (hex.length === 3) {
+    hex = hex
+      .split('')
+      .map((x) => x + x)
+      .join('');
+  }
+
+  const num = parseInt(hex, 16);
+  const r = (num >> 16) & 255;
+  const g = (num >> 8) & 255;
+  const b = num & 255;
+
+  const tintedR = Math.round(r + (255 - r) * amount);
+  const tintedG = Math.round(g + (255 - g) * amount);
+  const tintedB = Math.round(b + (255 - b) * amount);
+
+  const tintedHex = `#${((1 << 24) + (tintedR << 16) + (tintedG << 8) + tintedB)
+    .toString(16)
+    .slice(1)
+    .toUpperCase()}`;
+
+  return tintedHex;
+};

package/src/helpers/getUnnamedUsers.ts

@@ -0,0 +1,39 @@
+import { getUserByXmppUsername } from '../networking/api-requests/roomMembers.api';
+import { store } from '../roomStore';
+import { IMessage, IUser, RoomMember } from '../types/types';
+
+function getUniqueUsers(messages: IMessage[]): Set<IUser> {
+  const userMap = new Map<string, IUser>();
+
+  messages.forEach(({ user }) => {
+    if (!userMap.has(user.id)) {
+      userMap.set(user.id, user);
+    }
+  });
+
+  return new Set(userMap.values());
+}
+
+export const getUnnamedUsers = (messages: IMessage[]): IUser[] => {
+  const uniqueUsers = getUniqueUsers(messages);
+
+  return [...uniqueUsers].filter((user) =>
+    user?.name.toLowerCase().includes('deleted')
+  );
+};
+
+export const fixUnnamedArrayFromApi = async (
+  unnamedUsers: IUser[]
+): Promise<RoomMember[]> => {
+  const fetchedUsers = await Promise.all(
+    unnamedUsers.map(async (user) => {
+      const apiUser = await getUserByXmppUsername(
+        user.id,
+        store.getState().chatSettingStore.user.token
+      );
+      return apiUser;
+    })
+  );
+
+  return fetchedUsers;
+};

package/src/helpers/handleCopyClick.ts

@@ -0,0 +1,3 @@
+export const handleCopyClick = (string: string) => {
+  navigator.clipboard.writeText(string);
+};

package/src/helpers/handleXmppError.ts

@@ -0,0 +1,14 @@
+export function findError(node: Element): {
+  hasError: boolean;
+  errorText: string | null;
+} {
+  if (node.tagName === 'error') {
+    const text = node.textContent?.trim() || null;
+    return { hasError: true, errorText: text };
+  }
+  for (let i = 0; i < node.children.length; i++) {
+    const result = findError(node.children[i]);
+    if (result.hasError) {return result;}
+  }
+  return { hasError: false, errorText: null };
+}

package/src/helpers/hashcolor.ts

@@ -0,0 +1,34 @@
+import { sha256 } from 'js-sha256';
+
+export function nameToColor(name: string): {
+  backgroundColor: string;
+} | null {
+  const avatarColors = [
+    '#86d1ee',
+    '#badfff',
+    '#E2F4FB',
+    '#B1E1D9',
+    '#B8F1C4',
+    '#E0FFBE',
+    '#D3C2F1',
+    '#EEE6F9',
+    '#E7BDE6',
+    '#FEBDD1',
+    '#FFEBEE',
+    '#F1DCB6',
+    '#FFE0B6',
+    '#E8E4C9',
+    '#F5F2BC',
+  ];
+
+  if (!name) {
+    return { backgroundColor: 'transparent' };
+  }
+
+  return {
+    backgroundColor:
+      avatarColors[
+        parseInt(sha256(name).slice(0, 2), 16) % avatarColors.length
+      ],
+  };
+}