@ethora/chat-component-rn 26.4.1

package/src/context/xmppProvider.tsx

@@ -0,0 +1,364 @@
+import React, {
+  ReactNode,
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useRef,
+  useState,
+} from 'react';
+import { DeviceEventEmitter } from 'react-native';
+import XmppClient from '../networking/xmppClient';
+import {
+  IConfig,
+  ProviderBootstrapStatus,
+  User,
+  xmppSettingsInterface,
+} from '../types/types';
+import {
+  buildXmppClientKey,
+  getReusableXmppClientByKey,
+  isXmppClientReusable,
+  setGlobalXmppClient,
+  withXmppClientInitLock,
+} from '../utils/clientRegistry';
+import {
+  applyResolvedUserToStore,
+  resolveInitBeforeLoadUser,
+} from '../helpers/resolveInitBeforeLoadUser';
+import { ensureScopedChatCache } from '../helpers/ensureScopedChatCache';
+import { getRooms as prefetchRoomsViaRest } from '../networking/api-requests/rooms.api';
+import { store } from '../roomStore';
+import { logout, setStoreClient } from '../roomStore/chatSettingsSlice';
+import { setLogoutState } from '../roomStore/roomsSlice';
+import { runHistoryPreloadScheduler } from '../helpers/historyPreloadScheduler';
+import { asyncLocalStorage } from '../hooks/useLocalStorage';
+import { localStorageConstants } from '../helpers/constants/LOCAL_STORAGE';
+import { clearPersistedState } from '../roomStore/persistence';
+import { pushLog as devPushLog } from '../utils/devLogger';
+
+interface InitMode {
+  current: 'provider' | 'chat';
+}
+
+interface XmppContextType {
+  client: XmppClient | null;
+  providerBootstrapStatus: ProviderBootstrapStatus;
+  initMode: InitMode['current'];
+  setClient: (client: XmppClient | null) => void;
+  initializeClient: (
+    username: string,
+    password: string,
+    xmppSettings?: xmppSettingsInterface
+  ) => Promise<XmppClient>;
+}
+
+const XmppContext = createContext<XmppContextType | null>(null);
+
+interface XmppProviderProps {
+  children: ReactNode;
+  config?: IConfig;
+}
+
+const LOGOUT_EVENT = 'ethora-xmpp-logout';
+
+export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config }) => {
+  const [client, setClient] = useState<XmppClient | null>(null);
+  const [providerBootstrapStatus, setProviderBootstrapStatus] =
+    useState<ProviderBootstrapStatus>('idle');
+  const [reconnectAttempts, setReconnectAttempts] = useState(0);
+
+  // Track which "init mode" this provider runs in. When config.initBeforeLoad
+  // is true, the provider owns bootstrap and ChatWrapper just waits.
+  const initMode: InitMode['current'] = config?.initBeforeLoad ? 'provider' : 'chat';
+
+  const lastCredsRef = useRef<{ username: string; password: string; settings?: xmppSettingsInterface } | null>(null);
+  const completedBootstrapKeyRef = useRef<string>('');
+  const inflightBootstrapKeyRef = useRef<string>('');
+
+  const initializeClient = useCallback(
+    async (
+      username: string,
+      password: string,
+      xmppSettings?: xmppSettingsInterface
+    ): Promise<XmppClient> => {
+      const settings = xmppSettings || config?.xmppSettings;
+      const key = buildXmppClientKey(username, settings);
+
+      // 1. Reuse global singleton if it's the same key.
+      const reusable = getReusableXmppClientByKey(key);
+      if (reusable) {
+        setClient(reusable);
+        lastCredsRef.current = { username, password, settings };
+        return reusable;
+      }
+
+      // 2. Reuse current provider client if still usable.
+      if (client && isXmppClientReusable(client)) {
+        lastCredsRef.current = { username, password, settings };
+        return client;
+      }
+
+      // 3. Otherwise create a new client under the init lock to dedup
+      //    concurrent calls for the same key.
+      const created = await withXmppClientInitLock(key, async () => {
+        const newClient = new XmppClient(username, password, settings);
+        setGlobalXmppClient(newClient, key);
+        await newClient.waitForOnline().catch((err) => {
+          console.error('Error waiting for xmpp online:', err);
+          throw err;
+        });
+        return newClient;
+      });
+
+      setClient(created);
+      lastCredsRef.current = { username, password, settings };
+      setReconnectAttempts(0);
+      return created;
+    },
+    [client, config?.xmppSettings]
+  );
+
+  // -----------------------------------------------------------
+  // initBeforeLoad — eager auth + xmpp connect at provider mount
+  // -----------------------------------------------------------
+  useEffect(() => {
+    if (!config?.initBeforeLoad) {
+      setProviderBootstrapStatus('idle');
+      return;
+    }
+
+    const abortController = new AbortController();
+    let cancelled = false;
+
+    const run = async () => {
+      // Stable bootstrap key — re-run only when these change.
+      const explicitUser = config?.userLogin?.enabled ? config?.userLogin?.user : null;
+      const key = [
+        config?.appId || '',
+        config?.baseUrl || '',
+        explicitUser?.defaultWallet?.walletAddress || '',
+        explicitUser?.xmppUsername || '',
+        explicitUser?.token ? '1' : '0',
+        config?.jwtLogin?.enabled ? config?.jwtLogin?.token || '' : '',
+        config?.xmppSettings?.devServer || '',
+      ].join('|');
+
+      if (completedBootstrapKeyRef.current === key) {
+        devPushLog('rn', 'initBeforeLoad: already completed (same key) — skip');
+        return;
+      }
+      if (inflightBootstrapKeyRef.current === key) {
+        devPushLog('rn', 'initBeforeLoad: in-flight (same key) — skip');
+        return;
+      }
+      inflightBootstrapKeyRef.current = key;
+      setProviderBootstrapStatus('running');
+      devPushLog('rn', 'initBeforeLoad: running', {
+        appId: config?.appId,
+        baseUrl: config?.baseUrl,
+        mode:
+          config?.jwtLogin?.enabled ? 'jwt' :
+          config?.userLogin?.enabled ? 'userLogin' :
+          config?.customLogin?.enabled ? 'customLogin' : 'fallback',
+      });
+
+      try {
+        if (config?.clearStoreBeforeInit) {
+          devPushLog('rn', 'initBeforeLoad: clearStoreBeforeInit');
+          store.dispatch(setLogoutState());
+          store.dispatch(logout());
+          await asyncLocalStorage(localStorageConstants.ETHORA_USER).remove().catch(() => undefined);
+        }
+
+        await ensureScopedChatCache(config);
+        devPushLog('rn', 'initBeforeLoad: scope ok, resolving user…');
+
+        const resolved: User | null = await resolveInitBeforeLoadUser({
+          config,
+          signal: abortController.signal,
+        });
+        if (cancelled) {return;}
+
+        if (!resolved || !resolved.xmppPassword || !resolved.xmppUsername) {
+          devPushLog('error', 'initBeforeLoad: user resolve failed', {
+            hasResolved: !!resolved,
+            xmppUsername: resolved?.xmppUsername,
+            xmppPasswordPresent: !!resolved?.xmppPassword,
+          });
+          setProviderBootstrapStatus('failed');
+          inflightBootstrapKeyRef.current = '';
+          return;
+        }
+
+        devPushLog('rn', `initBeforeLoad: user resolved (${resolved.xmppUsername})`);
+        applyResolvedUserToStore(resolved);
+
+        prefetchRoomsViaRest().catch(() => undefined);
+
+        const c = await initializeClient(
+          resolved.xmppUsername!,
+          resolved.xmppPassword,
+          config?.xmppSettings
+        );
+        if (cancelled) {return;}
+        devPushLog('rn', 'initBeforeLoad: xmpp client created, waiting online…');
+
+        await c.waitForOnline();
+        if (cancelled) {return;}
+        devPushLog('xmpp', 'initBeforeLoad: xmpp online');
+
+        try {
+          await c.getRoomsStanza();
+          devPushLog('xmpp', 'initBeforeLoad: getRoomsStanza ok');
+        } catch (e) {
+          devPushLog('warn', 'initBeforeLoad: getRoomsStanza failed', e);
+        }
+        try {
+          await c.getChatsPrivateStoreRequestStanza();
+          devPushLog('xmpp', 'initBeforeLoad: privateStore ok');
+        } catch (e) {
+          devPushLog('warn', 'initBeforeLoad: privateStore failed', e);
+        }
+
+        store.dispatch(setStoreClient(c));
+        completedBootstrapKeyRef.current = key;
+        inflightBootstrapKeyRef.current = '';
+        setProviderBootstrapStatus('ready');
+        devPushLog('rn', 'initBeforeLoad: READY');
+
+        // Background-prefetch history for every room (fire-and-forget).
+        const qos = config?.historyQoS;
+        const activeRoomJID = store.getState().rooms.activeRoomJID || null;
+        const defaultRoomJids =
+          (config?.defaultRooms as any[])?.map((r) =>
+            typeof r === 'string' ? r : r?.jid
+          ).filter(Boolean) || [];
+        runHistoryPreloadScheduler({
+          client: c,
+          signal: abortController.signal,
+          selectedRoomJid: activeRoomJID,
+          defaultRoomJids,
+          concurrency: qos?.stagedPreloadConcurrency,
+          pageSize: qos?.stagedPreloadFirstPassSize,
+          roomLimit: qos?.preloadTopKRooms,
+        }).catch((err) => console.warn('History preload scheduler failed', err));
+      } catch (error: any) {
+        if (cancelled) {return;}
+        devPushLog('error', 'initBeforeLoad: bootstrap threw', {
+          message: error?.message,
+          status: error?.response?.status,
+          data: error?.response?.data,
+        });
+        inflightBootstrapKeyRef.current = '';
+        setProviderBootstrapStatus('failed');
+      }
+    };
+
+    run();
+
+    return () => {
+      cancelled = true;
+      abortController.abort();
+      // Re-running this effect (deps changed or unmount) must release the
+      // in-flight bootstrap key so the next render isn't permanently
+      // short-circuited by the early `inflightBootstrapKeyRef === key`
+      // check. Without this, a `setClient` mid-bootstrap that re-renders
+      // the provider strands the bootstrap in `running`.
+      inflightBootstrapKeyRef.current = '';
+    };
+    // NOTE: `initializeClient` is intentionally NOT in the dep array.
+    // It's a `useCallback` that depends on `client` state; including it
+    // would force the effect to re-run every time `setClient` fires
+    // (which happens DURING bootstrap), causing a cancel/re-init storm.
+    // The function is still reachable through closure; its identity drift
+    // is irrelevant to bootstrap semantics.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [
+    config?.initBeforeLoad,
+    config?.appId,
+    config?.baseUrl,
+    config?.userLogin?.enabled,
+    config?.userLogin?.user?.defaultWallet?.walletAddress,
+    config?.userLogin?.user?.xmppUsername,
+    config?.userLogin?.user?.token,
+    config?.jwtLogin?.enabled,
+    config?.jwtLogin?.token,
+    config?.xmppSettings?.devServer,
+  ]);
+
+  // -----------------------------------------------------------
+  // Reconnect / reinit on disconnect
+  // -----------------------------------------------------------
+  useEffect(() => {
+    if (!client) {return;}
+    if (client.status !== 'offline') {return;}
+
+    if (reconnectAttempts < 3) {
+      console.log(`xmpp reconnect attempt ${reconnectAttempts + 1}`);
+      client.scheduleReconnect();
+      setReconnectAttempts((prev) => prev + 1);
+      return;
+    }
+
+    // After 3 failed reconnects, drop the client and re-init from scratch.
+    if (lastCredsRef.current) {
+      const { username, password, settings } = lastCredsRef.current;
+      setGlobalXmppClient(null);
+      setClient(null);
+      initializeClient(username, password, settings).catch((err) =>
+        console.error('Full reinit failed:', err)
+      );
+    }
+  }, [client, client?.status, reconnectAttempts, initializeClient]);
+
+  // -----------------------------------------------------------
+  // Logout event listener (RN equivalent of window event)
+  // -----------------------------------------------------------
+  useEffect(() => {
+    const sub = DeviceEventEmitter.addListener(LOGOUT_EVENT, async () => {
+      try {
+        if (client) {
+          await client.disconnect({ suppressReconnect: true });
+        }
+      } catch (e) {
+        console.warn('Logout disconnect failed', e);
+      }
+      setGlobalXmppClient(null);
+      setClient(null);
+      completedBootstrapKeyRef.current = '';
+      inflightBootstrapKeyRef.current = '';
+      setReconnectAttempts(0);
+      setProviderBootstrapStatus('idle');
+      await clearPersistedState();
+    });
+    return () => sub.remove();
+  }, [client]);
+
+  return (
+    <XmppContext.Provider
+      value={{
+        client,
+        providerBootstrapStatus,
+        initMode,
+        initializeClient,
+        setClient,
+      }}
+    >
+      {children}
+    </XmppContext.Provider>
+  );
+};
+
+export const useXmppClient = () => {
+  const context = useContext(XmppContext);
+  if (!context) {
+    throw new Error('useXmppClient must be used within an XmppProvider');
+  }
+  return context;
+};
+
+/** Trigger a global xmpp logout — mirrors the web `ethora-xmpp-logout` event. */
+export function emitXmppLogout() {
+  DeviceEventEmitter.emit(LOGOUT_EVENT);
+}

