stream-chat-react-native-core 6.6.7 → 7.0.0-rc.1

package/src/contexts/channelsStateContext/ChannelsStateContext.tsx

@@ -8,7 +8,6 @@ import React, {
   useRef,
 } from 'react';
 
-import type { DefaultStreamChatGenerics } from '../../types/types';
 import { ActiveChannelsProvider } from '../activeChannelsRefContext/ActiveChannelsRefContext';
 
 import type { ThreadContextValue } from '../threadContext/ThreadContext';
@@ -16,50 +15,35 @@ import { DEFAULT_BASE_CONTEXT_VALUE } from '../utils/defaultBaseContextValue';
 
 import { isTestEnvironment } from '../utils/isTestEnvironment';
 
-export type ChannelState<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
-  threadMessages: ThreadContextValue<StreamChatGenerics>['threadMessages'];
+export type ChannelState = {
+  threadMessages: ThreadContextValue['threadMessages'];
 };
 
-type ChannelsState<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
-  [cid: string]: ChannelState<StreamChatGenerics>;
+type ChannelsState = {
+  [cid: string]: ChannelState;
 };
 
 export type Keys = keyof ChannelState;
 
-export type Payload<
-  Key extends Keys = Keys,
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
+export type Payload<Key extends Keys = Keys> = {
   cid: string;
   key: Key;
-  value: ChannelState<StreamChatGenerics>[Key];
+  value: ChannelState[Key];
 };
 
-type SetStateAction<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
-  payload: Payload<Keys, StreamChatGenerics>;
+type SetStateAction = {
+  payload: Payload;
   type: 'SET_STATE';
 };
 
-type Action<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> =
-  SetStateAction<StreamChatGenerics>;
+type Action = SetStateAction;
 
-export type ChannelsStateContextValue<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
-  setState: (value: Payload<Keys, StreamChatGenerics>) => void;
-  state: ChannelsState<StreamChatGenerics>;
+export type ChannelsStateContextValue = {
+  setState: (value: Payload) => void;
+  state: ChannelsState;
 };
 
