@ethora/chat-component-rn 26.4.1

package/src/helpers/resolveInitBeforeLoadUser.ts

@@ -0,0 +1,240 @@
+import http, { setBaseURL } from '../networking/apiClient';
+import { loginViaJwt } from '../networking/api-requests/auth.api';
+import { getMyUser } from '../networking/api-requests/user.api';
+import { IConfig, User } from '../types/types';
+import { store } from '../roomStore';
+import { setUser } from '../roomStore/chatSettingsSlice';
+import { walletToUsername } from './walletUsername';
+import { asyncLocalStorage } from '../hooks/useLocalStorage';
+import { localStorageConstants } from './constants/LOCAL_STORAGE';
+
+interface ResolveInitBeforeLoadUserOptions {
+  config?: IConfig;
+  signal?: AbortSignal;
+}
+
+interface HttpLikeError {
+  response?: { status?: number };
+  message?: string;
+}
+
+const getStatusCode = (error: unknown): number | null => {
+  const status = (error as HttpLikeError)?.response?.status;
+  return typeof status === 'number' ? status : null;
+};
+
+const isAuthError = (error: unknown): boolean => {
+  const code = getStatusCode(error);
+  return code === 401 || code === 403;
+};
+
+const isAbortError = (error: unknown): boolean => {
+  const message = (error as HttpLikeError)?.message || '';
+  return typeof message === 'string' && message.toLowerCase().includes('abort');
+};
+
+const hasXmppCredentials = (user?: Partial<User> | null): boolean =>
+  Boolean(
+    user?.xmppPassword &&
+      (user?.xmppUsername || user?.defaultWallet?.walletAddress)
+  );
+
+const normalizeUserForXmpp = (user?: User | null): User | null => {
+  if (!user) {return null;}
+  const normalizedXmppUsername =
+    user.xmppUsername || walletToUsername(user?.defaultWallet?.walletAddress || '');
+  return { ...user, xmppUsername: normalizedXmppUsername };
+};
+
+const refreshWithToken = async (refreshToken: string) => {
+  const response = await http.post(
+    '/users/login/refresh',
+    {},
+    { headers: { Authorization: refreshToken } }
+  );
+  return {
+    token: response?.data?.token || '',
+    refreshToken: response?.data?.refreshToken || refreshToken,
+  };
+};
+
+const mergeUsers = (base?: User | null, patch?: User | null): User | null => {
+  if (!base && !patch) {return null;}
+  return {
+    ...(base || ({} as User)),
+    ...(patch || ({} as User)),
+    defaultWallet: {
+      walletAddress:
+        patch?.defaultWallet?.walletAddress ||
+        base?.defaultWallet?.walletAddress ||
+        '',
+    },
+  } as User;
+};
+
+const tryHydrateViaMy = async (
+  candidate: User,
+  myEndpoint?: string,
+  signal?: AbortSignal
+): Promise<User | null> => {
+  if (signal?.aborted) {return null;}
+
+  const mergedCandidate = normalizeUserForXmpp(candidate);
+
+  if (!candidate?.token && !candidate?.refreshToken) {
+    return mergedCandidate;
+  }
+
+  let workingToken = candidate?.token || '';
+  let workingRefresh = candidate?.refreshToken || '';
+
+  const candidateWithCurrentTokens = (): User => ({
+    ...candidate,
+    token: workingToken || candidate.token,
+    refreshToken: workingRefresh || candidate.refreshToken,
+  });
+
+  const fallbackWithCreds = (): User | null => {
+    const normalized = normalizeUserForXmpp(candidateWithCurrentTokens());
+    if (normalized && hasXmppCredentials(normalized)) {return normalized;}
+    return null;
+  };
+
+  if (workingToken) {
+    try {
+      const myUser = await getMyUser({ token: workingToken, endpoint: myEndpoint });
+      const merged = normalizeUserForXmpp(mergeUsers(candidate, myUser));
+      if (merged) {
+        merged.token = workingToken || merged.token;
+        merged.refreshToken = workingRefresh || merged.refreshToken;
+      }
+      return merged;
+    } catch (error) {
+      if (signal?.aborted || isAbortError(error)) {return null;}
+      if (isAuthError(error)) {
+        if (!workingRefresh) {return fallbackWithCreds();}
+        // fall through to refresh path
+      } else {
+        const fallback = fallbackWithCreds();
+        return fallback || null;
+      }
+    }
+  }
+
+  if (!workingRefresh) {return mergedCandidate;}
+
+  try {
+    const refreshed = await refreshWithToken(workingRefresh);
+    workingToken = refreshed.token;
+    workingRefresh = refreshed.refreshToken;
+
+    try {
+      const myUser = await getMyUser({ token: workingToken, endpoint: myEndpoint });
+      const merged = normalizeUserForXmpp(
+        mergeUsers(candidateWithCurrentTokens(), myUser)
+      );
+      if (merged) {
+        merged.token = workingToken || merged.token;
+        merged.refreshToken = workingRefresh || merged.refreshToken;
+      }
+      return merged;
+    } catch (myError) {
+      if (signal?.aborted || isAbortError(myError)) {return null;}
+      const fallback = fallbackWithCreds();
+      if (fallback) {return fallback;}
+      if (isAuthError(myError)) {return null;}
+      throw myError;
+    }
+  } catch (error) {
+    if (signal?.aborted || isAbortError(error)) {return null;}
+    if (isAuthError(error)) {return null;}
+    throw error;
+  }
+};
+
+export const resolveInitBeforeLoadUser = async (
+  options?: ResolveInitBeforeLoadUserOptions
+): Promise<User | null> => {
+  const { config, signal } = options || {};
+  if (signal?.aborted) {return null;}
+
+  if (config?.baseUrl) {
+    setBaseURL(config.baseUrl, config.customAppToken);
+  }
+
+  const myEndpoint = config?.initBeforeLoadAuth?.myEndpoint || '/users/my';
+
+  // Priority 1: explicit userLogin
+  const explicitUser = config?.userLogin?.enabled ? config?.userLogin?.user : null;
+  if (explicitUser) {
+    const candidate = normalizeUserForXmpp(explicitUser);
+    if (candidate && hasXmppCredentials(candidate)) {return candidate;}
+
+    const hydrated = await tryHydrateViaMy(explicitUser, myEndpoint, signal).catch(
+      () => null
+    );
+    if (hydrated && hasXmppCredentials(hydrated)) {return hydrated;}
+    return null;
+  }
+
+  // Priority 2: customLogin function
+  if (config?.customLogin?.enabled && config?.customLogin?.loginFunction) {
+    try {
+      const customUser = await config.customLogin.loginFunction();
+      if (customUser) {
+        const candidate = normalizeUserForXmpp(customUser);
+        if (candidate && hasXmppCredentials(candidate)) {return candidate;}
+        const hydrated = await tryHydrateViaMy(customUser, myEndpoint, signal).catch(
+          () => null
+        );
+        if (hydrated && hasXmppCredentials(hydrated)) {return hydrated;}
+      }
+    } catch (error) {
+      if (signal?.aborted || isAbortError(error) || isAuthError(error)) {return null;}
+    }
+  }
+
+  // Priority 3: jwtLogin (legacy)
+  if (config?.jwtLogin?.enabled && config?.jwtLogin?.token) {
+    try {
+      const jwtUser = await loginViaJwt(config.jwtLogin.token);
+      const normalized = normalizeUserForXmpp(jwtUser);
+      if (normalized && hasXmppCredentials(normalized)) {return normalized;}
+    } catch (error) {
+      if (signal?.aborted || isAbortError(error) || isAuthError(error)) {return null;}
+      throw error;
+    }
+  }
+
+  // Priority 4: redux store user (in-memory hot path)
+  const currentUser = store.getState().chatSettingStore.user;
+  if (currentUser?.token || currentUser?.refreshToken || currentUser?.xmppPassword) {
+    const hydrated = await tryHydrateViaMy(currentUser as User, myEndpoint, signal).catch(
+      () => null
+    );
+    if (hydrated && hasXmppCredentials(hydrated)) {return hydrated;}
+  }
+
+  // Priority 5: persisted user in AsyncStorage
+  try {
+    const storedUser = await asyncLocalStorage<User>(localStorageConstants.ETHORA_USER).get();
+    if (storedUser && (storedUser.token || storedUser.refreshToken || storedUser.xmppPassword)) {
+      const hydrated = await tryHydrateViaMy(storedUser, myEndpoint, signal).catch(
+        () => null
+      );
+      if (hydrated && hasXmppCredentials(hydrated)) {return hydrated;}
+      await asyncLocalStorage(localStorageConstants.ETHORA_USER).remove();
+    }
+  } catch {
+    // ignore storage errors
+  }
+
+  return null;
+};
+
+export const applyResolvedUserToStore = (user?: User | null) => {
+  if (!user) {return;}
+  store.dispatch(setUser(user));
+};
+
+export default resolveInitBeforeLoadUser;