package/src/helpers/block_scroll.ts

@@ -0,0 +1,95 @@
+type TouchEventCallback = (e: TouchEvent) => void;
+type WheelEventCallback = (e: WheelEvent) => void;
+
+interface ElemEvents {
+  on_touchstart: TouchEventCallback;
+  on_touchmove: TouchEventCallback;
+  on_wheel: WheelEventCallback;
+}
+
+//  ---------------------------------------------------------------------------------------------------------------  //
+
+const ATTR_NAME = 'data-scroll-id';
+
+const events: {
+  [key: string]: ElemEvents;
+} = {};
+
+//  ---------------------------------------------------------------------------------------------------------------  //
+
+export function blockScrollEvent(elem: HTMLElement) {
+  let id = elem.getAttribute(ATTR_NAME);
+
+  if (id) {
+    return;
+  }
+  id = 'scroll-id-' + Date.now();
+  elem.setAttribute(ATTR_NAME, id);
+
+  let _client_y: number;
+
+  const elem_events = {
+    on_touchstart: function (e: TouchEvent) {
+      if (e.targetTouches.length === 1) {
+        _client_y = e.targetTouches[0].clientY;
+      }
+    },
+
+    on_touchmove: function (e: TouchEvent) {
+      if (e.targetTouches.length !== 1) {
+        return;
+      }
+
+      const client_y = e.targetTouches[0].clientY - _client_y;
+      if (elem.scrollTop === 0 && client_y > 0) {
+        e.preventDefault();
+      }
+      if (
+        elem.scrollHeight - elem.scrollTop <= elem.clientHeight &&
+        client_y < 0
+      ) {
+        e.preventDefault();
+      }
+    },
+
+    on_wheel: function (e: WheelEvent) {
+      const delta = e.deltaY || e.detail;
+
+      if (
+        (delta < 0 && elem.scrollTop === 0) ||
+        (delta > 0 &&
+          elem.scrollHeight - elem.clientHeight - elem.scrollTop <= 1)
+      ) {
+        e.preventDefault();
+      }
+    },
+  };
+
+  elem.addEventListener('touchstart', elem_events.on_touchstart);
+  elem.addEventListener('touchmove', elem_events.on_touchmove);
+  elem.addEventListener('wheel', elem_events.on_wheel);
+
+  events[id] = elem_events;
+}
+
+//  ---------------------------------------------------------------------------------------------------------------  //
+
+export function unblock_scroll(elem: HTMLElement) {
+  console.log('unblock_scroll');
+  const id = elem.getAttribute(ATTR_NAME);
+  if (!id) {
+    return;
+  }
+
+  elem.removeAttribute(ATTR_NAME);
+
+  const elem_events = events[id];
+
+  if (elem_events) {
+    elem.removeEventListener('touchstart', elem_events.on_touchstart);
+    elem.removeEventListener('touchmove', elem_events.on_touchmove);
+    elem.removeEventListener('wheel', elem_events.on_wheel);
+  }
+
+  delete events[id];
+}

