stream-chat-react-native-core 9.10.1-beta.2 → 10.0.0-rc.1

package/src/components/ChannelList/hooks/listeners/__tests__/useChannelUpdated.test.tsx

@@ -1,87 +0,0 @@
-import React, { useState } from 'react';
-import { Image, Text } from 'react-native';
-
-import { act, render, waitFor } from '@testing-library/react-native';
-import type { Channel, ChannelResponse, Event, StreamChat } from 'stream-chat';
-
-import type { ChatContextValue } from '../../../../../contexts/chatContext/ChatContext';
-import { ChatContext, useChannelUpdated } from '../../../../../index';
-
-describe('useChannelUpdated', () => {
-  it("defaults to the channels own_capabilities if the event doesn't include it", async () => {
-    let eventHanler: (event: Event) => void;
-    const mockChannel = {
-      cid: 'channeltype:123abc',
-      data: {
-        own_capabilities: {
-          send_messages: true,
-        },
-      },
-    } as unknown as Channel;
-
-    const mockEvent = {
-      channel: {
-        cid: mockChannel.cid,
-      } as ChannelResponse,
-      type: 'channel.updated' as Event['type'],
-    };
-
-    const mockClient = {
-      off: jest.fn(),
-      on: jest.fn().mockImplementation((_eventName: string, handler: (event: Event) => void) => {
-        eventHanler = handler;
-      }),
-    } as unknown as StreamChat;
-
-    const TestComponent = () => {
-      const [channels, setChannels] = useState<Channel[]>([mockChannel]);
-
-      useChannelUpdated({ setChannels });
-
-      if (
-        channels &&
-        channels[0].data?.own_capabilities &&
-        Object.keys(
-          channels[0].data?.own_capabilities as unknown as { [key: string]: boolean },
-        ).includes('send_messages')
-      ) {
-        return <Text>Send messages enabled</Text>;
-      }
-
-      return <Text>Send messages NOT enabled</Text>;
-    };
-
-    const { getByText } = await waitFor(() =>
-      render(
-        <ChatContext.Provider
-          value={
-            {
-              appSettings: null,
-              client: mockClient,
-              connectionRecovering: false,
-              enableOfflineSupport: false,
-              ImageComponent: Image,
-              isOnline: true,
-              mutedUsers: [],
-              setActiveChannel: () => null,
-            } as unknown as ChatContextValue
-          }
-        >
-          <TestComponent />
-        </ChatContext.Provider>,
-      ),
-    );
-
-    await waitFor(() => {
-      expect(getByText('Send messages enabled')).toBeTruthy();
-    });
-
-    act(() => {
-      eventHanler(mockEvent);
-    });
-
-    await waitFor(() => {
-      expect(getByText('Send messages enabled')).toBeTruthy();
-    });
-  });
-});

package/src/components/ChannelList/hooks/listeners/useChannelUpdated.ts