package/src/helpers/storeConsole.ts

@@ -0,0 +1,26 @@
+import { RootState, store } from '../roomStore';
+
+/**
+ * Return the current redux state. Mirrors web `useStoreConsole`.
+ * Attach to `globalThis.useStoreConsole` only when
+ * `config.useStoreConsoleEnabled === true`; clean up otherwise.
+ */
+export const useStoreConsole = (): RootState => store.getState();
+
+const g: any = globalThis as any;
+
+const refresh = () => {
+  try {
+    const config = store.getState().chatSettingStore?.config;
+    if (config?.useStoreConsoleEnabled === true) {
+      g.useStoreConsole = useStoreConsole;
+    } else if (g.useStoreConsole) {
+      delete g.useStoreConsole;
+    }
+  } catch {
+    // ignore — state may not be ready yet
+  }
+};
+
+refresh();
+store.subscribe(refresh);

package/src/helpers/transformTranslatations.ts

@@ -0,0 +1,16 @@
+interface Translation {
+  translatedText: string;
+  language: string;
+  languageName: string;
+}
+export interface TranslationObject {
+  [language: string]: Translation;
+}
+export const transformArrayToObject = (
+  array: Translation[]
+): TranslationObject => {
+  return array.reduce((acc, item) => {
+    acc[item.language] = item;
+    return acc;
+  }, {} as TranslationObject);
+};