package/src/helpers/chatAutoEnterer.ts

@@ -0,0 +1,46 @@
+/** @format */
+
+import { AppDispatch } from '../roomStore';
+import { setCurrentRoom } from '../roomStore/roomsSlice';
+
+interface XmppConfig {
+  xmppSettings?: {
+    conference?: string;
+  };
+}
+
+interface SelectRoomArgs {
+  roomJID?: string;
+  wasAutoSelected: boolean;
+  config: XmppConfig;
+  dispatch: AppDispatch;
+}
+
+export const chatAutoEnterer = ({
+  roomJID,
+  wasAutoSelected,
+  config,
+  dispatch,
+}: SelectRoomArgs): void => {
+  console.log('🟡 chatAutoEnterer: Called', { roomJID, wasAutoSelected });
+
+  if (roomJID) {
+    // If roomJID is already a full JID, use it directly
+    // Otherwise, construct it from chatId if needed
+    const conferenceDomain = config.xmppSettings?.conference ?? '';
+    let finalRoomJID = roomJID;
+
+    if (!roomJID.includes('@') && conferenceDomain) {
+      finalRoomJID = `${roomJID}@${conferenceDomain}`;
+      console.log('🟡 chatAutoEnterer: Constructed roomJID', finalRoomJID);
+    }
+
+    console.log('🟡 chatAutoEnterer: Setting current room', finalRoomJID);
+    dispatch(setCurrentRoom({ roomJID: finalRoomJID }));
+    return;
+  }
+
+  console.log('🟡 chatAutoEnterer: No roomJID provided');
+  // In React Native, we don't have window.location.search
+  // The roomJID should be passed directly via props/config
+};