@@ -1,49 +0,0 @@
-import React, { useEffect } from 'react';
-
-import type { Channel, Event } from 'stream-chat';
-
-import { useChatContext } from '../../../../contexts/chatContext/ChatContext';
-
-type Parameters = {
-  setChannels: React.Dispatch<React.SetStateAction<Channel[]>>;
-  onChannelUpdated?: (
-    setChannels: React.Dispatch<React.SetStateAction<Channel[]>>,
-    event: Event,
-  ) => void;
-};
-
-export const useChannelUpdated = ({ onChannelUpdated, setChannels }: Parameters) => {
-  const { client } = useChatContext();
-
-  useEffect(() => {
-    const handleEvent = (event: Event) => {
-      if (typeof onChannelUpdated === 'function') {
-        onChannelUpdated(setChannels, event);
-      } else {
-        setChannels((channels) => {
-          if (!channels) {
-            return channels;
-          }
-
-          const index = channels.findIndex(
-            (channel) => channel.cid === (event.cid || event.channel?.cid),
-          );
-          if (index >= 0 && event.channel) {
-            channels[index].data = {
-              ...event.channel,
-              hidden: event.channel?.hidden ?? channels[index].data?.hidden,
-              own_capabilities:
-                event.channel?.own_capabilities ?? channels[index].data?.own_capabilities,
-            };
-          }
-
-          return [...channels];
-        });
-      }
-    };
-
-    const listener = client?.on('channel.updated', handleEvent);
-    return () => listener?.unsubscribe();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-};

package/src/components/ChannelList/hooks/utils/index.ts

@@ -1,125 +0,0 @@
-import { Channel, ChannelSortBase } from 'stream-chat';
-
-import { ChannelListProps } from '../../ChannelList';
-
-export const isChannelPinned = (channel: Channel) => {
-  if (!channel) {
-    return false;
-  }
-
-  const member = channel.state.membership;
-
-  return !!member?.pinned_at;
-};
-
-export const isChannelArchived = (channel: Channel) => {
-  if (!channel) {
-    return false;
-  }
-
-  const member = channel.state.membership;
-
-  return !!member?.archived_at;
-};
-
-export const shouldConsiderArchivedChannels = (filters: ChannelListProps['filters']) => {
-  if (!filters) {
-    return false;
-  }
-
-  return typeof filters.archived === 'boolean';
-};
-
-export const extractSortValue = ({
-  atIndex,
-  sort,
-  targetKey,
-}: {
-  atIndex: number;
-  targetKey: keyof ChannelSortBase;
-  sort?: ChannelListProps['sort'];
-}) => {
-  if (!sort) {
-    return null;
-  }
-  let option: null | ChannelSortBase = null;
-
-  if (Array.isArray(sort)) {
-    option = sort[atIndex] ?? null;
-  } else {
-    let index = 0;
-    for (const key in sort) {
-      if (index !== atIndex) {
-        index++;
-        continue;
-      }
-
-      if (key !== targetKey) {
-        return null;
-      }
-
-      option = sort;
-
-      break;
-    }
-  }
-
-  return option?.[targetKey] ?? null;
-};
-
-/**
- * Returns true only if `{ pinned_at: -1 }` or `{ pinned_at: 1 }` option is first within the `sort` array.
- */
-export const shouldConsiderPinnedChannels = (sort: ChannelListProps['sort']) => {
-  const value = extractSortValue({
-    atIndex: 0,
-    sort,
-    targetKey: 'pinned_at',
-  });
-
-  if (typeof value !== 'number') {
-    return false;
-  }
-
-  return Math.abs(value) === 1;
-};
-
-export function findPinnedAtSortOrder({ sort }: { sort: ChannelListProps['sort'] }) {
-  if (!sort) {
-    return null;
-  }
-
-  if (Array.isArray(sort)) {
-    const [option] = sort;
-
-    if (!option?.pinned_at) {
-      return null;
-    }
-
-    return option.pinned_at;
-  } else {
-    if (!sort.pinned_at) {
-      return null;
-    }
-
-    return sort.pinned_at;
-  }
-}
-
-export function findLastPinnedChannelIndex({ channels }: { channels: Channel[] }) {
-  let lastPinnedChannelIndex: number | null = null;
-
-  for (const channel of channels) {
-    if (!isChannelPinned(channel)) {
-      break;
-    }
-
-    if (typeof lastPinnedChannelIndex === 'number') {
-      lastPinnedChannelIndex++;
-    } else {
-      lastPinnedChannelIndex = 0;
-    }
-  }
-
-  return lastPinnedChannelIndex;
-}

package/src/components/Chat/hooks/__tests__/useAppSettings.test.tsx

@@ -1,37 +0,0 @@
-import React from 'react';
-import { Text } from 'react-native';
-
-import { render, waitFor } from '@testing-library/react-native';
-
-import type { StreamChat } from 'stream-chat';
-
-import { useAppSettings } from '../useAppSettings';
-
-describe('useAppSettings', () => {
-  it('will return a settings object if the backend call is successful', async () => {
-    const TestComponent = () => {
-      const isOnline = true;
-      const appSettings = useAppSettings(
-        {
-          getAppSettings: jest.fn().mockReturnValue(
-            Promise.resolve({
-              auto_translation_enabled: true,
-            }),
-          ),
-          userID: 'some-user-id',
-        } as unknown as StreamChat,
-        isOnline,
-        false,
-        false,
-      );
-
-      return <Text>{JSON.stringify(appSettings)}</Text>;
-    };
-
-    const { getByText } = render(<TestComponent />);
-
-    await waitFor(() => {
-      expect(getByText(JSON.stringify({ auto_translation_enabled: true }))).toBeTruthy();
-    });
-  });
-});

package/src/components/Chat/hooks/useAppSettings.ts

@@ -1,65 +0,0 @@
-import { useEffect, useRef, useState } from 'react';
-
-import type { AppSettingsAPIResponse, StreamChat } from 'stream-chat';
-
-import { useIsMountedRef } from '../../../hooks/useIsMountedRef';
-
-export const useAppSettings = (
-  client: StreamChat,
-  isOnline: boolean | null,
-  enableOfflineSupport: boolean,
-  initialisedDatabase: boolean,
-): AppSettingsAPIResponse | null => {
-  const [appSettings, setAppSettings] = useState<AppSettingsAPIResponse | null>(null);
-  const appSettingsPromise = useRef<Promise<AppSettingsAPIResponse | null>>(null);
-  const fetchedAppSettings = useRef(false);
-  const isMounted = useIsMountedRef();
-
-  useEffect(() => {
-    if (fetchedAppSettings.current) {
-      return;
-    }
-
-    const fetchAppSettings = () => {
-      if (appSettingsPromise.current) {
-        return appSettingsPromise.current;
-      }
-      appSettingsPromise.current = client.getAppSettings();
-      return appSettingsPromise.current;
-    };
-
-    const enforceAppSettings = async () => {
-      if (!client.userID) return;
-
-      if (enableOfflineSupport && !initialisedDatabase) return;
-
-      const userId = client.userID as string;
-
-      if (!isOnline && client.offlineDb) {
-        const appSettings = await client.offlineDb.getAppSettings({ userId });
-        setAppSettings(appSettings);
-        return;
-      }
-
-      try {
-        const appSettings = await fetchAppSettings();
-        if (isMounted.current && appSettings) {
-          setAppSettings(appSettings);
-          fetchedAppSettings.current = true;
-          client.offlineDb?.executeQuerySafely(
-            (db) => db.upsertAppSettings({ appSettings, userId }),
-            { method: 'upsertAppSettings' },
-          );
-        }
-      } catch (error: unknown) {
-        if (error instanceof Error) {
-          console.error(`An error occurred while getting app settings: ${error}`);
-        }
-      }
-    };
-
-    enforceAppSettings();
-  }, [client, isOnline, initialisedDatabase, isMounted, enableOfflineSupport]);
-
-  return appSettings;
-};

package/src/components/Chat/hooks/useClientMutedUsers.ts

@@ -1,19 +0,0 @@
-import { useEffect, useState } from 'react';
-
-import type { Event, Mute, StreamChat } from 'stream-chat';
-
-export const useClientMutedUsers = (client: StreamChat) => {
-  const [mutedUsers, setMutedUsers] = useState<Mute[]>(client?.mutedUsers || []);
-
-  useEffect(() => {
-    const handleEvent = (event: Event) => {
-      setMutedUsers((mutes) => event.me?.mutes || mutes || []);
-    };
-
-    const listener = client?.on('notification.mutes_updated', handleEvent);
-    return () => listener?.unsubscribe();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [setMutedUsers]);
-
-  return mutedUsers;
-};

package/src/components/Chat/hooks/useIsOnline.ts

@@ -1,104 +0,0 @@
-import { useCallback, useEffect, useState } from 'react';
-
-import NetInfo, { NetInfoSubscription } from '@react-native-community/netinfo';
-
-import type { StreamChat, Event as StreamEvent } from 'stream-chat';
-
-import { useAppStateListener } from '../../../hooks/useAppStateListener';
-import { useIsMountedRef } from '../../../hooks/useIsMountedRef';
-
-/**
- * Disconnect the websocket connection when app goes to background,
- * and reconnect when app comes to foreground.
- * We do this to make sure the user receives push notifications when app is in the background.
- * You can't receive push notification until you have active websocket connection.
- */
-export const useIsOnline = (client: StreamChat, closeConnectionOnBackground = true) => {
-  const [isOnline, setIsOnline] = useState<boolean | null>(null);
-  const [connectionRecovering, setConnectionRecovering] = useState(false);
-  const isMounted = useIsMountedRef();
-  const clientExists = !!client;
-
-  const onBackground = useCallback(() => {
-    if (!closeConnectionOnBackground || !clientExists) {
-      return;
-    }
-
-    client.closeConnection();
-    setIsOnline(false);
-  }, [closeConnectionOnBackground, client, clientExists]);
-
-  const onForeground = useCallback(() => {
-    // If the user id is not set, we should not open the connection, as it will raise an unneeded error
-    if (!clientExists || !client.userID) {
-      return;
-    }
-
-    client.openConnection();
-  }, [client, clientExists]);
-
-  useAppStateListener(onForeground, onBackground);
-
-  useEffect(() => {
-    const handleChangedEvent = (event: StreamEvent) => {
-      setConnectionRecovering(!event.online);
-      setIsOnline(event.online || false);
-    };
-
-    const handleRecoveredEvent = () => setConnectionRecovering(false);
-
-    const notifyChatClient = (isConnected: boolean | null) => {
-      if (client?.wsConnection && isConnected) {
-        if (isConnected) {
-          client.wsConnection.onlineStatusChanged({
-            type: 'online',
-          } as Event);
-        } else {
-          client.wsConnection.onlineStatusChanged({
-            type: 'offline',
-          } as Event);
-        }
-      }
-    };
-
-    let unsubscribeNetInfo: NetInfoSubscription;
-    const setNetInfoListener = () => {
-      unsubscribeNetInfo = NetInfo.addEventListener((netInfoState) => {
-        if (!netInfoState && !client.wsConnection?.isHealthy) {
-          setConnectionRecovering(true);
-          setIsOnline(false);
-        }
-        const { isConnected, isInternetReachable } = netInfoState;
-        notifyChatClient(
-          isInternetReachable !== null ? isInternetReachable && isConnected : isConnected,
-        );
-      });
-    };
-
-    const setInitialOnlineState = async () => {
-      const { isConnected } = await NetInfo.fetch();
-      if (isMounted.current) {
-        setIsOnline(isConnected);
-        notifyChatClient(isConnected);
-      }
-    };
-
-    setInitialOnlineState();
-
-    const chatListeners: Array<ReturnType<StreamChat['on']>> = [];
-
-    if (client) {
-      chatListeners.push(client.on('connection.changed', handleChangedEvent));
-      chatListeners.push(client.on('connection.recovered', handleRecoveredEvent));
-      setNetInfoListener();
-    }
-
-    return () => {
-      chatListeners.forEach((listener) => listener.unsubscribe?.());
-      unsubscribeNetInfo?.();
-    };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [clientExists]);
-
-  return { connectionRecovering, isOnline };
-};

package/src/components/MessageList/InlineLoadingMoreRecentThreadIndicator.tsx

@@ -1,61 +0,0 @@
-import React from 'react';
-import { ActivityIndicator, StyleSheet, View } from 'react-native';
-
-import { useThreadContext } from '../../contexts';
-import { useTheme } from '../../contexts/themeContext/ThemeContext';
-import { primitives } from '../../theme';
-
-const styles = StyleSheet.create({
-  activityIndicatorContainer: {
-    padding: primitives.spacingSm,
-    width: '100%',
-  },
-});
-
-export type InlineLoadingMoreRecentThreadIndicatorPropsWithContext = {
-  loadingMoreRecent?: boolean;
-};
-
-export const InlineLoadingMoreRecentIndicatorWithContext = ({
-  loadingMoreRecent,
-}: InlineLoadingMoreRecentThreadIndicatorPropsWithContext) => {
-  const { theme } = useTheme();
-
-  const { semantics } = theme;
-
-  if (!loadingMoreRecent) {
-    return null;
-  }
-
-  return (
-    <View style={styles.activityIndicatorContainer}>
-      <ActivityIndicator color={semantics.accentPrimary} size='small' />
-    </View>
-  );
-};
-
-const areEqual = (
-  prevProps: InlineLoadingMoreRecentThreadIndicatorPropsWithContext,
-  nextProps: InlineLoadingMoreRecentThreadIndicatorPropsWithContext,
-) => {
-  const { loadingMoreRecent: prevLoadingMoreRecent } = prevProps;
-  const { loadingMoreRecent: nextLoadingMoreRecent } = nextProps;
-
-  const loadingMoreRecentEqual = prevLoadingMoreRecent === nextLoadingMoreRecent;
-  if (!loadingMoreRecentEqual) {
-    return false;
-  }
-
-  return true;
-};
-
-const MemoizedInlineLoadingMoreRecentIndicator = React.memo(
-  InlineLoadingMoreRecentIndicatorWithContext,
-  areEqual,
-) as typeof InlineLoadingMoreRecentIndicatorWithContext;
-
-export const InlineLoadingMoreRecentThreadIndicator = () => {
-  const { threadLoadingMoreRecent } = useThreadContext();
-
-  return <MemoizedInlineLoadingMoreRecentIndicator loadingMoreRecent={threadLoadingMoreRecent} />;
-};

package/src/components/MessageList/utils/getLastReceivedMessage.ts

@@ -1,16 +0,0 @@
-import { LocalMessage } from 'stream-chat';
-
-import { MessageStatusTypes } from '../../../utils/utils';
-
-export const getLastReceivedMessage = (messages: LocalMessage[]) => {
-  /**
-   * There are no status on dates so they will be skipped
-   */
-  for (const message of messages) {
-    if (message?.status !== MessageStatusTypes.FAILED) {
-      return message;
-    }
-  }
-
-  return;
-};

package/src/contexts/activeChannelsRefContext/ActiveChannelsRefContext.tsx

@@ -1,15 +0,0 @@
-import React, { PropsWithChildren, useContext } from 'react';
-
-type ActiveChannels = React.MutableRefObject<string[]>;
-
-const ActiveChannelsContext = React.createContext({ current: [] } as ActiveChannels);
-
-export const ActiveChannelsProvider = ({
-  children,
-  value,
-}: PropsWithChildren<{
-  value: ActiveChannels;
-}>) => <ActiveChannelsContext.Provider value={value}>{children}</ActiveChannelsContext.Provider>;
-
-export const useActiveChannelsRefContext = () =>
-  useContext(ActiveChannelsContext) as unknown as ActiveChannels;

package/src/contexts/channelsStateContext/ChannelsStateContext.tsx

@@ -1,107 +0,0 @@
-import React, {
-  ReactNode,
-  useCallback,
-  useContext,
-  useEffect,
-  useMemo,
-  useReducer,
-  useRef,
-} from 'react';
-
-import { ActiveChannelsProvider } from '../activeChannelsRefContext/ActiveChannelsRefContext';
-
-import type { ThreadContextValue } from '../threadContext/ThreadContext';
-import { DEFAULT_BASE_CONTEXT_VALUE } from '../utils/defaultBaseContextValue';
-
-import { isTestEnvironment } from '../utils/isTestEnvironment';
-
-export type ChannelState = {
-  threadMessages: ThreadContextValue['threadMessages'];
-};
-
-type ChannelsState = {
-  [cid: string]: ChannelState;
-};
-
-export type Keys = keyof ChannelState;
-
-export type Payload<Key extends Keys = Keys> = {
-  cid: string;
-  key: Key;
-  value: ChannelState[Key];
-};
-
-type SetStateAction = {
-  payload: Payload;
-  type: 'SET_STATE';
-};
-
-type Action = SetStateAction;
-
-export type ChannelsStateContextValue = {
-  setState: (value: Payload) => void;
-  state: ChannelsState;
-};
-
-type Reducer = (state: ChannelsState, action: Action) => ChannelsState;
-
-function reducer(state: ChannelsState, action: Action) {
-  switch (action.type) {
-    case 'SET_STATE':
-      return {
-        ...state,
-        [action.payload.cid]: {
-          ...(state[action.payload.cid] || {}),
-          [action.payload.key]: action.payload.value,
-        },
-      };
-
-    default:
-      throw new Error();
-  }
-}
-
-const ChannelsStateContext = React.createContext(
-  DEFAULT_BASE_CONTEXT_VALUE as ChannelsStateContextValue,
-);
-
-export const ChannelsStateProvider = ({ children }: { children: ReactNode }) => {
-  const [state, dispatch] = useReducer(reducer as unknown as Reducer, {});
-
-  const setState = useCallback((payload: Payload) => {
-    dispatch({ payload, type: 'SET_STATE' });
-  }, []);
-
-  const value = useMemo(
-    () => ({
-      setState,
-      state,
-    }),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [state],
-  );
-
-  const activeChannelsRef = useRef(Object.keys(state));
-
-  useEffect(() => {
-    activeChannelsRef.current = Object.keys(state);
-  }, [state]);
-
-  return (
-    <ChannelsStateContext.Provider value={value as unknown as ChannelsStateContextValue}>
-      <ActiveChannelsProvider value={activeChannelsRef}>{children}</ActiveChannelsProvider>
-    </ChannelsStateContext.Provider>
-  );
-};
-
-export const useChannelsStateContext = () => {
-  const contextValue = useContext(ChannelsStateContext) as unknown as ChannelsStateContextValue;
-
-  if (contextValue === DEFAULT_BASE_CONTEXT_VALUE && !isTestEnvironment()) {
-    throw new Error(
-      'The useChannelsStateContext hook was called outside the ChannelStateContext Provider. Make sure you have configured OverlayProvider component correctly - https://getstream.io/chat/docs/sdk/reactnative/basics/hello_stream_chat/#overlay-provider',
-    );
-  }
-
-  return contextValue;
-};