stream-chat-react-native-core 6.6.8-beta.3 → 7.0.0-rc.2

package/src/components/Channel/hooks/useChannelDataState.ts

@@ -2,7 +2,6 @@ import { useCallback, useState } from 'react';
 
 import { Channel, ChannelState as StreamChannelState } from 'stream-chat';
 
-import { DefaultStreamChatGenerics } from '../../../types/types';
 import { MessageType } from '../../MessageList/hooks/useMessageList';
 
 export const channelInitialState = {
@@ -24,53 +23,43 @@ export const channelInitialState = {
 /**
  * The ChannelMessagesState object
  */
-export type ChannelMessagesState<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
+export type ChannelMessagesState = {
   hasMore?: boolean;
   hasMoreNewer?: boolean;
   loading?: boolean;
   loadingMore?: boolean;
   loadingMoreRecent?: boolean;
-  messages?: StreamChannelState<StreamChatGenerics>['messages'];
-  pinnedMessages?: StreamChannelState<StreamChatGenerics>['pinnedMessages'];
+  messages?: StreamChannelState['messages'];
+  pinnedMessages?: StreamChannelState['pinnedMessages'];
   targetedMessageId?: string;
 };
 
 /**
  * The ChannelThreadState object
  */
-export type ChannelThreadState<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
-  thread: MessageType<StreamChatGenerics> | null;
+export type ChannelThreadState = {
+  thread: MessageType | null;
   threadHasMore?: boolean;
   threadLoadingMore?: boolean;
-  threadMessages?: StreamChannelState<StreamChatGenerics>['messages'];
+  threadMessages?: StreamChannelState['messages'];
 };
 
 /**
  * The ChannelState object
  */
-export type ChannelState<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = ChannelMessagesState<StreamChatGenerics> & {
-  members?: StreamChannelState<StreamChatGenerics>['members'];
-  read?: StreamChannelState<StreamChatGenerics>['read'];
-  typing?: StreamChannelState<StreamChatGenerics>['typing'];
+export type ChannelState = ChannelMessagesState & {
+  members?: StreamChannelState['members'];
+  read?: StreamChannelState['read'];
+  typing?: StreamChannelState['typing'];
   watcherCount?: number;
-  watchers?: StreamChannelState<StreamChatGenerics>['watchers'];
+  watchers?: StreamChannelState['watchers'];
 };
 
 /**
  * The useChannelMessageDataState hook that handles the state for the channel messages.
  */
-export const useChannelMessageDataState = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  channel: Channel<StreamChatGenerics>,
-) => {
-  const [state, setState] = useState<ChannelMessagesState<StreamChatGenerics>>({
+export const useChannelMessageDataState = (channel: Channel) => {
+  const [state, setState] = useState<ChannelMessagesState>({
     hasMore: true,
     hasMoreNewer: false,
     loading: false,
@@ -81,7 +70,7 @@ export const useChannelMessageDataState = <
     targetedMessageId: undefined,
   });
 
-  const copyMessagesStateFromChannel = useCallback((channel: Channel<StreamChatGenerics>) => {
+  const copyMessagesStateFromChannel = useCallback((channel: Channel) => {
     setState((prev) => ({
       ...prev,
       messages: [...channel.state.messages],
@@ -89,18 +78,15 @@ export const useChannelMessageDataState = <
     }));
   }, []);
 
-  const loadInitialMessagesStateFromChannel = useCallback(
-    (channel: Channel<StreamChatGenerics>, hasMore: boolean) => {
-      setState((prev) => ({
-        ...prev,
-        hasMore,
-        loading: false,
-        messages: [...channel.state.messages],
-        pinnedMessages: [...channel.state.pinnedMessages],
-      }));
-    },
-    [],
-  );
+  const loadInitialMessagesStateFromChannel = useCallback((channel: Channel, hasMore: boolean) => {
+    setState((prev) => ({
+      ...prev,
+      hasMore,
+      loading: false,
+      messages: [...channel.state.messages],
+      pinnedMessages: [...channel.state.pinnedMessages],
+    }));
+  }, []);
 
   const jumpToLatestMessage = useCallback(() => {
     setState((prev) => ({
@@ -120,17 +106,14 @@ export const useChannelMessageDataState = <
     }));
   }, []);
 
-  const loadMoreFinished = useCallback(
-    (hasMore: boolean, messages: ChannelState<StreamChatGenerics>['messages']) => {
-      setState((prev) => ({
-        ...prev,
-        hasMore,
-        loadingMore: false,
-        messages,
-      }));
-    },
-    [],
-  );
+  const loadMoreFinished = useCallback((hasMore: boolean, messages: ChannelState['messages']) => {
+    setState((prev) => ({
+      ...prev,
+      hasMore,
+      loadingMore: false,
+      messages,
+    }));
+  }, []);
 
   const setLoadingMore = useCallback((loadingMore: boolean) => {
     setState((prev) => ({
@@ -154,7 +137,7 @@ export const useChannelMessageDataState = <
   }, []);
 
   const loadMoreRecentFinished = useCallback(
-    (hasMoreNewer: boolean, messages: ChannelState<StreamChatGenerics>['messages']) => {
+    (hasMoreNewer: boolean, messages: ChannelState['messages']) => {
       setState((prev) => ({
         ...prev,
         hasMoreNewer,
@@ -182,12 +165,8 @@ export const useChannelMessageDataState = <
 /**
  * The useChannelThreadState hook that handles the state for the channel member, read, typing, watchers, etc.
  */
-export const useChannelDataState = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  channel: Channel<StreamChatGenerics>,
-) => {
-  const [state, setState] = useState<ChannelState<StreamChatGenerics>>({
+export const useChannelDataState = (channel: Channel) => {
+  const [state, setState] = useState<ChannelState>({
     members: channel.state.members,
     read: channel.state.read,
     typing: {},
@@ -196,7 +175,7 @@ export const useChannelDataState = <
   });
 
   const initStateFromChannel = useCallback(
-    (channel: Channel<StreamChatGenerics>) => {
+    (channel: Channel) => {
       setState({
         ...state,
         members: { ...channel.state.members },
@@ -209,7 +188,7 @@ export const useChannelDataState = <
     [state],
   );
 
-  const copyStateFromChannel = useCallback((channel: Channel<StreamChatGenerics>) => {
+  const copyStateFromChannel = useCallback((channel: Channel) => {
     setState((prev) => ({
       ...prev,
       members: { ...channel.state.members },
@@ -219,14 +198,14 @@ export const useChannelDataState = <
     }));
   }, []);
 
-  const setRead = useCallback((channel: Channel<StreamChatGenerics>) => {
+  const setRead = useCallback((channel: Channel) => {
     setState((prev) => ({
       ...prev,
       read: { ...channel.state.read }, // Synchronize the read state from the channel
     }));
   }, []);
 
-  const setTyping = useCallback((channel: Channel<StreamChatGenerics>) => {
+  const setTyping = useCallback((channel: Channel) => {
     setState((prev) => ({
       ...prev,
       typing: { ...channel.state.typing }, // Synchronize the typing state from the channel

package/src/components/Channel/hooks/useCreateChannelContext.ts

@@ -1,11 +1,8 @@
 import { useMemo } from 'react';
 
 import type { ChannelContextValue } from '../../../contexts/channelContext/ChannelContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
 
-export const useCreateChannelContext = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const useCreateChannelContext = ({
   channel,
   channelUnreadState,
   disabled,
@@ -39,7 +36,7 @@ export const useCreateChannelContext = <
   uploadAbortControllerRef,
   watcherCount,
   watchers,
-}: ChannelContextValue<StreamChatGenerics>) => {
+}: ChannelContextValue) => {
   const channelId = channel?.id;
   const lastReadTime = lastRead?.getTime();
   const membersLength = Object.keys(members).length;
@@ -49,7 +46,7 @@ export const useCreateChannelContext = <
   const readUsersLastReads = readUsers.map(({ last_read }) => last_read.toISOString()).join();
   const stringifiedChannelUnreadState = JSON.stringify(channelUnreadState);
 
-  const channelContext: ChannelContextValue<StreamChatGenerics> = useMemo(
+  const channelContext: ChannelContextValue = useMemo(
     () => ({
       channel,
       channelUnreadState,

package/src/components/Channel/hooks/useCreateInputMessageInputContext.ts

@@ -1,11 +1,8 @@
 import { useMemo } from 'react';
 
 import type { InputMessageInputContextValue } from '../../../contexts/messageInputContext/MessageInputContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
 
-export const useCreateInputMessageInputContext = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const useCreateInputMessageInputContext = ({
   additionalTextInputProps,
   asyncMessagesLockDistance,
   asyncMessagesMinimumPressDuration,
@@ -66,7 +63,7 @@ export const useCreateInputMessageInputContext = <
   StartAudioRecordingButton,
   StopMessageStreamingButton,
   UploadProgressIndicator,
-}: InputMessageInputContextValue<StreamChatGenerics> & {
+}: InputMessageInputContextValue & {
   /**
    * To ensure we allow re-render, when channel is changed
    */
@@ -75,7 +72,7 @@ export const useCreateInputMessageInputContext = <
   const editingDep = editing ? editing.id : '';
   const quotedMessageId = quotedMessage ? quotedMessage.id : '';
 
-  const inputMessageInputContext: InputMessageInputContextValue<StreamChatGenerics> = useMemo(
+  const inputMessageInputContext: InputMessageInputContextValue = useMemo(
     () => ({
       additionalTextInputProps,
       asyncMessagesLockDistance,

package/src/components/Channel/hooks/useCreateMessagesContext.ts

@@ -1,11 +1,8 @@
 import { useMemo } from 'react';
 
 import type { MessagesContextValue } from '../../../contexts/messagesContext/MessagesContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
 
-export const useCreateMessagesContext = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const useCreateMessagesContext = ({
   additionalPressableProps,
   Attachment,
   AttachmentActions,
@@ -111,7 +108,7 @@ export const useCreateMessagesContext = <
   updateMessage,
   UrlPreview,
   VideoThumbnail,
-}: MessagesContextValue<StreamChatGenerics> & {
+}: MessagesContextValue & {
   /**
    * To ensure we allow re-render, when channel is changed
    */
@@ -122,7 +119,7 @@ export const useCreateMessagesContext = <
   const messageContentOrderValue = messageContentOrder.join();
   const supportedReactionsLength = supportedReactions?.length;
 
-  const messagesContext: MessagesContextValue<StreamChatGenerics> = useMemo(
+  const messagesContext: MessagesContextValue = useMemo(
     () => ({
       additionalPressableProps,
       Attachment,

package/src/components/Channel/hooks/useCreateOwnCapabilitiesContext.ts

@@ -7,15 +7,12 @@ import {
   OwnCapabilitiesContextValue,
   OwnCapability,
 } from '../../../contexts/ownCapabilitiesContext/OwnCapabilitiesContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
 
-export const useCreateOwnCapabilitiesContext = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const useCreateOwnCapabilitiesContext = ({
   channel,
   overrideCapabilities,
 }: {
-  channel: Channel<StreamChatGenerics>;
+  channel: Channel;
   overrideCapabilities?: Partial<OwnCapabilitiesContextValue>;
 }) => {
   const [own_capabilities, setOwnCapabilites] = useState(

package/src/components/Channel/hooks/useCreatePaginatedMessageListContext.ts

@@ -1,12 +1,10 @@
 import { useMemo } from 'react';
 
 import type { PaginatedMessageListContextValue } from '../../../contexts/paginatedMessageListContext/PaginatedMessageListContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
+
 import { reduceMessagesToString } from '../../../utils/utils';
 
-export const useCreatePaginatedMessageListContext = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const useCreatePaginatedMessageListContext = ({
   channelId,
   hasMore,
   loadingMore,
@@ -17,12 +15,12 @@ export const useCreatePaginatedMessageListContext = <
   messages,
   setLoadingMore,
   setLoadingMoreRecent,
-}: PaginatedMessageListContextValue<StreamChatGenerics> & {
+}: PaginatedMessageListContextValue & {
   channelId?: string;
 }) => {
   const messagesStr = reduceMessagesToString(messages);
 
-  const paginatedMessagesContext: PaginatedMessageListContextValue<StreamChatGenerics> = useMemo(
+  const paginatedMessagesContext: PaginatedMessageListContextValue = useMemo(
     () => ({
       hasMore,
       loadingMore,

package/src/components/Channel/hooks/useCreateThreadContext.ts

@@ -2,7 +2,6 @@ import { ThreadState } from 'stream-chat';
 
 import type { ThreadContextValue } from '../../../contexts/threadContext/ThreadContext';
 import { useStateStore } from '../../../hooks';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
 
 const selector = (nextValue: ThreadState) =>
   ({
@@ -11,9 +10,7 @@ const selector = (nextValue: ThreadState) =>
     latestReplies: nextValue.replies,
   }) as const;
 
-export const useCreateThreadContext = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const useCreateThreadContext = ({
   allowThreadMessagesInChannel,
   closeThread,
   loadMoreThread,
@@ -25,7 +22,7 @@ export const useCreateThreadContext = <
   threadInstance,
   threadLoadingMore,
   threadMessages,
-}: ThreadContextValue<StreamChatGenerics>) => {
+}: ThreadContextValue) => {
   const { isLoadingNext, isLoadingPrev, latestReplies } =
     useStateStore(threadInstance?.state, selector) ?? {};
 

package/src/components/Channel/hooks/useCreateTypingContext.ts

@@ -1,16 +1,11 @@
 import { useMemo } from 'react';
 
 import type { TypingContextValue } from '../../../contexts/typingContext/TypingContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
 
-export const useCreateTypingContext = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
-  typing,
-}: TypingContextValue<StreamChatGenerics>) => {
+export const useCreateTypingContext = ({ typing }: TypingContextValue) => {
   const typingValue = Object.keys(typing).join();
 
-  const typingContext: TypingContextValue<StreamChatGenerics> = useMemo(
+  const typingContext: TypingContextValue = useMemo(
     () => ({
       typing,
     }),

package/src/components/Channel/hooks/useMessageListPagination.tsx

@@ -6,7 +6,6 @@ import { Channel, ChannelState, MessageResponse } from 'stream-chat';
 import { useChannelMessageDataState } from './useChannelDataState';
 
 import { ChannelContextValue } from '../../../contexts/channelContext/ChannelContext';
-import { DefaultStreamChatGenerics } from '../../../types/types';
 import { findInMessagesByDate, findInMessagesById } from '../../../utils/utils';
 
 const defaultDebounceInterval = 500;
@@ -21,13 +20,7 @@ const debounceOptions = {
  *
  * @param channel The channel object for which the message list pagination is being handled.
  */
-export const useMessageListPagination = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
-  channel,
-}: {
-  channel: Channel<StreamChatGenerics>;
-}) => {
+export const useMessageListPagination = ({ channel }: { channel: Channel }) => {
   const {
     copyMessagesStateFromChannel,
     jumpToLatestMessage,
@@ -39,12 +32,12 @@ export const useMessageListPagination = <
     setLoadingMore,
     setLoadingMoreRecent,
     state,
-  } = useChannelMessageDataState<StreamChatGenerics>(channel);
+  } = useChannelMessageDataState(channel);
 
   // hard limit to prevent you from scrolling faster than 1 page per 2 seconds
   const loadMoreFinished = useRef(
     debounce(
-      (hasMore: boolean, messages: ChannelState<StreamChatGenerics>['messages']) => {
+      (hasMore: boolean, messages: ChannelState['messages']) => {
         loadMoreFinishedFn(hasMore, messages);
       },
       defaultDebounceInterval,
@@ -55,7 +48,7 @@ export const useMessageListPagination = <
   // hard limit to prevent you from scrolling faster than 1 page per 2 seconds
   const loadMoreRecentFinished = useRef(
     debounce(
-      (hasMore: boolean, newMessages: ChannelState<StreamChatGenerics>['messages']) => {
+      (hasMore: boolean, newMessages: ChannelState['messages']) => {
         loadMoreRecentFinishedFn(hasMore, newMessages);
       },
       defaultDebounceInterval,
@@ -140,42 +133,43 @@ export const useMessageListPagination = <
    *
    * @param messageId If undefined, channel will be loaded at most recent message.
    */
-  const loadChannelAroundMessage: ChannelContextValue<StreamChatGenerics>['loadChannelAroundMessage'] =
-    async ({ limit = 25, messageId: messageIdToLoadAround, setTargetedMessage }) => {
-      if (!messageIdToLoadAround) {
-        return;
-      }
-      setLoadingMore(true);
-      setLoading(true);
-      try {
-        await channel.state.loadMessageIntoState(messageIdToLoadAround, undefined, limit);
-        loadMoreFinished(channel.state.messagePagination.hasPrev, channel.state.messages);
-        jumpToMessageFinished(channel.state.messagePagination.hasNext, messageIdToLoadAround);
+  const loadChannelAroundMessage: ChannelContextValue['loadChannelAroundMessage'] = async ({
+    limit = 25,
+    messageId: messageIdToLoadAround,
+    setTargetedMessage,
+  }) => {
+    if (!messageIdToLoadAround) {
+      return;
+    }
+    setLoadingMore(true);
+    setLoading(true);
+    try {
+      await channel.state.loadMessageIntoState(messageIdToLoadAround, undefined, limit);
+      loadMoreFinished(channel.state.messagePagination.hasPrev, channel.state.messages);
+      jumpToMessageFinished(channel.state.messagePagination.hasNext, messageIdToLoadAround);
 
-        if (setTargetedMessage) {
-          setTargetedMessage(messageIdToLoadAround);
-        }
-      } catch (error) {
-        setLoadingMore(false);
-        setLoading(false);
-        console.warn(
-          'Message pagination(fetching messages in the channel around a message id) request failed with error:',
-          error,
-        );
-        return;
+      if (setTargetedMessage) {
+        setTargetedMessage(messageIdToLoadAround);
       }
-    };
+    } catch (error) {
+      setLoadingMore(false);
+      setLoading(false);
+      console.warn(
+        'Message pagination(fetching messages in the channel around a message id) request failed with error:',
+        error,
+      );
+      return;
+    }
+  };
 
   /**
    * Fetch messages around a specific timestamp.
    */
-  const fetchMessagesAround = async <
-    StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-  >(
-    channel: Channel<StreamChatGenerics>,
+  const fetchMessagesAround = async (
+    channel: Channel,
     timestamp: string,
     limit: number,
-  ): Promise<MessageResponse<StreamChatGenerics>[]> => {
+  ): Promise<MessageResponse[]> => {
     try {
       const { messages } = await channel.query(
         { messages: { created_at_around: timestamp, limit } },
@@ -191,7 +185,7 @@ export const useMessageListPagination = <
   /**
    * Loads channel at first unread message.
    */
-  const loadChannelAtFirstUnreadMessage: ChannelContextValue<StreamChatGenerics>['loadChannelAtFirstUnreadMessage'] =
+  const loadChannelAtFirstUnreadMessage: ChannelContextValue['loadChannelAtFirstUnreadMessage'] =
     async ({ channelUnreadState, limit = 25, setChannelUnreadState, setTargetedMessage }) => {
       try {
         if (!channelUnreadState?.unread_messages) {