package/src/helpers/checkUniqueUsers.tsx

@@ -0,0 +1,31 @@
+import { IMessage, RoomMember } from '../types/types';
+import { store } from '../roomStore';
+import { fixUnnamedArrayFromApi, getUnnamedUsers } from './getUnnamedUsers';
+import { getUserByXmppUsername } from '../networking/api-requests/roomMembers.api';
+
+export const checkUniqueUsers = (messages: IMessage[]) => {
+  const unnamedUsers = getUnnamedUsers(messages);
+
+  if (unnamedUsers.length > 0) {
+    const getApiUsers = async () => {
+      const fixedUsers = await fixUnnamedArrayFromApi(unnamedUsers);
+      return fixedUsers;
+    };
+    const newUsers = getApiUsers();
+    return newUsers;
+  }
+};
+
+export const checkSingleUser = async (
+  usersSet: Record<string, RoomMember>,
+  xmppUsername: string
+) => {
+  if (usersSet[xmppUsername]) {return;}
+
+  const fixedUser = await getUserByXmppUsername(
+    xmppUsername,
+    store.getState().chatSettingStore.user.token
+  );
+
+  return fixedUser;
+};

package/src/helpers/constants/CHAT_TYPES.ts

@@ -0,0 +1,6 @@
+import { ChatAccessOption } from '../../types/types';
+
+export const CHAT_TYPES: ChatAccessOption[] = [
+  { name: 'Public', id: 'public' },
+  { name: 'Members-only', id: 'group' },
+];

