stream-chat-react-native-core 6.7.5-beta.1 → 7.0.0-beta.1

package/src/components/MessageList/hooks/useMessageList.ts

@@ -1,8 +1,6 @@
-import { useMemo } from 'react';
+import { useMemo, useRef } from 'react';
 
-import type { ChannelState, MessageResponse } from 'stream-chat';
-
-import { useLastReadData } from './useLastReadData';
+import type { LocalMessage } from 'stream-chat';
 
 import { useChannelContext } from '../../../contexts/channelContext/ChannelContext';
 import { useChatContext } from '../../../contexts/chatContext/ChatContext';
@@ -12,8 +10,8 @@ import {
 } from '../../../contexts/messagesContext/MessagesContext';
 import { usePaginatedMessageListContext } from '../../../contexts/paginatedMessageListContext/PaginatedMessageListContext';
 import { useThreadContext } from '../../../contexts/threadContext/ThreadContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-import { getDateSeparators } from '../utils/getDateSeparators';
+
+import { DateSeparators, getDateSeparators } from '../utils/getDateSeparators';
 import { getGroupStyles } from '../utils/getGroupStyles';
 
 export type UseMessageListParams = {
@@ -24,32 +22,12 @@ export type UseMessageListParams = {
 
 export type GroupType = string;
 
-export type MessagesWithStylesReadByAndDateSeparator<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = MessageResponse<StreamChatGenerics> & {
-  groupStyles: GroupType[];
-  readBy: boolean | number;
-  dateSeparator?: Date;
+export type MessageGroupStyles = {
+  [key: string]: string[];
 };
 
-export type MessageType<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> =
-  | ReturnType<ChannelState<StreamChatGenerics>['formatMessage']>
-  | MessagesWithStylesReadByAndDateSeparator<StreamChatGenerics>;
-
-// Type guards to check MessageType
-export const isMessageWithStylesReadByAndDateSeparator = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  message: MessageType<StreamChatGenerics>,
-): message is MessagesWithStylesReadByAndDateSeparator<StreamChatGenerics> =>
-  (message as MessagesWithStylesReadByAndDateSeparator<StreamChatGenerics>).readBy !== undefined;
-
-export const shouldIncludeMessageInList = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  message: MessageType<StreamChatGenerics>,
+export const shouldIncludeMessageInList = (
+  message: LocalMessage,
   options: { deletedMessagesVisibilityType?: DeletedMessagesVisibilityType; userId?: string },
 ) => {
   const { deletedMessagesVisibilityType, userId } = options;
@@ -69,48 +47,55 @@ export const shouldIncludeMessageInList = <
   }
 };
 
-export const useMessageList = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  params: UseMessageListParams,
-) => {
+export const useMessageList = (params: UseMessageListParams) => {
   const { noGroupByUser, threadList } = params;
-  const { client } = useChatContext<StreamChatGenerics>();
-  const { hideDateSeparators, maxTimeBetweenGroupedMessages, read } =
-    useChannelContext<StreamChatGenerics>();
+  const { client } = useChatContext();
+  const { hideDateSeparators, maxTimeBetweenGroupedMessages } = useChannelContext();
   const { deletedMessagesVisibilityType, getMessagesGroupStyles = getGroupStyles } =
-    useMessagesContext<StreamChatGenerics>();
-  const { messages } = usePaginatedMessageListContext<StreamChatGenerics>();
-  const { threadMessages } = useThreadContext<StreamChatGenerics>();
-
+    useMessagesContext();
+  const { messages } = usePaginatedMessageListContext();
+  const { threadMessages } = useThreadContext();
   const messageList = threadList ? threadMessages : messages;
-  const readList: ChannelState<StreamChatGenerics>['read'] | undefined = threadList
-    ? undefined
-    : read;
-
-  const readData = useLastReadData({
-    messages: messageList,
-    read: readList,
-    userID: client.userID,
-  });
-
-  const processedMessageList = useMemo<MessageType<StreamChatGenerics>[]>(() => {
-    const dateSeparators = getDateSeparators({
-      deletedMessagesVisibilityType,
-      hideDateSeparators,
-      messages: messageList,
-      userId: client.userID,
-    });
 
-    const messageGroupStyles = getMessagesGroupStyles({
-      dateSeparators,
+  const dateSeparators = useMemo(
+    () =>
+      getDateSeparators({
+        deletedMessagesVisibilityType,
+        hideDateSeparators,
+        messages: messageList,
+        userId: client.userID,
+      }),
+    [deletedMessagesVisibilityType, hideDateSeparators, messageList, client.userID],
+  );
+
+  const dateSeparatorsRef = useRef<DateSeparators>(dateSeparators);
+  dateSeparatorsRef.current = dateSeparators;
+
+  const messageGroupStyles = useMemo(
+    () =>
+      getMessagesGroupStyles({
+        dateSeparators: dateSeparatorsRef.current,
+        hideDateSeparators,
+        maxTimeBetweenGroupedMessages,
+        messages: messageList,
+        noGroupByUser,
+        userId: client.userID,
+      }),
+    [
+      dateSeparatorsRef,
+      getMessagesGroupStyles,
       hideDateSeparators,
       maxTimeBetweenGroupedMessages,
-      messages: messageList,
+      messageList,
       noGroupByUser,
-      userId: client.userID,
-    });
+      client.userID,
+    ],
+  );
+
+  const messageGroupStylesRef = useRef<MessageGroupStyles>(messageGroupStyles);
+  messageGroupStylesRef.current = messageGroupStyles;
 
+  const processedMessageList = useMemo<LocalMessage[]>(() => {
     const newMessageList = [];
     for (const message of messageList) {
       if (
@@ -119,28 +104,17 @@ export const useMessageList = <
           userId: client.userID,
         })
       ) {
-        const messageId = message.id;
-        newMessageList.unshift({
-          ...message,
-          dateSeparator: dateSeparators[messageId] || undefined,
-          groupStyles: messageGroupStyles[messageId] || ['single'],
-          readBy: messageId ? readData[messageId] || false : false,
-        });
+        newMessageList.unshift(message);
       }
     }
     return newMessageList;
-  }, [
-    client.userID,
-    deletedMessagesVisibilityType,
-    getMessagesGroupStyles,
-    hideDateSeparators,
-    maxTimeBetweenGroupedMessages,
-    messageList,
-    noGroupByUser,
-    readData,
-  ]);
+  }, [client.userID, deletedMessagesVisibilityType, messageList]);
 
   return {
+    /** Date separators */
+    dateSeparatorsRef,
+    /** Message group styles */
+    messageGroupStylesRef,
     /** Messages enriched with dates/readby/groups and also reversed in order */
     processedMessageList,
     /** Raw messages from the channel state */

package/src/components/MessageList/hooks/useShouldScrollToRecentOnNewOwnMessage.ts

@@ -1,12 +1,11 @@
 import { useEffect, useRef } from 'react';
 
-import type { FormatMessageResponse } from 'stream-chat';
+import type { LocalMessage } from 'stream-chat';
 
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-
-export function useShouldScrollToRecentOnNewOwnMessage<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(rawMessageList: FormatMessageResponse<StreamChatGenerics>[], currentUserId?: string) {
+export function useShouldScrollToRecentOnNewOwnMessage(
+  rawMessageList: LocalMessage[],
+  currentUserId?: string,
+) {
   const lastFocusedOwnMessageId = useRef('');
   const initialFocusRegistered = useRef(false);
   const messagesRef = useRef(rawMessageList);

package/src/components/MessageList/hooks/useTypingString.ts

@@ -3,16 +3,13 @@ import { useThreadContext } from '../../../contexts/threadContext/ThreadContext'
 import { useTranslationContext } from '../../../contexts/translationContext/TranslationContext';
 import { useTypingContext } from '../../../contexts/typingContext/TypingContext';
 
-import type { DefaultStreamChatGenerics } from '../../../types/types';
 import { filterTypingUsers } from '../utils/filterTypingUsers';
 
-export const useTypingString = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->() => {
-  const { client } = useChatContext<StreamChatGenerics>();
-  const { thread } = useThreadContext<StreamChatGenerics>();
+export const useTypingString = () => {
+  const { client } = useChatContext();
+  const { thread } = useThreadContext();
   const { t } = useTranslationContext();
-  const { typing } = useTypingContext<StreamChatGenerics>();
+  const { typing } = useTypingContext();
 
   const filteredTypingUsers = filterTypingUsers({ client, thread, typing });
 

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

@@ -1,21 +1,12 @@
 import type { ChatContextValue } from '../../../contexts/chatContext/ChatContext';
 import type { ThreadContextValue } from '../../../contexts/threadContext/ThreadContext';
 import type { TypingContextValue } from '../../../contexts/typingContext/TypingContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-
-type FilterTypingUsersParams<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = Pick<TypingContextValue<StreamChatGenerics>, 'typing'> &
-  Pick<ChatContextValue<StreamChatGenerics>, 'client'> &
-  Pick<ThreadContextValue<StreamChatGenerics>, 'thread'>;
-
-export const filterTypingUsers = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
-  client,
-  thread,
-  typing,
-}: FilterTypingUsersParams<StreamChatGenerics>) => {
+
+type FilterTypingUsersParams = Pick<TypingContextValue, 'typing'> &
+  Pick<ChatContextValue, 'client'> &
+  Pick<ThreadContextValue, 'thread'>;
+
+export const filterTypingUsers = ({ client, thread, typing }: FilterTypingUsersParams) => {
   const nonSelfUsers: string[] = [];
 
   if (!client || !client.user || !typing) {

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

@@ -1,14 +1,9 @@
 import type { DeletedMessagesVisibilityType } from '../../../contexts/messagesContext/MessagesContext';
 import type { PaginatedMessageListContextValue } from '../../../contexts/paginatedMessageListContext/PaginatedMessageListContext';
 import type { ThreadContextValue } from '../../../contexts/threadContext/ThreadContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
 
-export type GetDateSeparatorsParams<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
-  messages:
-    | PaginatedMessageListContextValue<StreamChatGenerics>['messages']
-    | ThreadContextValue<StreamChatGenerics>['threadMessages'];
+export type GetDateSeparatorsParams = {
+  messages: PaginatedMessageListContextValue['messages'] | ThreadContextValue['threadMessages'];
   deletedMessagesVisibilityType?: DeletedMessagesVisibilityType;
   hideDateSeparators?: boolean;
   userId?: string;
@@ -18,11 +13,7 @@ export type DateSeparators = {
   [key: string]: Date;
 };
 
-export const getDateSeparators = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  params: GetDateSeparatorsParams<StreamChatGenerics>,
-) => {
+export const getDateSeparators = (params: GetDateSeparatorsParams) => {
   const { deletedMessagesVisibilityType, hideDateSeparators, messages, userId } = params;
   const dateSeparators: DateSeparators = {};
 

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

@@ -1,18 +1,16 @@
+import { LocalMessage } from 'stream-chat';
+
 import type { DateSeparators } from './getDateSeparators';
 
 import type { PaginatedMessageListContextValue } from '../../../contexts/paginatedMessageListContext/PaginatedMessageListContext';
 import type { ThreadContextValue } from '../../../contexts/threadContext/ThreadContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
+
 import { isEditedMessage } from '../../../utils/utils';
-import type { GroupType, MessageType } from '../hooks/useMessageList';
+import type { GroupType } from '../hooks/useMessageList';
 
-export type GetGroupStylesParams<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
+export type GetGroupStylesParams = {
   dateSeparators: DateSeparators;
-  messages:
-    | PaginatedMessageListContextValue<StreamChatGenerics>['messages']
-    | ThreadContextValue<StreamChatGenerics>['threadMessages'];
+  messages: PaginatedMessageListContextValue['messages'] | ThreadContextValue['threadMessages'];
   hideDateSeparators?: boolean;
   maxTimeBetweenGroupedMessages?: number;
   noGroupByUser?: boolean;
@@ -21,13 +19,11 @@ export type GetGroupStylesParams<
 
 export type GroupStyle = '' | 'middle' | 'top' | 'bottom' | 'single';
 
-const getGroupStyle = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
+const getGroupStyle = (
   dateSeparators: DateSeparators,
-  message: MessageType<StreamChatGenerics>,
-  previousMessage: MessageType<StreamChatGenerics>,
-  nextMessage: MessageType<StreamChatGenerics>,
+  message: LocalMessage,
+  previousMessage: LocalMessage,
+  nextMessage: LocalMessage,
   hideDateSeparators?: boolean,
   maxTimeBetweenGroupedMessages?: number,
 ): GroupStyle[] => {
@@ -44,7 +40,7 @@ const getGroupStyle = <
     previousMessage.type === 'error' ||
     userId !== previousMessage?.user?.id ||
     !!isPrevMessageTypeDeleted ||
-    (!hideDateSeparators && dateSeparators[message.id]) ||
+    (!hideDateSeparators && dateSeparators[previousMessage.id]) ||
     isEditedMessage(previousMessage);
 
   const isBottomMessage =
@@ -101,11 +97,7 @@ const getGroupStyle = <
   return groupStyles;
 };
 
-export const getGroupStyles = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  params: GetGroupStylesParams<StreamChatGenerics>,
-) => {
+export const getGroupStyles = (params: GetGroupStylesParams) => {
   const {
     dateSeparators,
     hideDateSeparators,

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

@@ -1,13 +1,8 @@
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-import { MessageStatusTypes } from '../../../utils/utils';
+import { LocalMessage } from 'stream-chat';
 
-import type { MessageType } from '../hooks/useMessageList';
+import { MessageStatusTypes } from '../../../utils/utils';
 
-export const getLastReceivedMessage = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  messages: MessageType<StreamChatGenerics>[],
-) => {
+export const getLastReceivedMessage = (messages: LocalMessage[]) => {
   /**
    * There are no status on dates so they will be skipped
    */

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

@@ -0,0 +1,27 @@
+import { ChannelState, LocalMessage } from 'stream-chat';
+
+/**
+ * Get the number of users who have read the message
+ * @param message - The message to get the read state for
+ * @param read - The read state of the channel
+ * @returns The number of users who have read the message
+ */
+export const getReadState = (message: LocalMessage, read?: ChannelState['read']) => {
+  if (!read) {
+    return 0;
+  }
+
+  const readState = Object.values(read).reduce((acc, readState) => {
+    if (!readState.last_read) {
+      return acc;
+    }
+
+    if (message.created_at && message.created_at < readState.last_read) {
+      return acc + 1;
+    }
+
+    return acc;
+  }, 0);
+
+  return readState;
+};

package/src/components/MessageMenu/MessageMenu.tsx

@@ -13,14 +13,11 @@ import {
   useMessagesContext,
 } from '../../contexts/messagesContext/MessagesContext';
 import { useTheme } from '../../contexts/themeContext/ThemeContext';
-import { DefaultStreamChatGenerics } from '../../types/types';
 import { BottomSheetModal } from '../UIComponents/BottomSheetModal';
 
-export type MessageMenuProps<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = Partial<
+export type MessageMenuProps = Partial<
   Pick<
-    MessagesContextValue<StreamChatGenerics>,
+    MessagesContextValue,
     | 'MessageActionList'
     | 'MessageActionListItem'
     | 'MessageReactionPicker'
@@ -29,7 +26,7 @@ export type MessageMenuProps<
     | 'MessageUserReactionsItem'
   >
 > &
-  Partial<Pick<MessageContextValue<StreamChatGenerics>, 'message'>> & {
+  Partial<Pick<MessageContextValue, 'message'>> & {
     /**
      * Function to close the message actions bottom sheet
      * @returns void
@@ -59,11 +56,7 @@ export type MessageMenuProps<
     selectedReaction?: string;
   };
 
-export const MessageMenu = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  props: MessageMenuProps<StreamChatGenerics>,
-) => {
+export const MessageMenu = (props: MessageMenuProps) => {
   const {
     dismissOverlay,
     handleReaction,
@@ -87,8 +80,8 @@ export const MessageMenu = <
     MessageUserReactions: contextMessageUserReactions,
     MessageUserReactionsAvatar: contextMessageUserReactionsAvatar,
     MessageUserReactionsItem: contextMessageUserReactionsItem,
-  } = useMessagesContext<StreamChatGenerics>();
-  const { message: contextMessage } = useMessageContext<StreamChatGenerics>();
+  } = useMessagesContext();
+  const { message: contextMessage } = useMessageContext();
   const MessageActionList = propMessageActionList ?? contextMessageActionList;
   const MessageActionListItem = propMessageActionListItem ?? contextMessageActionListItem;
   const MessageReactionPicker = propMessageReactionPicker ?? contextMessageReactionPicker;

package/src/components/MessageMenu/MessageReactionPicker.tsx

@@ -12,13 +12,11 @@ import {
 import { useOwnCapabilitiesContext } from '../../contexts/ownCapabilitiesContext/OwnCapabilitiesContext';
 import { useTheme } from '../../contexts/themeContext/ThemeContext';
 import { NativeHandlers } from '../../native';
-import type { DefaultStreamChatGenerics } from '../../types/types';
+
 import { ReactionData } from '../../utils/utils';
 
-export type MessageReactionPickerProps<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = Pick<MessagesContextValue<StreamChatGenerics>, 'supportedReactions'> &
-  Pick<MessageContextValue<StreamChatGenerics>, 'handleReaction' | 'dismissOverlay'> & {
+export type MessageReactionPickerProps = Pick<MessagesContextValue, 'supportedReactions'> &
+  Pick<MessageContextValue, 'handleReaction' | 'dismissOverlay'> & {
     /**
      * An array of reaction types that the current user has reacted with
      */
@@ -43,11 +41,7 @@ const renderItem = ({ index, item }: { index: number; item: ReactionPickerItemTy
 /**
  * MessageReactionPicker - A high level component which implements all the logic required for a message overlay reaction list
  */
-export const MessageReactionPicker = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  props: MessageReactionPickerProps<StreamChatGenerics>,
-) => {
+export const MessageReactionPicker = (props: MessageReactionPickerProps) => {
   const {
     dismissOverlay,
     handleReaction,

package/src/components/MessageMenu/MessageUserReactions.tsx

@@ -14,18 +14,16 @@ import {
 } from '../../contexts/messagesContext/MessagesContext';
 import { useTheme } from '../../contexts/themeContext/ThemeContext';
 import { useTranslationContext } from '../../contexts/translationContext/TranslationContext';
-import { DefaultStreamChatGenerics, Reaction } from '../../types/types';
+import { Reaction } from '../../types/types';
 import { ReactionData } from '../../utils/utils';
 
-export type MessageUserReactionsProps<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = Partial<
+export type MessageUserReactionsProps = Partial<
   Pick<
-    MessagesContextValue<StreamChatGenerics>,
+    MessagesContextValue,
     'MessageUserReactionsAvatar' | 'MessageUserReactionsItem' | 'supportedReactions'
   >
 > &
-  Partial<Pick<MessageContextValue<StreamChatGenerics>, 'message'>> & {
+  Partial<Pick<MessageContextValue, 'message'>> & {
     /**
      * An array of reactions
      */

package/src/components/MessageMenu/MessageUserReactionsItem.tsx

@@ -7,12 +7,13 @@ import { MessagesContextValue } from '../../contexts/messagesContext/MessagesCon
 import { useTheme } from '../../contexts/themeContext/ThemeContext';
 import { Unknown } from '../../icons';
 
-import type { DefaultStreamChatGenerics, Reaction } from '../../types/types';
+import type { Reaction } from '../../types/types';
 import { ReactionData } from '../../utils/utils';
 
-export type MessageUserReactionsItemProps<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = Pick<MessagesContextValue<StreamChatGenerics>, 'MessageUserReactionsAvatar'> & {
+export type MessageUserReactionsItemProps = Pick<
+  MessagesContextValue,
+  'MessageUserReactionsAvatar'
+> & {
   /**
    * The reaction object
    */
@@ -23,13 +24,11 @@ export type MessageUserReactionsItemProps<
   supportedReactions: ReactionData[];
 };
 
-export const MessageUserReactionsItem = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const MessageUserReactionsItem = ({
   MessageUserReactionsAvatar,
   reaction,
   supportedReactions,
-}: MessageUserReactionsItemProps<StreamChatGenerics>) => {
+}: MessageUserReactionsItemProps) => {
   const { id, name, type } = reaction;
   const {
     theme: {

package/src/components/MessageMenu/__tests__/MessageUserReactions.test.tsx

@@ -4,7 +4,7 @@ import { Text } from 'react-native';
 
 import { fireEvent, render } from '@testing-library/react-native';
 
-import { ReactionResponse } from 'stream-chat';
+import { LocalMessage, ReactionResponse } from 'stream-chat';
 
 import {
   MessagesContextValue,
@@ -17,7 +17,6 @@ import {
   TranslationProvider,
 } from '../../../contexts/translationContext/TranslationContext';
 import { generateMessage } from '../../../mock-builders/generator/message';
-import { MessageType } from '../../MessageList/hooks/useMessageList';
 import * as useFetchReactionsModule from '../hooks/useFetchReactions';
 import { MessageUserReactions } from '../MessageUserReactions';
 import { MessageUserReactionsItemProps } from '../MessageUserReactionsItem';
@@ -35,7 +34,7 @@ const defaultProps = {
   message: {
     ...generateMessage(),
     reaction_groups: { like: { count: 1, sum_scores: 1 }, love: { count: 1, sum_scores: 1 } },
-  } as unknown as MessageType,
+  } as unknown as LocalMessage,
   supportedReactions: mockSupportedReactions,
 };
 

package/src/components/MessageMenu/hooks/useFetchReactions.ts

@@ -1,30 +1,24 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
 
-import { ReactionResponse, ReactionSort } from 'stream-chat';
+import { LocalMessage, ReactionResponse, ReactionSort } from 'stream-chat';
 
-import { MessageType } from '../../../components/MessageList/hooks/useMessageList';
 import { useChatContext } from '../../../contexts/chatContext/ChatContext';
 import { getReactionsForFilterSort } from '../../../store/apis/getReactionsforFilterSort';
-import { DefaultStreamChatGenerics } from '../../../types/types';
 
-export type UseFetchReactionParams<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
+export type UseFetchReactionParams = {
   limit?: number;
-  message?: MessageType<StreamChatGenerics>;
+  message?: LocalMessage;
   reactionType?: string;
-  sort?: ReactionSort<StreamChatGenerics>;
+  sort?: ReactionSort;
 };
 
-export const useFetchReactions = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const useFetchReactions = ({
   limit = 25,
   message,
   reactionType,
   sort,
 }: UseFetchReactionParams) => {
-  const [reactions, setReactions] = useState<ReactionResponse<StreamChatGenerics>[]>([]);
+  const [reactions, setReactions] = useState<ReactionResponse[]>([]);
   const [loading, setLoading] = useState(true);
   const [next, setNext] = useState<string | undefined>(undefined);
   const messageId = message?.id;

package/src/components/Poll/Poll.tsx

@@ -14,12 +14,9 @@ import {
   useTheme,
   useTranslationContext,
 } from '../../contexts';
-import type { DefaultStreamChatGenerics } from '../../types/types';
 
-export type PollProps<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = Pick<PollContextValue<StreamChatGenerics>, 'poll' | 'message'> &
-  Pick<MessagesContextValue<StreamChatGenerics>, 'PollContent'>;
+export type PollProps = Pick<PollContextValue, 'poll' | 'message'> &
+  Pick<MessagesContextValue, 'PollContent'>;
 
 export type PollContentProps = {
   PollButtons?: React.ComponentType;
@@ -90,13 +87,7 @@ export const PollContent = ({
   );
 };
 
-export const Poll = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
-  message,
-  poll,
-  PollContent: PollContentOverride,
-}: PollProps<StreamChatGenerics>) => (
+export const Poll = ({ message, poll, PollContent: PollContentOverride }: PollProps) => (
   <PollContextProvider
     value={{
       message,

package/src/components/Poll/components/Button.tsx

@@ -1,22 +1,12 @@
 import React from 'react';
 import { Pressable, StyleSheet, Text } from 'react-native';
 
-import { Poll, PollOption } from 'stream-chat';
+import { LocalMessage, Poll, PollOption } from 'stream-chat';
 
 import { useTheme } from '../../../contexts';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-import { MessageType } from '../../MessageList/hooks/useMessageList';
 
-export type PollButtonProps<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
-  onPress?: ({
-    message,
-    poll,
-  }: {
-    message: MessageType<StreamChatGenerics>;
-    poll: Poll<StreamChatGenerics>;
-  }) => void;
+export type PollButtonProps = {
+  onPress?: ({ message, poll }: { message: LocalMessage; poll: Poll }) => void;
 };
 
 export type PollVoteButtonProps = {