-type Reducer<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = (
-  state: ChannelsState<StreamChatGenerics>,
-  action: Action<StreamChatGenerics>,
-) => ChannelsState<StreamChatGenerics>;
+type Reducer = (state: ChannelsState, action: Action) => ChannelsState;
 
 function reducer(state: ChannelsState, action: Action) {
   switch (action.type) {
@@ -81,16 +65,10 @@ const ChannelsStateContext = React.createContext(
   DEFAULT_BASE_CONTEXT_VALUE as ChannelsStateContextValue,
 );
 
-export const ChannelsStateProvider = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
-  children,
-}: {
-  children: ReactNode;
-}) => {
-  const [state, dispatch] = useReducer(reducer as unknown as Reducer<StreamChatGenerics>, {});
+export const ChannelsStateProvider = ({ children }: { children: ReactNode }) => {
+  const [state, dispatch] = useReducer(reducer as unknown as Reducer, {});
 
-  const setState = useCallback((payload: Payload<Keys, StreamChatGenerics>) => {
+  const setState = useCallback((payload: Payload) => {
     dispatch({ payload, type: 'SET_STATE' });
   }, []);
 
@@ -116,12 +94,8 @@ export const ChannelsStateProvider = <
   );
 };
 
-export const useChannelsStateContext = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->() => {
-  const contextValue = useContext(
-    ChannelsStateContext,
-  ) as unknown as ChannelsStateContextValue<StreamChatGenerics>;
+export const useChannelsStateContext = () => {
+  const contextValue = useContext(ChannelsStateContext) as unknown as ChannelsStateContextValue;
 
   if (contextValue === DEFAULT_BASE_CONTEXT_VALUE && !isTestEnvironment()) {
     throw new Error(

package/src/contexts/channelsStateContext/useChannelState.ts

@@ -6,12 +6,7 @@ import { useChannelsStateContext } from './ChannelsStateContext';
 
 import type { ChannelsStateContextValue, ChannelState, Keys } from './ChannelsStateContext';
 
-import type { DefaultStreamChatGenerics } from '../../types/types';
-
-type StateManagerParams<
-  Key extends Keys,
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = ChannelsStateContextValue<StreamChatGenerics> & {
+type StateManagerParams<Key extends Keys> = ChannelsStateContextValue & {
   cid: string;
   key: Key;
 };
@@ -21,20 +16,16 @@ type StateManagerParams<
   updates to the ChannelsStateContext reducer. It receives the cid and key which it wants to update
   and perform the state updates. Also supports a initialState.
 */
-export function useStateManager<
-  Key extends Keys,
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  { cid, key, setState, state }: StateManagerParams<Key, StreamChatGenerics>,
-  initialValue?: ChannelState<StreamChatGenerics>[Key],
+export function useStateManager<Key extends Keys>(
+  { cid, key, setState, state }: StateManagerParams<Key>,
+  initialValue?: ChannelState[Key],
 ) {
   // eslint-disable-next-line react-hooks/exhaustive-deps
   const memoizedInitialValue = useMemo(() => initialValue, []);
-  const value =
-    state[cid]?.[key] || (memoizedInitialValue as ChannelState<StreamChatGenerics>[Key]);
+  const value = state[cid]?.[key] || (memoizedInitialValue as ChannelState[Key]);
 
   const setValue = useCallback(
-    (value: ChannelState<StreamChatGenerics>[Key]) => setState({ cid, key, value }),
+    (value: ChannelState[Key]) => setState({ cid, key, value }),
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [cid, key],
   );
@@ -42,21 +33,17 @@ export function useStateManager<
   return [value, setValue] as const;
 }
 
-export type UseChannelStateValue<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
-  setThreadMessages: (value: ChannelState<StreamChatGenerics>['threadMessages']) => void;
-  threadMessages: ChannelState<StreamChatGenerics>['threadMessages'];
+export type UseChannelStateValue = {
+  setThreadMessages: (value: ChannelState['threadMessages']) => void;
+  threadMessages: ChannelState['threadMessages'];
 };
 
-export function useChannelState<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  channel: ChannelType<StreamChatGenerics> | undefined,
+export function useChannelState(
+  channel: ChannelType | undefined,
   threadId?: string,
-): UseChannelStateValue<StreamChatGenerics> {
+): UseChannelStateValue {
   const cid = channel?.id || 'id'; // in case channel is not initialized, use generic id string for indexing
-  const { setState, state } = useChannelsStateContext<StreamChatGenerics>();
+  const { setState, state } = useChannelsStateContext();
 
   const [threadMessages, setThreadMessages] = useStateManager(
     {

package/src/contexts/chatContext/ChatContext.tsx

@@ -3,19 +3,16 @@ import type { ImageProps } from 'react-native';
 
 import type { AppSettingsAPIResponse, Channel, Mute, StreamChat } from 'stream-chat';
 
-import type { DefaultStreamChatGenerics } from '../../types/types';
 import { MessageContextValue } from '../messageContext/MessageContext';
 import { DEFAULT_BASE_CONTEXT_VALUE } from '../utils/defaultBaseContextValue';
 
 import { isTestEnvironment } from '../utils/isTestEnvironment';
 
-export type ChatContextValue<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
+export type ChatContextValue = {
   /**
    * Object of application settings returned from Stream.
    * */
-  appSettings: AppSettingsAPIResponse<StreamChatGenerics> | null;
+  appSettings: AppSettingsAPIResponse | null;
   /**
    * The StreamChat client object
    *
@@ -32,7 +29,7 @@ export type ChatContextValue<
    *
    * @overrideType StreamChat
    * */
-  client: StreamChat<StreamChatGenerics>;
+  client: StreamChat;
   connectionRecovering: boolean;
   enableOfflineSupport: boolean;
   /**
@@ -40,13 +37,13 @@ export type ChatContextValue<
    */
   ImageComponent: React.ComponentType<ImageProps>;
   isOnline: boolean | null;
-  mutedUsers: Mute<StreamChatGenerics>[];
+  mutedUsers: Mute[];
   /**
    * @param newChannel Channel to set as active.
    *
    * @overrideType Function
    */
-  setActiveChannel: (newChannel?: Channel<StreamChatGenerics>) => void;
+  setActiveChannel: (newChannel?: Channel) => void;
   /**
    * Instance of channel object from stream-chat package.
    *
@@ -64,28 +61,24 @@ export type ChatContextValue<
    *
    * @overrideType Channel
    */
-  channel?: Channel<StreamChatGenerics>;
-} & Partial<Pick<MessageContextValue<StreamChatGenerics>, 'isMessageAIGenerated'>>;
+  channel?: Channel;
+} & Partial<Pick<MessageContextValue, 'isMessageAIGenerated'>>;
 
 export const ChatContext = React.createContext(DEFAULT_BASE_CONTEXT_VALUE as ChatContextValue);
 
-export const ChatProvider = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const ChatProvider = ({
   children,
   value,
 }: PropsWithChildren<{
-  value?: ChatContextValue<StreamChatGenerics>;
+  value?: ChatContextValue;
 }>) => (
   <ChatContext.Provider value={value as unknown as ChatContextValue}>
     {children}
   </ChatContext.Provider>
 );
 
-export const useChatContext = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->() => {
-  const contextValue = useContext(ChatContext) as unknown as ChatContextValue<StreamChatGenerics>;
+export const useChatContext = () => {
+  const contextValue = useContext(ChatContext) as unknown as ChatContextValue;
 
   if (contextValue === DEFAULT_BASE_CONTEXT_VALUE && !isTestEnvironment()) {
     throw new Error(

package/src/contexts/debugContext/DebugContext.tsx

@@ -3,59 +3,52 @@ import React, { PropsWithChildren, useContext, useRef } from 'react';
 import type { Channel, ChannelState, StreamChat } from 'stream-chat';
 
 import type { MessageType } from '../../components/MessageList/hooks/useMessageList';
-import type { DefaultStreamChatGenerics } from '../../types/types';
 
 import { DEFAULT_BASE_CONTEXT_VALUE } from '../utils/defaultBaseContextValue';
 
-export type DebugDataType<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> =
-  | StreamChat<StreamChatGenerics>['user']
+export type DebugDataType =
+  | StreamChat['user']
   | {
-      data: Channel<StreamChatGenerics>['data'];
-      members: ChannelState<StreamChatGenerics>['members'];
+      data: Channel['data'];
+      members: ChannelState['members'];
     }[]
-  | MessageType<StreamChatGenerics>[];
+  | MessageType[];
 
-export type DebugContextValue<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
+export type DebugContextValue = {
   eventType?: string;
   sendEventParams?: {
     action: string;
-    data: DebugDataType<StreamChatGenerics>;
+    data: DebugDataType;
   };
   setEventType?: (data: string) => void;
-  setSendEventParams?: (data: { action: string; data: DebugDataType<StreamChatGenerics> }) => void;
+  setSendEventParams?: (data: { action: string; data: DebugDataType }) => void;
 };
 
 export const DebugContext = React.createContext(
   DEFAULT_BASE_CONTEXT_VALUE as React.MutableRefObject<DebugContextValue>,
 );
 
-export const DebugContextProvider = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const DebugContextProvider = ({
   children,
   useFlipper,
 }: PropsWithChildren<{
   useFlipper: () => {
-    updateData: (ref: React.RefObject<DebugContextValue<StreamChatGenerics>>) => void;
+    updateData: (ref: React.RefObject<DebugContextValue>) => void;
   };
 }>) => {
-  const debugRef = useRef<DebugContextValue<StreamChatGenerics>>({
+  const debugRef = useRef<DebugContextValue>({
     eventType: undefined,
     sendEventParams: undefined,
   });
 
   const { updateData } = useFlipper();
 
-  const ref = useRef<DebugContextValue<StreamChatGenerics>>({
+  const ref = useRef<DebugContextValue>({
     setEventType: (data: string) => {
       debugRef.current.eventType = data;
       updateData(debugRef);
     },
-    setSendEventParams: (data: { action: string; data: DebugDataType<StreamChatGenerics> }) => {
+    setSendEventParams: (data: { action: string; data: DebugDataType }) => {
       debugRef.current.sendEventParams = data;
       updateData(debugRef);
     },

package/src/contexts/imageGalleryContext/ImageGalleryContext.tsx

@@ -1,7 +1,7 @@
 import React, { PropsWithChildren, useContext, useState } from 'react';
 
 import type { MessageType } from '../../components/MessageList/hooks/useMessageList';
-import type { DefaultStreamChatGenerics, UnknownType } from '../../types/types';
+import type { UnknownType } from '../../types/types';
 import { DEFAULT_BASE_CONTEXT_VALUE } from '../utils/defaultBaseContextValue';
 
 import { isTestEnvironment } from '../utils/isTestEnvironment';
@@ -11,11 +11,9 @@ type SelectedMessage = {
   url?: string;
 };
 
-export type ImageGalleryContextValue<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
-  messages: MessageType<StreamChatGenerics>[];
-  setMessages: React.Dispatch<React.SetStateAction<MessageType<StreamChatGenerics>[]>>;
+export type ImageGalleryContextValue = {
+  messages: MessageType[];
+  setMessages: React.Dispatch<React.SetStateAction<MessageType[]>>;
   setSelectedMessage: React.Dispatch<React.SetStateAction<SelectedMessage | undefined>>;
   selectedMessage?: SelectedMessage;
 };
@@ -24,12 +22,8 @@ export const ImageGalleryContext = React.createContext(
   DEFAULT_BASE_CONTEXT_VALUE as ImageGalleryContextValue,
 );
 
-export const ImageGalleryProvider = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
-  children,
-}: PropsWithChildren<UnknownType>) => {
-  const [messages, setMessages] = useState<MessageType<StreamChatGenerics>[]>([]);
+export const ImageGalleryProvider = ({ children }: PropsWithChildren<UnknownType>) => {
+  const [messages, setMessages] = useState<MessageType[]>([]);
   const [selectedMessage, setSelectedMessage] = useState<SelectedMessage>();
 
   return (
@@ -48,12 +42,8 @@ export const ImageGalleryProvider = <
   );
 };
 
-export const useImageGalleryContext = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->() => {
-  const contextValue = useContext(
-    ImageGalleryContext,
-  ) as unknown as ImageGalleryContextValue<StreamChatGenerics>;
+export const useImageGalleryContext = () => {
+  const contextValue = useContext(ImageGalleryContext) as unknown as ImageGalleryContextValue;
 
   if (contextValue === DEFAULT_BASE_CONTEXT_VALUE && !isTestEnvironment()) {
     throw new Error(
@@ -61,5 +51,5 @@ export const useImageGalleryContext = <
     );
   }
 
-  return contextValue as ImageGalleryContextValue<StreamChatGenerics>;
+  return contextValue as ImageGalleryContextValue;
 };

package/src/contexts/messageContext/MessageContext.tsx

@@ -13,14 +13,12 @@ import type { ChannelContextValue } from '../../contexts/channelContext/ChannelC
 import type { MessageContentType } from '../../contexts/messagesContext/MessagesContext';
 import type { DeepPartial } from '../../contexts/themeContext/ThemeContext';
 import type { Theme } from '../../contexts/themeContext/utils/theme';
-import type { DefaultStreamChatGenerics } from '../../types/types';
+
 import { DEFAULT_BASE_CONTEXT_VALUE } from '../utils/defaultBaseContextValue';
 
 export type Alignment = 'right' | 'left';
 
-export type MessageContextValue<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
+export type MessageContextValue = {
   /** Whether or not actions can be performed on message */
   actionsEnabled: boolean;
   /** Position of the message, either 'right' or 'left' */
@@ -30,7 +28,7 @@ export type MessageContextValue<
    */
   dismissOverlay: () => void;
   /** The files attached to a message */
-  files: Attachment<StreamChatGenerics>[];
+  files: Attachment[];
   /**
    * Position of message in group - top, bottom, middle, single.
    *
@@ -44,19 +42,19 @@ export type MessageContextValue<
   /** Whether or not message has reactions */
   hasReactions: boolean;
   /** The images attached to a message */
-  images: Attachment<StreamChatGenerics>[];
+  images: Attachment[];
   /** Boolean that determines if the edited message is pressed. */
   isEditedMessageOpen: boolean;
   /**
    * A factory function that determines whether a message is AI generated or not.
    */
-  isMessageAIGenerated: (message: MessageType<StreamChatGenerics>) => boolean;
+  isMessageAIGenerated: (message: MessageType) => boolean;
   /** Whether or not this is the active user's message */
   isMyMessage: boolean;
   /** Whether or not this is the last message in a group of messages */
   lastGroupMessage: boolean;
   /** Current [message object](https://getstream.io/chat/docs/#message_format) */
-  message: MessageType<StreamChatGenerics>;
+  message: MessageType;
   /** Order to render the message content */
   messageContentOrder: MessageContentType[];
   /**
@@ -87,7 +85,7 @@ export type MessageContextValue<
   onPress: (payload: MessagePressableHandlerPayload) => void;
   onPressIn: ((payload: PressableHandlerPayload) => void) | null;
   /** The images attached to a message */
-  otherAttachments: Attachment<StreamChatGenerics>[];
+  otherAttachments: Attachment[];
   reactions: ReactionSummary[];
   /** React set state function to set the state of `isEditedMessageOpen` */
   setIsEditedMessageOpen: React.Dispatch<React.SetStateAction<boolean>>;
@@ -101,7 +99,7 @@ export type MessageContextValue<
   /** Whether or not the Message is part of a Thread */
   threadList: boolean;
   /** The videos attached to a message */
-  videos: Attachment<StreamChatGenerics>[];
+  videos: Attachment[];
   goToMessage?: (messageId: string) => void;
   /**
    * Function to handle reaction on message
@@ -119,31 +117,25 @@ export type MessageContextValue<
   preventPress?: boolean;
   /** Whether or not the avatar show show next to Message */
   showAvatar?: boolean;
-} & Pick<ChannelContextValue<StreamChatGenerics>, 'channel' | 'members'>;
+} & Pick<ChannelContextValue, 'channel' | 'members'>;
 
 export const MessageContext = React.createContext(
   DEFAULT_BASE_CONTEXT_VALUE as MessageContextValue,
 );
 
-export const MessageProvider = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const MessageProvider = ({
   children,
   value,
 }: PropsWithChildren<{
-  value?: MessageContextValue<StreamChatGenerics>;
+  value?: MessageContextValue;
 }>) => (
   <MessageContext.Provider value={value as unknown as MessageContextValue}>
     {children}
   </MessageContext.Provider>
 );
 
-export const useMessageContext = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->() => {
-  const contextValue = useContext(
-    MessageContext,
-  ) as unknown as MessageContextValue<StreamChatGenerics>;
+export const useMessageContext = () => {
+  const contextValue = useContext(MessageContext) as unknown as MessageContextValue;
 
   return contextValue;
 };