stream-chat-react 12.14.0 → 13.0.0-rc.1

package/dist/components/Thread/Thread.js

@@ -1,20 +1,24 @@
-import React, { useEffect } from 'react';
+import React, { useContext, useEffect } from 'react';
 import clsx from 'clsx';
 import { MESSAGE_ACTIONS } from '../Message';
 import { MessageInput, MessageInputFlat } from '../MessageInput';
-import { MessageList, VirtualizedMessageList, } from '../MessageList';
+import { MessageList, VirtualizedMessageList } from '../MessageList';
 import { ThreadHeader as DefaultThreadHeader } from './ThreadHeader';
 import { ThreadHead as DefaultThreadHead } from '../Thread/ThreadHead';
 import { useChannelActionContext, useChannelStateContext, useChatContext, useComponentContext, } from '../../context';
 import { useThreadContext } from '../Threads';
 import { useStateStore } from '../../store';
+const LegacyThreadContext = React.createContext({ legacyThread: undefined });
+export const useLegacyThreadContext = () => useContext(LegacyThreadContext);
 /**
  * The Thread component renders a parent Message with a list of replies
  */
 export const Thread = (props) => {
     const { channel, channelConfig, thread } = useChannelStateContext('Thread');
     const threadInstance = useThreadContext();
-    if ((!thread && !threadInstance) || channelConfig?.replies === false)
+    if (!thread && !threadInstance)
+        return null;
+    if (channelConfig?.replies === false)
         return null;
     // the wrapper ensures a key variable is set and the component recreates on thread switch
     return (
@@ -30,22 +34,24 @@ const selector = (nextValue) => ({
 const ThreadInner = (props) => {
     const { additionalMessageInputProps, additionalMessageListProps, additionalParentMessageProps, additionalVirtualizedMessageListProps, autoFocus = true, enableDateSeparator = false, Input: PropInput, Message: PropMessage, messageActions = Object.keys(MESSAGE_ACTIONS), virtualized, } = props;
     const threadInstance = useThreadContext();
-    const { isLoadingNext, isLoadingPrev, parentMessage, replies } = useStateStore(threadInstance?.state, selector) ?? {};
     const { thread, threadHasMore, threadLoadingMore, threadMessages = [], threadSuppressAutoscroll, } = useChannelStateContext('Thread');
     const { closeThread, loadMoreThread } = useChannelActionContext('Thread');
     const { customClasses } = useChatContext('Thread');
     const { Message: ContextMessage, ThreadHead = DefaultThreadHead, ThreadHeader = DefaultThreadHeader, ThreadInput: ContextInput, VirtualMessage, } = useComponentContext('Thread');
+    const { isLoadingNext, isLoadingPrev, parentMessage, replies } = useStateStore(threadInstance?.state, selector) ?? {};
     const ThreadInput = PropInput ?? additionalMessageInputProps?.Input ?? ContextInput ?? MessageInputFlat;
     const ThreadMessage = PropMessage || additionalMessageListProps?.Message;
     const FallbackMessage = virtualized && VirtualMessage ? VirtualMessage : ContextMessage;
     const MessageUIComponent = ThreadMessage || FallbackMessage;
     const ThreadMessageList = virtualized ? VirtualizedMessageList : MessageList;
     useEffect(() => {
-        if (thread?.id && thread?.reply_count) {
+        if (threadInstance)
+            return;
+        if ((thread?.reply_count ?? 0) > 0) {
             // FIXME: integrators can customize channel query options but cannot customize channel.getReplies() options
             loadMoreThread();
         }
-    }, [thread, loadMoreThread]);
+    }, [thread, loadMoreThread, threadInstance]);
     const threadProps = threadInstance
         ? {
             loadingMore: isLoadingPrev,
@@ -68,10 +74,15 @@ const ThreadInner = (props) => {
             'str-chat__thread--virtualized': virtualized,
         });
     const head = (React.createElement(ThreadHead, { key: messageAsThread.id, message: messageAsThread, Message: MessageUIComponent, ...additionalParentMessageProps }));
-    return (React.createElement("div", { className: threadClass },
-        React.createElement(ThreadHeader, { closeThread: closeThread, thread: messageAsThread }),
-        React.createElement(ThreadMessageList, { disableDateSeparator: !enableDateSeparator, head: head, Message: MessageUIComponent, messageActions: messageActions, suppressAutoscroll: threadSuppressAutoscroll, threadList: true, ...threadProps, ...(virtualized
-                ? additionalVirtualizedMessageListProps
-                : additionalMessageListProps) }),
-        React.createElement(MessageInput, { focus: autoFocus, Input: ThreadInput, isThreadInput: true, parent: thread ?? parentMessage, publishTypingEvent: false, ...additionalMessageInputProps })));
+    return (
+    // Thread component needs a context which we can use for message composer
+    React.createElement(LegacyThreadContext.Provider, { value: {
+            legacyThread: thread ?? undefined,
+        } },
+        React.createElement("div", { className: threadClass },
+            React.createElement(ThreadHeader, { closeThread: closeThread, thread: messageAsThread }),
+            React.createElement(ThreadMessageList, { disableDateSeparator: !enableDateSeparator, head: head, Message: MessageUIComponent, messageActions: messageActions, suppressAutoscroll: threadSuppressAutoscroll, threadList: true, ...threadProps, ...(virtualized
+                    ? additionalVirtualizedMessageListProps
+                    : additionalMessageListProps) }),
+            React.createElement(MessageInput, { focus: autoFocus, Input: ThreadInput, isThreadInput: true, parent: thread ?? parentMessage, ...additionalMessageInputProps }))));
 };

package/dist/components/Thread/ThreadHead.d.ts

@@ -1,4 +1,3 @@
 import React from 'react';
-import { MessageProps } from '../Message';
-import type { DefaultStreamChatGenerics } from '../../types/types';
-export declare const ThreadHead: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(props: MessageProps<StreamChatGenerics>) => React.JSX.Element;
+import type { MessageProps } from '../Message';
+export declare const ThreadHead: (props: MessageProps) => React.JSX.Element;

package/dist/components/Thread/ThreadHeader.d.ts

@@ -1,11 +1,10 @@
 import React from 'react';
-import { ChannelPreviewInfoParams } from '../ChannelPreview/hooks/useChannelPreviewInfo';
-import { StreamMessage } from '../../context/ChannelStateContext';
-import type { DefaultStreamChatGenerics } from '../../types/types';
-export type ThreadHeaderProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
+import type { ChannelPreviewInfoParams } from '../ChannelPreview/hooks/useChannelPreviewInfo';
+import type { LocalMessage } from 'stream-chat';
+export type ThreadHeaderProps = {
     /** Callback for closing the thread */
     closeThread: (event?: React.BaseSyntheticEvent) => void;
     /** The thread parent message */
-    thread: StreamMessage<StreamChatGenerics>;
+    thread: LocalMessage;
 };
-export declare const ThreadHeader: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(props: ThreadHeaderProps<StreamChatGenerics> & Pick<ChannelPreviewInfoParams<StreamChatGenerics>, 'overrideImage' | 'overrideTitle'>) => React.JSX.Element;
+export declare const ThreadHeader: (props: ThreadHeaderProps & Pick<ChannelPreviewInfoParams, 'overrideImage' | 'overrideTitle'>) => React.JSX.Element;

package/dist/components/Thread/ThreadHeader.js

@@ -1,5 +1,5 @@
 import React from 'react';
-import { useChannelPreviewInfo, } from '../ChannelPreview/hooks/useChannelPreviewInfo';
+import { useChannelPreviewInfo } from '../ChannelPreview/hooks/useChannelPreviewInfo';
 import { CloseIcon } from './icons';
 import { useChannelStateContext } from '../../context/ChannelStateContext';
 import { useTranslationContext } from '../../context/TranslationContext';

package/dist/components/Threads/ThreadContext.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
 import type { PropsWithChildren } from 'react';
-import { Thread } from 'stream-chat';
+import type { Thread } from 'stream-chat';
 export type ThreadContextValue = Thread | undefined;
 export declare const ThreadContext: React.Context<ThreadContextValue>;
-export declare const useThreadContext: () => Thread<import("stream-chat").DefaultGenerics> | undefined;
+export declare const useThreadContext: () => ThreadContextValue;
 export declare const ThreadProvider: ({ children, thread, }: PropsWithChildren<{
     thread?: Thread;
 }>) => React.JSX.Element;

package/dist/components/Threads/ThreadContext.js

@@ -1,9 +1,6 @@
 import React, { createContext, useContext } from 'react';
 import { Channel } from '../../components';
 export const ThreadContext = createContext(undefined);
-export const useThreadContext = () => {
-    const thread = useContext(ThreadContext);
-    return thread ?? undefined;
-};
+export const useThreadContext = () => useContext(ThreadContext);
 export const ThreadProvider = ({ children, thread, }) => (React.createElement(ThreadContext.Provider, { value: thread },
     React.createElement(Channel, { channel: thread?.channel }, children)));

package/dist/components/Threads/ThreadList/ThreadList.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { VirtuosoProps } from 'react-virtuoso';
+import type { VirtuosoProps } from 'react-virtuoso';
 import type { Thread } from 'stream-chat';
 type ThreadListProps = {
     virtuosoProps?: VirtuosoProps<Thread, unknown>;

package/dist/components/Threads/ThreadList/ThreadListItem.d.ts

@@ -5,5 +5,5 @@ export type ThreadListItemProps = {
     thread: Thread;
     threadListItemUIProps?: ThreadListItemUIProps;
 };
-export declare const useThreadListItemContext: () => Thread<import("stream-chat").DefaultGenerics> | undefined;
+export declare const useThreadListItemContext: () => Thread | undefined;
 export declare const ThreadListItem: ({ thread, threadListItemUIProps, }: ThreadListItemProps) => React.JSX.Element;

package/dist/components/Threads/hooks/useThreadManagerState.d.ts

@@ -1,2 +1,2 @@
-import { ThreadManagerState } from 'stream-chat';
+import type { ThreadManagerState } from 'stream-chat';
 export declare const useThreadManagerState: <T extends readonly unknown[]>(selector: (nextValue: ThreadManagerState) => T) => T;

package/dist/components/Threads/hooks/useThreadState.d.ts

@@ -1,4 +1,4 @@
-import { ThreadState } from 'stream-chat';
+import type { ThreadState } from 'stream-chat';
 /**
  * @description returns thread state, prioritizes `ThreadListItemContext` falls back to `ThreadContext` if not former is not present
  */

package/dist/components/Threads/icons.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef } from 'react';
 export declare const Icon: {
     MessageBubble: (props: ComponentPropsWithoutRef<'svg'>) => React.JSX.Element;
     MessageBubbleEmpty: (props: ComponentPropsWithoutRef<'svg'>) => React.JSX.Element;

package/dist/components/Tooltip/Tooltip.d.ts

@@ -1,5 +1,6 @@
-import React, { ComponentProps } from 'react';
-import { PopperProps } from 'react-popper';
+import type { ComponentProps } from 'react';
+import React from 'react';
+import type { PopperProps } from 'react-popper';
 export declare const Tooltip: ({ children, ...rest }: ComponentProps<'div'>) => React.JSX.Element;
 export type PopperTooltipProps<T extends HTMLElement> = React.PropsWithChildren<{
     /** Reference element to which the tooltip should attach to */

package/dist/components/Tooltip/hooks/useEnterLeaveHandlers.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
+import type React from 'react';
 export declare const useEnterLeaveHandlers: <T extends HTMLElement>({ onMouseEnter, onMouseLeave, }?: Partial<Record<'onMouseEnter' | 'onMouseLeave', React.MouseEventHandler<T>>>) => {
     handleEnter: React.MouseEventHandler<T>;
     handleLeave: React.MouseEventHandler<T>;

package/dist/components/TypingIndicator/TypingIndicator.d.ts

@@ -1,7 +1,6 @@
 import React from 'react';
-import type { DefaultStreamChatGenerics } from '../../types/types';
 export type TypingIndicatorProps = {
     /** Whether the typing indicator is in a thread */
     threadList?: boolean;
 };
-export declare const TypingIndicator: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(props: TypingIndicatorProps) => React.JSX.Element | null;
+export declare const TypingIndicator: (props: TypingIndicatorProps) => React.JSX.Element | null;

package/dist/components/Window/Window.d.ts

@@ -1,11 +1,11 @@
-import React, { PropsWithChildren } from 'react';
-import { StreamMessage } from '../../context/ChannelStateContext';
-import type { DefaultStreamChatGenerics } from '../../types/types';
-export type WindowProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
+import type { PropsWithChildren } from 'react';
+import React from 'react';
+import type { LocalMessage } from 'stream-chat';
+export type WindowProps = {
     /** optional prop to force addition of class str-chat__main-panel---with-thread-opn to the Window root element */
-    thread?: StreamMessage<StreamChatGenerics>;
+    thread?: LocalMessage;
 };
 /**
  * A UI component for conditionally displaying a Thread or Channel
  */
-export declare const Window: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(props: PropsWithChildren<WindowProps<StreamChatGenerics>>) => React.JSX.Element;
+export declare const Window: (props: PropsWithChildren<WindowProps>) => React.JSX.Element;

package/dist/components/index.d.ts

@@ -1,5 +1,4 @@
 export * from './Attachment';
-export * from './AutoCompleteTextarea';
 export * from './Avatar';
 export * from './Channel';
 export * from './ChannelHeader';
@@ -7,11 +6,8 @@ export * from './ChannelList';
 export * from './ChannelPreview';
 export * from './ChannelSearch';
 export * from './Chat';
-export * from './ChatAutoComplete';
-export * from './CommandItem';
 export * from './DateSeparator';
 export * from './Dialog';
-export * from './EmoticonItem';
 export * from './EmptyStateIndicator';
 export * from './EventComponent';
 export * from './Gallery';
@@ -29,10 +25,10 @@ export * from './Modal';
 export * from './Poll';
 export * from './Reactions';
 export * from './SafeAnchor';
+export * from './TextareaComposer';
 export * from './Thread';
 export * from './Tooltip';
 export * from './TypingIndicator';
-export * from './UserItem';
 export * from './Window';
 export * from './Threads';
 export * from './ChatView';

package/dist/components/index.js

@@ -1,5 +1,4 @@
 export * from './Attachment';
-export * from './AutoCompleteTextarea';
 export * from './Avatar';
 export * from './Channel';
 export * from './ChannelHeader';
@@ -7,11 +6,8 @@ export * from './ChannelList';
 export * from './ChannelPreview';
 export * from './ChannelSearch';
 export * from './Chat';
-export * from './ChatAutoComplete';
-export * from './CommandItem';
 export * from './DateSeparator';
 export * from './Dialog';
-export * from './EmoticonItem';
 export * from './EmptyStateIndicator';
 export * from './EventComponent';
 export * from './Gallery';
@@ -28,10 +24,10 @@ export * from './Modal';
 export * from './Poll';
 export * from './Reactions';
 export * from './SafeAnchor';
+export * from './TextareaComposer';
 export * from './Thread';
 export * from './Tooltip';
 export * from './TypingIndicator';
-export * from './UserItem';
 export * from './Window';
 export * from './Threads';
 export * from './ChatView';

package/dist/context/AttachmentSelectorContext.d.ts

@@ -1,4 +1,5 @@
-import React, { PropsWithChildren } from 'react';
+import type { PropsWithChildren } from 'react';
+import React from 'react';
 export type AttachmentSelectorContextValue = {
     fileInput: HTMLInputElement | null;
 };

package/dist/context/ChannelActionContext.d.ts

@@ -1,9 +1,9 @@
-import React, { PropsWithChildren } from 'react';
-import type { APIErrorResponse, Attachment, ErrorFromResponse, Message, MessageResponse, UpdatedMessage, UpdateMessageAPIResponse, UserResponse } from 'stream-chat';
-import type { StreamMessage } from './ChannelStateContext';
+import type { PropsWithChildren } from 'react';
+import React from 'react';
+import type { LocalMessage, Message, MessageResponse, SendMessageOptions, UpdateMessageAPIResponse, UpdateMessageOptions } from 'stream-chat';
 import type { ChannelStateReducerAction } from '../components/Channel/channelState';
 import type { CustomMentionHandler } from '../components/Message/hooks/useMentionsHandler';
-import type { ChannelUnreadUiState, DefaultStreamChatGenerics, SendMessageOptions, UnknownType, UpdateMessageOptions } from '../types/types';
+import type { ChannelUnreadUiState, UnknownType } from '../types/types';
 export type MarkReadWrapperOptions = {
     /**
      * Signal, whether the `channelUnreadUiState` should be updated.
@@ -12,25 +12,13 @@ export type MarkReadWrapperOptions = {
      */
     updateChannelUiUnreadState?: boolean;
 };
-export type MessageAttachments<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = Array<Attachment<StreamChatGenerics>>;
-export type MessageToSend<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
-    attachments?: MessageAttachments<StreamChatGenerics>;
-    error?: ErrorFromResponse<APIErrorResponse>;
-    errorStatusCode?: number;
-    id?: string;
-    mentioned_users?: UserResponse<StreamChatGenerics>[];
-    parent?: StreamMessage<StreamChatGenerics>;
-    parent_id?: string;
-    status?: string;
-    text?: string;
-};
-export type RetrySendMessage<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = (message: StreamMessage<StreamChatGenerics>) => Promise<void>;
-export type ChannelActionContextValue<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
+export type RetrySendMessage = (message: LocalMessage) => Promise<void>;
+export type ChannelActionContextValue = {
     addNotification: (text: string, type: 'success' | 'error') => void;
     closeThread: (event?: React.BaseSyntheticEvent) => void;
-    deleteMessage: (message: StreamMessage<StreamChatGenerics>) => Promise<MessageResponse<StreamChatGenerics>>;
-    dispatch: React.Dispatch<ChannelStateReducerAction<StreamChatGenerics>>;
-    editMessage: (message: UpdatedMessage<StreamChatGenerics>, options?: UpdateMessageOptions) => Promise<UpdateMessageAPIResponse<StreamChatGenerics> | void>;
+    deleteMessage: (message: LocalMessage) => Promise<MessageResponse>;
+    dispatch: React.Dispatch<ChannelStateReducerAction>;
+    editMessage: (message: LocalMessage | MessageResponse, options?: UpdateMessageOptions) => Promise<UpdateMessageAPIResponse | void>;
     jumpToFirstUnreadMessage: (queryMessageLimit?: number, highlightDuration?: number) => Promise<void>;
     jumpToLatestMessage: () => Promise<void>;
     jumpToMessage: (messageId: string, limit?: number, highlightDuration?: number) => Promise<void>;
@@ -38,27 +26,30 @@ export type ChannelActionContextValue<StreamChatGenerics extends DefaultStreamCh
     loadMoreNewer: (limit?: number) => Promise<number>;
     loadMoreThread: () => Promise<void>;
     markRead: (options?: MarkReadWrapperOptions) => void;
-    onMentionsClick: CustomMentionHandler<StreamChatGenerics>;
-    onMentionsHover: CustomMentionHandler<StreamChatGenerics>;
-    openThread: (message: StreamMessage<StreamChatGenerics>, event?: React.BaseSyntheticEvent) => void;
-    removeMessage: (message: StreamMessage<StreamChatGenerics>) => void;
-    retrySendMessage: RetrySendMessage<StreamChatGenerics>;
-    sendMessage: (message: MessageToSend<StreamChatGenerics>, customMessageData?: Partial<Message<StreamChatGenerics>>, options?: SendMessageOptions) => Promise<void>;
+    onMentionsClick: CustomMentionHandler;
+    onMentionsHover: CustomMentionHandler;
+    openThread: (message: LocalMessage, event?: React.BaseSyntheticEvent) => void;
+    removeMessage: (message: LocalMessage) => void;
+    retrySendMessage: RetrySendMessage;
+    sendMessage: (params: {
+        localMessage: LocalMessage;
+        message: Message;
+        options?: SendMessageOptions;
+    }) => Promise<void>;
     setChannelUnreadUiState: React.Dispatch<React.SetStateAction<ChannelUnreadUiState | undefined>>;
-    setQuotedMessage: React.Dispatch<React.SetStateAction<StreamMessage<StreamChatGenerics> | undefined>>;
-    updateMessage: (message: StreamMessage<StreamChatGenerics>) => void;
+    updateMessage: (message: MessageResponse | LocalMessage) => void;
 };
-export declare const ChannelActionContext: React.Context<ChannelActionContextValue<DefaultStreamChatGenerics> | undefined>;
-export declare const ChannelActionProvider: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ children, value, }: PropsWithChildren<{
-    value: ChannelActionContextValue<StreamChatGenerics>;
+export declare const ChannelActionContext: React.Context<ChannelActionContextValue | undefined>;
+export declare const ChannelActionProvider: ({ children, value, }: PropsWithChildren<{
+    value: ChannelActionContextValue;
 }>) => React.JSX.Element;
-export declare const useChannelActionContext: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(componentName?: string) => ChannelActionContextValue<StreamChatGenerics>;
+export declare const useChannelActionContext: (componentName?: string) => ChannelActionContextValue;
 /**
  * Typescript currently does not support partial inference, so if ChannelActionContext
  * typing is desired while using the HOC withChannelActionContext, the Props for the
  * wrapped component must be provided as the first generic.
  */
-export declare const withChannelActionContext: <P extends UnknownType, StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(Component: React.ComponentType<P>) => {
-    (props: Omit<P, keyof ChannelActionContextValue<StreamChatGenerics>>): React.JSX.Element;
+export declare const withChannelActionContext: <P extends UnknownType>(Component: React.ComponentType<P>) => {
+    (props: Omit<P, keyof ChannelActionContextValue>): React.JSX.Element;
     displayName: string;
 };

package/dist/context/ChannelListContext.d.ts

@@ -1,22 +1,22 @@
-import React, { Dispatch, PropsWithChildren, SetStateAction } from 'react';
+import type { Dispatch, PropsWithChildren, SetStateAction } from 'react';
+import React from 'react';
 import type { Channel } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../types/types';
-export type ChannelListContextValue<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
+export type ChannelListContextValue = {
     /**
      * State representing the array of loaded channels.
      * Channels query is executed by default only by ChannelList component in the SDK.
      */
-    channels: Channel<StreamChatGenerics>[];
+    channels: Channel[];
     /**
      * Sets the list of Channel objects to be rendered by ChannelList component.
      */
-    setChannels: Dispatch<SetStateAction<Channel<StreamChatGenerics>[]>>;
+    setChannels: Dispatch<SetStateAction<Channel[]>>;
 };
-export declare const ChannelListContext: React.Context<ChannelListContextValue<DefaultStreamChatGenerics> | undefined>;
+export declare const ChannelListContext: React.Context<ChannelListContextValue | undefined>;
 /**
  * Context provider for components rendered within the `ChannelList`
  */
-export declare const ChannelListContextProvider: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ children, value, }: PropsWithChildren<{
-    value: ChannelListContextValue<StreamChatGenerics>;
+export declare const ChannelListContextProvider: ({ children, value, }: PropsWithChildren<{
+    value: ChannelListContextValue;
 }>) => React.JSX.Element;
-export declare const useChannelListContext: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(componentName?: string) => ChannelListContextValue<StreamChatGenerics>;
+export declare const useChannelListContext: (componentName?: string) => ChannelListContextValue;

package/dist/context/ChannelListContext.js

@@ -1,4 +1,4 @@
-import React, { createContext, useContext, } from 'react';
+import React, { createContext, useContext } from 'react';
 export const ChannelListContext = createContext(undefined);
 /**
  * Context provider for components rendered within the `ChannelList`

package/dist/context/ChannelStateContext.d.ts

@@ -1,14 +1,13 @@
-import React, { PropsWithChildren } from 'react';
-import type { Channel, ChannelConfigWithInfo, MessageResponse, Mute, ChannelState as StreamChannelState } from 'stream-chat';
-import type { ChannelUnreadUiState, DefaultStreamChatGenerics, GiphyVersions, ImageAttachmentSizeHandler, UnknownType, VideoAttachmentSizeHandler } from '../types/types';
-import type { URLEnrichmentConfig } from '../components/MessageInput/hooks/useLinkPreviews';
+import type { PropsWithChildren } from 'react';
+import React from 'react';
+import type { Channel, ChannelConfigWithInfo, LocalMessage, Mute, ChannelState as StreamChannelState } from 'stream-chat';
+import type { ChannelUnreadUiState, GiphyVersions, ImageAttachmentSizeHandler, UnknownType, VideoAttachmentSizeHandler } from '../types/types';
 export type ChannelNotifications = Array<{
     id: string;
     text: string;
     type: 'success' | 'error';
 }>;
-export type StreamMessage<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = ReturnType<StreamChannelState<StreamChatGenerics>['formatMessage']> | MessageResponse<StreamChatGenerics>;
-export type ChannelState<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
+export type ChannelState = {
     suppressAutoscroll: boolean;
     error?: Error | null;
     hasMore?: boolean;
@@ -17,52 +16,43 @@ export type ChannelState<StreamChatGenerics extends DefaultStreamChatGenerics =
     loading?: boolean;
     loadingMore?: boolean;
     loadingMoreNewer?: boolean;
-    members?: StreamChannelState<StreamChatGenerics>['members'];
-    messages?: StreamMessage<StreamChatGenerics>[];
-    pinnedMessages?: StreamMessage<StreamChatGenerics>[];
-    quotedMessage?: StreamMessage<StreamChatGenerics>;
-    read?: StreamChannelState<StreamChatGenerics>['read'];
-    thread?: StreamMessage<StreamChatGenerics> | null;
+    members?: StreamChannelState['members'];
+    messages?: LocalMessage[];
+    pinnedMessages?: LocalMessage[];
+    read?: StreamChannelState['read'];
+    thread?: LocalMessage | null;
     threadHasMore?: boolean;
     threadLoadingMore?: boolean;
-    threadMessages?: StreamMessage<StreamChatGenerics>[];
+    threadMessages?: LocalMessage[];
     threadSuppressAutoscroll?: boolean;
-    typing?: StreamChannelState<StreamChatGenerics>['typing'];
+    typing?: StreamChannelState['typing'];
     watcherCount?: number;
-    watchers?: StreamChannelState<StreamChatGenerics>['watchers'];
+    watchers?: StreamChannelState['watchers'];
 };
-export type ChannelStateContextValue<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = Omit<ChannelState<StreamChatGenerics>, 'typing'> & {
-    channel: Channel<StreamChatGenerics>;
+export type ChannelStateContextValue = Omit<ChannelState, 'typing'> & {
+    channel: Channel;
     channelCapabilities: Record<string, boolean>;
-    channelConfig: ChannelConfigWithInfo<StreamChatGenerics> | undefined;
+    channelConfig: ChannelConfigWithInfo | undefined;
     imageAttachmentSizeHandler: ImageAttachmentSizeHandler;
-    multipleUploads: boolean;
     notifications: ChannelNotifications;
     shouldGenerateVideoThumbnail: boolean;
     videoAttachmentSizeHandler: VideoAttachmentSizeHandler;
-    acceptedFiles?: string[];
-    channelUnreadUiState?: ChannelUnreadUiState<StreamChatGenerics>;
-    debounceURLEnrichmentMs?: URLEnrichmentConfig['debounceURLEnrichmentMs'];
-    dragAndDropWindow?: boolean;
-    enrichURLForPreview?: URLEnrichmentConfig['enrichURLForPreview'];
-    findURLFn?: URLEnrichmentConfig['findURLFn'];
+    channelUnreadUiState?: ChannelUnreadUiState;
     giphyVersion?: GiphyVersions;
-    maxNumberOfFiles?: number;
-    mutes?: Array<Mute<StreamChatGenerics>>;
-    onLinkPreviewDismissed?: URLEnrichmentConfig['onLinkPreviewDismissed'];
+    mutes?: Array<Mute>;
     watcher_count?: number;
 };
-export declare const ChannelStateContext: React.Context<ChannelStateContextValue<DefaultStreamChatGenerics> | undefined>;
-export declare const ChannelStateProvider: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ children, value, }: PropsWithChildren<{
-    value: ChannelStateContextValue<StreamChatGenerics>;
+export declare const ChannelStateContext: React.Context<ChannelStateContextValue | undefined>;
+export declare const ChannelStateProvider: ({ children, value, }: PropsWithChildren<{
+    value: ChannelStateContextValue;
 }>) => React.JSX.Element;
-export declare const useChannelStateContext: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(componentName?: string) => ChannelStateContextValue<StreamChatGenerics>;
+export declare const useChannelStateContext: (componentName?: string) => ChannelStateContextValue;
 /**
  * Typescript currently does not support partial inference, so if ChannelStateContext
  * typing is desired while using the HOC withChannelStateContext, the Props for the
  * wrapped component must be provided as the first generic.
  */
-export declare const withChannelStateContext: <P extends UnknownType, StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(Component: React.ComponentType<P>) => {
-    (props: Omit<P, keyof ChannelStateContextValue<StreamChatGenerics>>): React.JSX.Element;
+export declare const withChannelStateContext: <P extends UnknownType>(Component: React.ComponentType<P>) => {
+    (props: Omit<P, keyof ChannelStateContextValue>): React.JSX.Element;
     displayName: string;
 };

package/dist/context/ChatContext.d.ts

@@ -1,30 +1,31 @@
-import React, { PropsWithChildren } from 'react';
+import React from 'react';
+import type { PropsWithChildren } from 'react';
 import type { AppSettingsAPIResponse, Channel, Mute, SearchController } from 'stream-chat';
 import type { ChatProps } from '../components/Chat/Chat';
-import type { DefaultStreamChatGenerics, UnknownType } from '../types/types';
+import type { UnknownType } from '../types/types';
 import type { ChannelsQueryState } from '../components/Chat/hooks/useChannelsQueryState';
 type CSSClasses = 'chat' | 'chatContainer' | 'channel' | 'channelList' | 'message' | 'messageList' | 'thread' | 'threadList' | 'virtualMessage' | 'virtualizedMessageList';
 export type CustomClasses = Partial<Record<CSSClasses, string>>;
-type ChannelCID = string;
-export type ChatContextValue<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
+type ChannelConfId = string;
+export type ChatContextValue = {
     /**
      * Indicates, whether a channels query has been triggered within ChannelList by its channels pagination controller.
      */
     channelsQueryState: ChannelsQueryState;
     closeMobileNav: () => void;
-    getAppSettings: () => Promise<AppSettingsAPIResponse<StreamChatGenerics>> | null;
-    latestMessageDatesByChannels: Record<ChannelCID, Date>;
-    mutes: Array<Mute<StreamChatGenerics>>;
+    getAppSettings: () => Promise<AppSettingsAPIResponse> | null;
+    latestMessageDatesByChannels: Record<ChannelConfId, Date>;
+    mutes: Array<Mute>;
     openMobileNav: () => void;
     /** Instance of SearchController class that allows to control all the search operations. */
-    searchController: SearchController<StreamChatGenerics>;
+    searchController: SearchController;
     /**
      * Sets active channel to be rendered within Channel component.
      * @param newChannel
      * @param watchers
      * @param event
      */
-    setActiveChannel: (newChannel?: Channel<StreamChatGenerics>, watchers?: {
+    setActiveChannel: (newChannel?: Channel, watchers?: {
         limit?: number;
         offset?: number;
     }, event?: React.BaseSyntheticEvent) => void;
@@ -32,25 +33,25 @@ export type ChatContextValue<StreamChatGenerics extends DefaultStreamChatGeneric
     /**
      * Active channel used to render the contents of the Channel component.
      */
-    channel?: Channel<StreamChatGenerics>;
+    channel?: Channel;
     /**
      * Object through which custom classes can be set for main container components of the SDK.
      */
     customClasses?: CustomClasses;
     navOpen?: boolean;
-} & Partial<Pick<ChatProps<StreamChatGenerics>, 'isMessageAIGenerated'>> & Required<Pick<ChatProps<StreamChatGenerics>, 'theme' | 'client'>>;
-export declare const ChatContext: React.Context<ChatContextValue<DefaultStreamChatGenerics> | undefined>;
-export declare const ChatProvider: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ children, value, }: PropsWithChildren<{
-    value: ChatContextValue<StreamChatGenerics>;
+} & Partial<Pick<ChatProps, 'isMessageAIGenerated'>> & Required<Pick<ChatProps, 'theme' | 'client'>>;
+export declare const ChatContext: React.Context<ChatContextValue | undefined>;
+export declare const ChatProvider: ({ children, value, }: PropsWithChildren<{
+    value: ChatContextValue;
 }>) => React.JSX.Element;
-export declare const useChatContext: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(componentName?: string) => ChatContextValue<StreamChatGenerics>;
+export declare const useChatContext: (componentName?: string) => ChatContextValue;
 /**
  * Typescript currently does not support partial inference so if ChatContext
  * typing is desired while using the HOC withChatContext the Props for the
  * wrapped component must be provided as the first generic.
  */
-export declare const withChatContext: <P extends UnknownType, StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(Component: React.ComponentType<P>) => {
-    (props: Omit<P, keyof ChatContextValue<StreamChatGenerics>>): React.JSX.Element;
+export declare const withChatContext: <P extends UnknownType>(Component: React.ComponentType<P>) => {
+    (props: Omit<P, keyof ChatContextValue>): React.JSX.Element;
     displayName: string;
 };
 export {};