package/src/helpers/constants/LANGUAGE_OPTIONS.ts

@@ -0,0 +1,14 @@
+import { Iso639_1Codes } from '../../types/types';
+
+type LanguageOption = {
+  name: string;
+  id: Iso639_1Codes;
+};
+
+export const LANGUAGE_OPTIONS: LanguageOption[] = [
+  { name: 'English', id: 'en' },
+  { name: 'Spanish', id: 'es' },
+  { name: 'Portuguese', id: 'pt' },
+  { name: 'Haitian Creole', id: 'ht' },
+  { name: 'Chinese', id: 'zh' },
+];

package/src/helpers/constants/LOCAL_STORAGE.ts

@@ -0,0 +1,3 @@
+export const localStorageConstants = {
+  ETHORA_USER: '@ethora/chat-component-user',
+};

package/src/helpers/constants/MESSAGE_INTERACTIONS.ts

@@ -0,0 +1,29 @@
+import {
+  CopyIcon,
+  DeleteIcon,
+  EditIcon,
+  ReplyIcon,
+  ReportIcon,
+  SendCoinIcon,
+} from '../../assets/icons';
+import { SendItemIcon } from '../../assets/images';
+
+export const MESSAGE_INTERACTIONS = {
+  SEND_COINS: 'Send coins',
+  SEND_ITEM: 'Send item',
+  REPLY: 'Reply',
+  COPY: 'Copy',
+  EDIT: 'Edit',
+  DELETE: 'Delete',
+  REPORT: 'Report',
+};
+
+export const MESSAGE_INTERACTIONS_ICONS = {
+  SEND_COINS: SendCoinIcon,
+  SEND_ITEM: SendItemIcon,
+  REPLY: ReplyIcon,
+  COPY: CopyIcon,
+  EDIT: EditIcon,
+  DELETE: DeleteIcon,
+  REPORT: ReportIcon,
+};

package/src/helpers/constants/MODAL_TYPES.ts