package/src/helpers/updateMessagesTillLast.tsx

@@ -0,0 +1,104 @@
+import XmppClient from '../networking/xmppClient';
+import { store } from '../roomStore';
+import {
+  getLastMessageTimestamp,
+  insertUsers,
+  setRoomMessages,
+} from '../roomStore/roomsSlice';
+import { IMessage, IRoom } from '../types/types';
+import { checkUniqueUsers } from './checkUniqueUsers';
+
+export const updateMessagesTillLast = async (
+  rooms: {
+    [jid: string]: IRoom;
+  },
+  client: XmppClient,
+  batchSize = 5,
+  maxFetchAttempts = 4,
+  messagesPerFetch = 5
+) => {
+  const roomEntries = Object.keys(rooms);
+  if (roomEntries.length > 0) {
+    let processedIndex = 0;
+
+    while (processedIndex < roomEntries.length) {
+      const currentBatch = roomEntries.slice(
+        processedIndex,
+        processedIndex + batchSize
+      );
+
+      const lastTimestampsByJid = currentBatch.reduce(
+        (acc, current: string) => {
+          acc[current] = getLastMessageTimestamp(
+            store.getState().rooms,
+            current
+          );
+          return acc;
+        },
+        {}
+      );
+
+      await Promise.all(
+        currentBatch.map(async (jid, index) => {
+          try {
+            if (index > 0) {await new Promise((res) => setTimeout(res, 125));}
+
+            let counter = 0;
+            let isMessageFound = false;
+            let currentJidNewMessages: IMessage[] = [];
+
+            const lastCachedMessagesTimeStamp = lastTimestampsByJid[jid];
+            if (!lastCachedMessagesTimeStamp) {return;}
+
+            while (!isMessageFound && counter < maxFetchAttempts) {
+              const lastMessageId =
+                counter > 0 ? currentJidNewMessages[0]?.id : undefined;
+
+              const fetchedMessages = await client.getHistoryStanza(
+                jid,
+                messagesPerFetch,
+                Number(lastMessageId)
+              );
+
+              if (!fetchedMessages.length) {break;}
+
+              counter++;
+
+              currentJidNewMessages = [
+                ...fetchedMessages,
+                ...currentJidNewMessages,
+              ];
+
+              isMessageFound = currentJidNewMessages.some(
+                (message: IMessage) =>
+                  Number(message.id) === Number(lastCachedMessagesTimeStamp)
+              );
+
+              if (!isMessageFound && !(counter <= maxFetchAttempts - 1)) {
+                const fixedUsers = await checkUniqueUsers(
+                  currentJidNewMessages
+                );
+                if (fixedUsers && fixedUsers.length > 0) {
+                  store.dispatch(insertUsers({ newUsers: fixedUsers }));
+                }
+
+                store.dispatch(
+                  setRoomMessages({
+                    roomJID: jid,
+                    messages: currentJidNewMessages,
+                  })
+                );
+              }
+            }
+          } catch (error) {
+            console.error(`Error processing room ${jid}:`, error);
+          }
+        })
+      );
+
+      processedIndex += batchSize;
+    }
+  }
+
+  console.log('All rooms processed');
+};

package/src/helpers/updatedChatLastTimestamps.ts

@@ -0,0 +1,29 @@
+import { setLastViewedTimestamp } from '../roomStore/roomsSlice';
+
+export const updatedChatLastTimestamps = (
+  roomTimestampObject: [jid: string, timestamp: string],
+  dispatch: any
+) => {
+  if (!roomTimestampObject) {return;}
+
+  if (roomTimestampObject && Object.keys(roomTimestampObject).length > 0) {
+    const roomTimestampArray = Object.entries(roomTimestampObject).map(
+      ([jid, timestamp]) => ({
+        jid,
+        timestamp,
+      })
+    );
+    console.log('getting roomTimestampArray', roomTimestampArray);
+
+    roomTimestampArray.forEach(({ jid, timestamp }) => {
+      if (jid) {
+        dispatch(
+          setLastViewedTimestamp({
+            chatJID: jid,
+            timestamp: Number(timestamp || 0),
+          })
+        );
+      }
+    });
+  }
+};

package/src/helpers/validator.ts

@@ -0,0 +1,20 @@
+import { IMessage } from '../types/types';
+
+export const validateMessages = (messages: IMessage[]): boolean => {
+  const requiredAttributes: (keyof IMessage)[] = ['id', 'user', 'date', 'body'];
+  let isValid = true;
+  messages.forEach((message, index) => {
+    const missingAttributes = requiredAttributes.filter(
+      (attr) => !(attr in message)
+    );
+    if (missingAttributes.length > 0) {
+      console.error(
+        `Message at index ${index} is missing attributes: ${missingAttributes.join(
+          ', '
+        )}`
+      );
+      isValid = false;
+    }
+  });
+  return isValid;
+};

package/src/helpers/walletUsername.ts

@@ -0,0 +1,12 @@
+export function walletToUsername(string: string) {
+  if (string) {
+    return string.replaceAll(/([A-Z])/g, '_$1').toLowerCase();
+  }
+  return '';
+}
+
+export function usernameToWallet(string: string) {
+  return string.replaceAll(/_([a-z])/gm, (m1: string, m2: string) => {
+    return m2.toUpperCase();
+  });
+}

package/src/hooks/hooks.ts

@@ -0,0 +1,6 @@
+import { useDispatch, useSelector } from 'react-redux';
+import type { TypedUseSelectorHook } from 'react-redux';
+import type { RootState, AppDispatch } from '../roomStore';
+
+export const useAppDispatch: () => AppDispatch = useDispatch;
+export const useAppSelector: TypedUseSelectorHook<RootState> = useSelector;

package/src/hooks/useChatSettingState.tsx

@@ -0,0 +1,38 @@
+import { useSelector } from 'react-redux';
+import { RootState } from '../roomStore';
+
+export const useChatSettingState = () => {
+  const user = useSelector((state: RootState) => state.chatSettingStore.user);
+  const activeFile = useSelector(
+    (state: RootState) => state.chatSettingStore.activeFile
+  );
+  const activeModal = useSelector(
+    (state: RootState) => state.chatSettingStore.activeModal
+  );
+  const config = useSelector(
+    (state: RootState) => state.chatSettingStore.config
+  );
+  const deleteModal = useSelector(
+    (state: RootState) => state.chatSettingStore.deleteModal
+  );
+  const selectedUser = useSelector(
+    (state: RootState) => state.chatSettingStore.selectedUser
+  );
+  const langSource = useSelector(
+    (state: RootState) => state.chatSettingStore.langSource
+  );
+  const client = useSelector(
+    (state: RootState) => state.chatSettingStore.client
+  );
+
+  return {
+    user,
+    activeFile,
+    activeModal,
+    config,
+    deleteModal,
+    selectedUser,
+    langSource,
+    client,
+  };
+};