@@ -0,0 +1,57 @@
+import ChatProfileModal from '../../components/Modals/ChatProfileModal/ChatProfileModal';
+import FilePreviewModal from '../../components/Modals/FilePreviewModal/FilePreviewModal';
+import NewChatModal from '../../components/Modals/NewChatModal/NewChatModal';
+import BlockedUsersModal from '../../components/Modals/SettingsModals/BlockedUsers/BlockedUsersModal';
+import DocumentSharesModal from '../../components/Modals/SettingsModals/DocumentShares/DocumentSharesModal';
+import ManageDataModal from '../../components/Modals/SettingsModals/ManageDataModal/ManageDataModal';
+import ProfileSharesModal from '../../components/Modals/SettingsModals/ProfileShares/ProfileShares';
+import ReferralsModal from '../../components/Modals/SettingsModals/Referrals/Referrals';
+import VisibilityModal from '../../components/Modals/SettingsModals/Visibility/VisibilityModal';
+import UserProfileModal from '../../components/Modals/UserProfileModal/UserProfileModal';
+import UserSettingsModal from '../../components/Modals/UserSettingsModal/UserSettingsModal';
+
+export const MODAL_TYPES = {
+  SETTINGS: 'settings',
+  PROFILE: 'profile',
+  CHAT_PROFILE: 'chatprofile',
+  MANAGE_DATA: 'managedata',
+  VISIBILITY: 'visibility',
+
+  PROFILE_SHARES: 'profile_shares',
+  DOCUMENT_SHARES: 'document_shares',
+  BLOCKED_USERS: 'blocked_users',
+
+  REFERRALS: 'referrals',
+
+  FILE_PREVIEW: 'file_preview',
+
+  NEW_CHAT: 'new_chat',
+
+  // SETTINGS: 'Settings',
+  // PROFILE: 'Profile',
+  // CHAT_PROFILE: 'Chat Profile',
+
+  // MANAGE_DATA: 'Manage Data',
+  // VISIBILITY: 'Visiblility',
+  // PROFILE_SHARES: 'Profile Shares',
+  // DOCUMENT_SHARES: 'Document Shares',
+  // BLOCKED_USERS: 'Blocked Users',
+  // REFERRALS: 'Referrals',
+};
+
+export const MODAL_COMPONENTS: Record<
+  string,
+  React.FC<{ handleCloseModal: () => void }>
+> = {
+  [MODAL_TYPES.SETTINGS]: UserSettingsModal,
+  [MODAL_TYPES.NEW_CHAT]: NewChatModal,
+  [MODAL_TYPES.PROFILE]: UserProfileModal,
+  [MODAL_TYPES.CHAT_PROFILE]: ChatProfileModal,
+  [MODAL_TYPES.MANAGE_DATA]: ManageDataModal,
+  [MODAL_TYPES.VISIBILITY]: VisibilityModal,
+  [MODAL_TYPES.REFERRALS]: ReferralsModal,
+  [MODAL_TYPES.DOCUMENT_SHARES]: DocumentSharesModal,
+  [MODAL_TYPES.PROFILE_SHARES]: ProfileSharesModal,
+  [MODAL_TYPES.BLOCKED_USERS]: BlockedUsersModal,
+  [MODAL_TYPES.FILE_PREVIEW]: FilePreviewModal,
+};

package/src/helpers/constants/PLATFORM_CONSTANTS.ts

@@ -0,0 +1,3 @@
+export const CONFERENCE_DOMAIN = '@conference.xmpp.ethoradev.com';
+export const CHAT_DOMAIN = '@xmpp.ethoradev.com';
+export const QRCODE_URL = 'https://beta.ethora.com/app/chat/?chatId=';

package/src/helpers/createMainMessageForThread.ts

@@ -0,0 +1,23 @@
+import { IMessage } from '../types/types';
+
+export const createMainMessageForThread = (message: IMessage): string => {
+  const data = {
+    text: message.body,
+    id: message.id,
+    userName: message.user.name,
+    createdAt: message.date,
+    imageLocation: message.location,
+    imagePreview: message.locationPreview,
+    mimeType: message.mimetype,
+    size: '',
+    duration: '',
+    waveForm: '',
+    attachmentId: '',
+    wrappable: '',
+    nftActionType: '',
+    contractAddress: '',
+    roomJid: message.roomJid,
+    nftId: '',
+  };
+  return JSON.stringify(data);
+};