stream-chat-react 12.0.0-rc.9 → 12.1.0

package/dist/components/MessageList/VirtualizedMessageList.js

@@ -6,11 +6,15 @@ import { useGiphyPreview, useMessageSetKey, useNewMessageNotification, usePrepen
 import { useMarkRead } from './hooks/useMarkRead';
 import { MessageNotification as DefaultMessageNotification } from './MessageNotification';
 import { MessageListNotifications as DefaultMessageListNotifications } from './MessageListNotifications';
-import { MessageListMainPanel } from './MessageListMainPanel';
+import { MessageListMainPanel as DefaultMessageListMainPanel } from './MessageListMainPanel';
 import { getGroupStyles, getLastReceived, processMessages, } from './utils';
 import { MessageSimple } from '../Message';
 import { UnreadMessagesNotification as DefaultUnreadMessagesNotification } from './UnreadMessagesNotification';
 import { calculateFirstItemIndex, calculateItemIndex, EmptyPlaceholder, Header, Item, makeItemsRenderedHandler, messageRenderer, } from './VirtualizedMessageListComponents';
+import { UnreadMessagesSeparator as DefaultUnreadMessagesSeparator } from '../MessageList';
+import { DateSeparator as DefaultDateSeparator } from '../DateSeparator';
+import { EventComponent as DefaultMessageSystem } from '../EventComponent';
+import { DialogManagerProvider } from '../../context';
 import { useChannelActionContext, } from '../../context/ChannelActionContext';
 import { useChannelStateContext, } from '../../context/ChannelStateContext';
 import { useChatContext } from '../../context/ChatContext';
@@ -53,7 +57,7 @@ const VirtualizedMessageListWithContext = (props) => {
     // Stops errors generated from react-virtuoso to bubble up
     // to Sentry or other tracking tools.
     useCaptureResizeObserverExceededError();
-    const { DateSeparator, GiphyPreviewMessage = DefaultGiphyPreviewMessage, MessageListNotifications = DefaultMessageListNotifications, MessageNotification = DefaultMessageNotification, MessageSystem, UnreadMessagesNotification = DefaultUnreadMessagesNotification, UnreadMessagesSeparator, VirtualMessage: MessageUIComponentFromContext = MessageSimple, TypingIndicator, } = useComponentContext('VirtualizedMessageList');
+    const { DateSeparator = DefaultDateSeparator, GiphyPreviewMessage = DefaultGiphyPreviewMessage, MessageListNotifications = DefaultMessageListNotifications, MessageNotification = DefaultMessageNotification, MessageSystem = DefaultMessageSystem, MessageListMainPanel = DefaultMessageListMainPanel, UnreadMessagesNotification = DefaultUnreadMessagesNotification, UnreadMessagesSeparator = DefaultUnreadMessagesSeparator, VirtualMessage: MessageUIComponentFromContext = MessageSimple, TypingIndicator, } = useComponentContext('VirtualizedMessageList');
     const MessageUIComponent = MessageUIComponentFromProps || MessageUIComponentFromContext;
     const { client, customClasses } = useChatContext('VirtualizedMessageList');
     const virtuoso = useRef(null);
@@ -187,43 +191,44 @@ const VirtualizedMessageListWithContext = (props) => {
         return null;
     return (React.createElement(React.Fragment, null,
         React.createElement(MessageListMainPanel, null,
-            !threadList && showUnreadMessagesNotification && (React.createElement(UnreadMessagesNotification, { unreadCount: channelUnreadUiState?.unread_messages })),
-            React.createElement("div", { className: customClasses?.virtualizedMessageList || 'str-chat__virtual-list' },
-                React.createElement(Virtuoso, { atBottomStateChange: atBottomStateChange, atBottomThreshold: 100, atTopStateChange: atTopStateChange, atTopThreshold: 100, className: 'str-chat__message-list-scroll', components: {
-                        EmptyPlaceholder,
-                        Header,
-                        Item,
-                        ...virtuosoComponentsFromProps,
-                    }, computeItemKey: computeItemKey, context: {
-                        additionalMessageInputProps,
-                        closeReactionSelectorOnClick,
-                        customClasses,
-                        customMessageActions,
-                        customMessageRenderer,
-                        DateSeparator,
-                        firstUnreadMessageId: channelUnreadUiState?.first_unread_message_id,
-                        formatDate,
-                        head,
-                        lastReadDate: channelUnreadUiState?.last_read,
-                        lastReadMessageId: channelUnreadUiState?.last_read_message_id,
-                        lastReceivedMessageId,
-                        loadingMore,
-                        Message: MessageUIComponent,
-                        messageActions,
-                        messageGroupStyles,
-                        MessageSystem,
-                        numItemsPrepended,
-                        ownMessagesReadByOthers,
-                        processedMessages,
-                        reactionDetailsSort,
-                        shouldGroupByUser,
-                        sortReactionDetails,
-                        sortReactions,
-                        threadList,
-                        unreadMessageCount: channelUnreadUiState?.unread_messages,
-                        UnreadMessagesSeparator,
-                        virtuosoRef: virtuoso,
-                    }, firstItemIndex: calculateFirstItemIndex(numItemsPrepended), followOutput: followOutput, increaseViewportBy: { bottom: 200, top: 0 }, initialTopMostItemIndex: calculateInitialTopMostItemIndex(processedMessages, highlightedMessageId), itemContent: messageRenderer, itemSize: fractionalItemSize, itemsRendered: handleItemsRendered, key: messageSetKey, overscan: overscan, ref: virtuoso, style: { overflowX: 'hidden' }, totalCount: processedMessages.length, ...overridingVirtuosoProps, ...(scrollSeekPlaceHolder ? { scrollSeek: scrollSeekPlaceHolder } : {}), ...(defaultItemHeight ? { defaultItemHeight } : {}) })),
+            React.createElement(DialogManagerProvider, { id: 'virtualized-message-list-dialog-manager' },
+                !threadList && showUnreadMessagesNotification && (React.createElement(UnreadMessagesNotification, { unreadCount: channelUnreadUiState?.unread_messages })),
+                React.createElement("div", { className: customClasses?.virtualizedMessageList || 'str-chat__virtual-list' },
+                    React.createElement(Virtuoso, { atBottomStateChange: atBottomStateChange, atBottomThreshold: 100, atTopStateChange: atTopStateChange, atTopThreshold: 100, className: 'str-chat__message-list-scroll', components: {
+                            EmptyPlaceholder,
+                            Header,
+                            Item,
+                            ...virtuosoComponentsFromProps,
+                        }, computeItemKey: computeItemKey, context: {
+                            additionalMessageInputProps,
+                            closeReactionSelectorOnClick,
+                            customClasses,
+                            customMessageActions,
+                            customMessageRenderer,
+                            DateSeparator,
+                            firstUnreadMessageId: channelUnreadUiState?.first_unread_message_id,
+                            formatDate,
+                            head,
+                            lastReadDate: channelUnreadUiState?.last_read,
+                            lastReadMessageId: channelUnreadUiState?.last_read_message_id,
+                            lastReceivedMessageId,
+                            loadingMore,
+                            Message: MessageUIComponent,
+                            messageActions,
+                            messageGroupStyles,
+                            MessageSystem,
+                            numItemsPrepended,
+                            ownMessagesReadByOthers,
+                            processedMessages,
+                            reactionDetailsSort,
+                            shouldGroupByUser,
+                            sortReactionDetails,
+                            sortReactions,
+                            threadList,
+                            unreadMessageCount: channelUnreadUiState?.unread_messages,
+                            UnreadMessagesSeparator,
+                            virtuosoRef: virtuoso,
+                        }, firstItemIndex: calculateFirstItemIndex(numItemsPrepended), followOutput: followOutput, increaseViewportBy: { bottom: 200, top: 0 }, initialTopMostItemIndex: calculateInitialTopMostItemIndex(processedMessages, highlightedMessageId), itemContent: messageRenderer, itemSize: fractionalItemSize, itemsRendered: handleItemsRendered, key: messageSetKey, overscan: overscan, ref: virtuoso, style: { overflowX: 'hidden' }, totalCount: processedMessages.length, ...overridingVirtuosoProps, ...(scrollSeekPlaceHolder ? { scrollSeek: scrollSeekPlaceHolder } : {}), ...(defaultItemHeight ? { defaultItemHeight } : {}) }))),
             TypingIndicator && React.createElement(TypingIndicator, null)),
         React.createElement(MessageListNotifications, { hasNewMessages: newMessagesNotification, isMessageListScrolledToBottom: isMessageListScrolledToBottom, isNotAtLatestMessageSet: hasMoreNewer, MessageNotification: MessageNotification, notifications: notifications, scrollToBottom: scrollToBottom, threadList: threadList, unreadCount: threadList ? undefined : channelUnreadUiState?.unread_messages }),
         giphyPreviewMessage && React.createElement(GiphyPreviewMessage, { message: giphyPreviewMessage })));
@@ -236,5 +241,5 @@ export function VirtualizedMessageList(props) {
     const { jumpToLatestMessage, loadMore, loadMoreNewer, } = useChannelActionContext('VirtualizedMessageList');
     const { channel, channelUnreadUiState, hasMore, hasMoreNewer, highlightedMessageId, loadingMore, loadingMoreNewer, messages: contextMessages, notifications, read, suppressAutoscroll, } = useChannelStateContext('VirtualizedMessageList');
     const messages = props.messages || contextMessages;
-    return (React.createElement(VirtualizedMessageListWithContext, { channel: channel, channelUnreadUiState: channelUnreadUiState, hasMore: !!hasMore, hasMoreNewer: !!hasMoreNewer, highlightedMessageId: highlightedMessageId, jumpToLatestMessage: jumpToLatestMessage, loadingMore: !!loadingMore, loadingMoreNewer: !!loadingMoreNewer, loadMore: loadMore, loadMoreNewer: loadMoreNewer, messages: messages, notifications: notifications, read: read, suppressAutoscroll: suppressAutoscroll, ...props }));
+    return (React.createElement(VirtualizedMessageListWithContext, { channel: channel, channelUnreadUiState: props.channelUnreadUiState ?? channelUnreadUiState, hasMore: !!hasMore, hasMoreNewer: !!hasMoreNewer, highlightedMessageId: highlightedMessageId, jumpToLatestMessage: jumpToLatestMessage, loadingMore: !!loadingMore, loadingMoreNewer: !!loadingMoreNewer, loadMore: loadMore, loadMoreNewer: loadMoreNewer, messages: messages, notifications: notifications, read: read, suppressAutoscroll: suppressAutoscroll, ...props }));
 }

package/dist/components/MessageList/VirtualizedMessageListComponents.d.ts

@@ -11,7 +11,7 @@ type CommonVirtuosoComponentProps<StreamChatGenerics extends DefaultStreamChatGe
     context?: VirtuosoContext<StreamChatGenerics>;
 };
 export declare const Item: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ context, ...props }: ItemProps & CommonVirtuosoComponentProps<StreamChatGenerics>) => React.JSX.Element;
-export declare const Header: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ context, }: CommonVirtuosoComponentProps<StreamChatGenerics>) => React.JSX.Element | null;
+export declare const Header: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ context, }: CommonVirtuosoComponentProps<StreamChatGenerics>) => React.JSX.Element;
 export declare const EmptyPlaceholder: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ context, }: CommonVirtuosoComponentProps<StreamChatGenerics>) => React.JSX.Element;
 export declare const messageRenderer: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(virtuosoIndex: number, _data: UnknownType, virtuosoContext: VirtuosoContext<StreamChatGenerics>) => React.JSX.Element | null;
 export {};

package/dist/components/MessageList/VirtualizedMessageListComponents.js

@@ -37,17 +37,17 @@ export const Item = ({ context, ...props }) => {
 };
 export const Header = ({ context, }) => {
     const { LoadingIndicator = DefaultLoadingIndicator } = useComponentContext('VirtualizedMessageListHeader');
-    if (!context?.loadingMore)
-        return null;
-    return LoadingIndicator ? (React.createElement("div", { className: 'str-chat__virtual-list__loading' },
-        React.createElement(LoadingIndicator, { size: 20 }))) : (context?.head || null);
+    return (React.createElement(React.Fragment, null,
+        context?.head,
+        context?.loadingMore && LoadingIndicator && (React.createElement("div", { className: 'str-chat__virtual-list__loading' },
+            React.createElement(LoadingIndicator, { size: 20 })))));
 };
 export const EmptyPlaceholder = ({ context, }) => {
     const { EmptyStateIndicator = DefaultEmptyStateIndicator, } = useComponentContext('VirtualizedMessageList');
     return (React.createElement(React.Fragment, null, EmptyStateIndicator && (React.createElement(EmptyStateIndicator, { listType: context?.threadList ? 'thread' : 'message' }))));
 };
 export const messageRenderer = (virtuosoIndex, _data, virtuosoContext) => {
-    const { additionalMessageInputProps, closeReactionSelectorOnClick, customMessageActions, customMessageRenderer, DateSeparator, firstUnreadMessageId, formatDate, lastReadDate, lastReadMessageId, lastReceivedMessageId, Message: MessageUIComponent, messageActions, messageGroupStyles, MessageSystem, numItemsPrepended, ownMessagesReadByOthers, processedMessages: messageList, reactionDetailsSort, shouldGroupByUser, sortReactionDetails, sortReactions, unreadMessageCount = 0, UnreadMessagesSeparator, virtuosoRef, } = virtuosoContext;
+    const { additionalMessageInputProps, closeReactionSelectorOnClick, customMessageActions, customMessageRenderer, DateSeparator, firstUnreadMessageId, formatDate, lastReadDate, lastReadMessageId, lastReceivedMessageId, Message: MessageUIComponent, messageActions, messageGroupStyles, MessageSystem, numItemsPrepended, ownMessagesReadByOthers, processedMessages: messageList, reactionDetailsSort, shouldGroupByUser, sortReactionDetails, sortReactions, threadList, unreadMessageCount = 0, UnreadMessagesSeparator, virtuosoRef, } = virtuosoContext;
     const streamMessageIndex = calculateItemIndex(virtuosoIndex, numItemsPrepended);
     if (customMessageRenderer) {
         return customMessageRenderer(messageList, streamMessageIndex);
@@ -89,7 +89,7 @@ export const messageRenderer = (virtuosoIndex, _data, virtuosoContext) => {
     return (React.createElement(React.Fragment, null,
         showUnreadSeparatorAbove && (React.createElement("div", { className: 'str-chat__unread-messages-separator-wrapper' },
             React.createElement(UnreadMessagesSeparator, { unreadCount: unreadMessageCount }))),
-        React.createElement(Message, { additionalMessageInputProps: additionalMessageInputProps, autoscrollToBottom: virtuosoRef.current?.autoscrollToBottom, closeReactionSelectorOnClick: closeReactionSelectorOnClick, customMessageActions: customMessageActions, endOfGroup: endOfGroup, firstOfGroup: firstOfGroup, formatDate: formatDate, groupedByUser: groupedByUser, groupStyles: [messageGroupStyles[message.id] ?? ''], lastReceivedId: lastReceivedMessageId, message: message, Message: MessageUIComponent, messageActions: messageActions, reactionDetailsSort: reactionDetailsSort, readBy: ownMessagesReadByOthers[message.id] || [], sortReactionDetails: sortReactionDetails, sortReactions: sortReactions }),
+        React.createElement(Message, { additionalMessageInputProps: additionalMessageInputProps, autoscrollToBottom: virtuosoRef.current?.autoscrollToBottom, closeReactionSelectorOnClick: closeReactionSelectorOnClick, customMessageActions: customMessageActions, endOfGroup: endOfGroup, firstOfGroup: firstOfGroup, formatDate: formatDate, groupedByUser: groupedByUser, groupStyles: [messageGroupStyles[message.id] ?? ''], lastReceivedId: lastReceivedMessageId, message: message, Message: MessageUIComponent, messageActions: messageActions, reactionDetailsSort: reactionDetailsSort, readBy: ownMessagesReadByOthers[message.id] || [], sortReactionDetails: sortReactionDetails, sortReactions: sortReactions, threadList: threadList }),
         showUnreadSeparatorBelow && (React.createElement("div", { className: 'str-chat__unread-messages-separator-wrapper' },
             React.createElement(UnreadMessagesSeparator, { unreadCount: unreadMessageCount })))));
 };

package/dist/components/MessageList/hooks/MessageList/useUnreadMessagesNotification.js

@@ -21,10 +21,10 @@ export const useUnreadMessagesNotification = ({ isMessageListScrolledToBottom, s
             setShow(false);
             return;
         }
-        const msgListPanel = document.querySelector(`.${MESSAGE_LIST_MAIN_PANEL_CLASS}`);
+        const [msgListPanel] = document.getElementsByClassName(MESSAGE_LIST_MAIN_PANEL_CLASS);
         if (!msgListPanel)
             return;
-        const observedTarget = document.querySelector(`.${UNREAD_MESSAGE_SEPARATOR_CLASS}`);
+        const [observedTarget] = document.getElementsByClassName(UNREAD_MESSAGE_SEPARATOR_CLASS);
         if (!observedTarget) {
             setShow(true);
             return;

package/dist/components/MessageList/renderMessages.d.ts

@@ -1,10 +1,10 @@
 import React, { ReactNode } from 'react';
+import type { UserResponse } from 'stream-chat';
 import { GroupStyle } from './utils';
-import { MessageProps } from '../Message';
 import { ComponentContextValue, CustomClasses } from '../../context';
-import type { UserResponse } from 'stream-chat';
 import type { ChannelUnreadUiState, DefaultStreamChatGenerics } from '../../types';
 import type { StreamMessage } from '../../context/ChannelStateContext';
+import type { MessageProps } from '../Message';
 export interface RenderMessagesOptions<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> {
     components: ComponentContextValue<StreamChatGenerics>;
     lastReceivedMessageId: string | null;

package/dist/components/MessageList/renderMessages.js

@@ -1,9 +1,12 @@
 import React, { Fragment } from 'react';
 import { isDateSeparatorMessage } from './utils';
 import { Message } from '../Message';
+import { DateSeparator as DefaultDateSeparator } from '../DateSeparator';
+import { EventComponent as DefaultMessageSystem } from '../EventComponent';
+import { UnreadMessagesSeparator as DefaultUnreadMessagesSeparator } from './UnreadMessagesSeparator';
 import { CUSTOM_MESSAGE_TYPE } from '../../constants/messageTypes';
 export function defaultRenderMessages({ channelUnreadUiState, components, customClasses, lastReceivedMessageId: lastReceivedId, messageGroupStyles, messages, readData, sharedMessageProps: messageProps, }) {
-    const { DateSeparator, HeaderComponent, MessageSystem, UnreadMessagesSeparator } = components;
+    const { DateSeparator = DefaultDateSeparator, HeaderComponent, MessageSystem = DefaultMessageSystem, UnreadMessagesSeparator = DefaultUnreadMessagesSeparator, } = components;
     const renderedMessages = [];
     let firstMessage;
     for (let index = 0; index < messages.length; index++) {

package/dist/components/MessageList/utils.js

@@ -1,8 +1,8 @@
 /* eslint-disable no-continue */
 import { nanoid } from 'nanoid';
 import { CUSTOM_MESSAGE_TYPE } from '../../constants/messageTypes';
-import { isDate } from '../../context/TranslationContext';
 import { isMessageEdited } from '../Message/utils';
+import { isDate } from '../../i18n';
 /**
  * processMessages - Transform the input message list according to config parameters
  *

package/dist/components/Reactions/ReactionSelector.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { AvatarProps } from '../Avatar';
 import type { ReactionGroupResponse, ReactionResponse } from 'stream-chat';
+import type { AvatarProps } from '../Avatar';
 import type { DefaultStreamChatGenerics } from '../../types/types';
 import type { ReactionOptions } from './reactionOptions';
 export type ReactionSelectorProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
@@ -21,7 +21,10 @@ export type ReactionSelectorProps<StreamChatGenerics extends DefaultStreamChatGe
     reaction_counts?: Record<string, number>;
     /** An object containing summary for each reaction type on a message */
     reaction_groups?: Record<string, ReactionGroupResponse>;
-    /** A list of the currently supported reactions on a message */
+    /**
+     * @deprecated
+     * A list of the currently supported reactions on a message
+     * */
     reactionOptions?: ReactionOptions;
     /** If true, adds a CSS class that reverses the horizontal positioning of the selector */
     reverse?: boolean;
@@ -29,4 +32,4 @@ export type ReactionSelectorProps<StreamChatGenerics extends DefaultStreamChatGe
 /**
  * Component that allows a user to select a reaction.
  */
-export declare const ReactionSelector: React.ForwardRefExoticComponent<ReactionSelectorProps<DefaultStreamChatGenerics> & React.RefAttributes<HTMLDivElement | null>>;
+export declare const ReactionSelector: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(props: ReactionSelectorProps<StreamChatGenerics>) => React.JSX.Element;

package/dist/components/Reactions/ReactionSelector.js

@@ -1,13 +1,17 @@
 import React, { useCallback, useEffect, useRef, useState } from 'react';
 import clsx from 'clsx';
-import { isMutableRef } from './utils/utils';
 import { Avatar as DefaultAvatar } from '../Avatar';
+import { useDialog } from '../Dialog';
+import { defaultReactionOptions } from './reactionOptions';
+import { isMutableRef } from './utils/utils';
 import { useComponentContext } from '../../context/ComponentContext';
 import { useMessageContext } from '../../context/MessageContext';
-const UnMemoizedReactionSelector = React.forwardRef((props, ref) => {
+const UnMemoizedReactionSelector = (props) => {
     const { Avatar: propAvatar, detailedView = true, handleReaction: propHandleReaction, latest_reactions: propLatestReactions, own_reactions: propOwnReactions, reaction_groups: propReactionGroups, reactionOptions: propReactionOptions, reverse = false, } = props;
-    const { Avatar: contextAvatar, reactionOptions: contextReactionOptions, } = useComponentContext('ReactionSelector');
-    const { handleReaction: contextHandleReaction, message, } = useMessageContext('ReactionSelector');
+    const { Avatar: contextAvatar, reactionOptions: contextReactionOptions = defaultReactionOptions, } = useComponentContext('ReactionSelector');
+    const { closeReactionSelectorOnClick, handleReaction: contextHandleReaction, message, } = useMessageContext('ReactionSelector');
+    const dialogId = `reaction-selector--${message.id}`;
+    const dialog = useDialog({ id: dialogId });
     const reactionOptions = propReactionOptions ?? contextReactionOptions;
     const Avatar = propAvatar || contextAvatar || DefaultAvatar;
     const handleReaction = propHandleReaction || contextHandleReaction;
@@ -16,6 +20,7 @@ const UnMemoizedReactionSelector = React.forwardRef((props, ref) => {
     const reactionGroups = propReactionGroups || message?.reaction_groups || {};
     const [tooltipReactionType, setTooltipReactionType] = useState(null);
     const [tooltipPositions, setTooltipPositions] = useState(null);
+    const rootRef = useRef(null);
     const targetRef = useRef(null);
     const tooltipRef = useRef(null);
     const showTooltip = useCallback((event, reactionType) => {
@@ -27,22 +32,22 @@ const UnMemoizedReactionSelector = React.forwardRef((props, ref) => {
         setTooltipPositions(null);
     }, []);
     useEffect(() => {
-        if (tooltipReactionType) {
-            const tooltip = tooltipRef.current?.getBoundingClientRect();
-            const target = targetRef.current?.getBoundingClientRect();
-            const container = isMutableRef(ref) ? ref.current?.getBoundingClientRect() : null;
-            if (!tooltip || !target || !container)
-                return;
-            const tooltipPosition = tooltip.width === container.width || tooltip.x < container.x
-                ? 0
-                : target.left + target.width / 2 - container.left - tooltip.width / 2;
-            const arrowPosition = target.x - tooltip.x + target.width / 2 - tooltipPosition;
-            setTooltipPositions({
-                arrow: arrowPosition,
-                tooltip: tooltipPosition,
-            });
-        }
-    }, [tooltipReactionType, ref]);
+        if (!tooltipReactionType || !rootRef.current)
+            return;
+        const tooltip = tooltipRef.current?.getBoundingClientRect();
+        const target = targetRef.current?.getBoundingClientRect();
+        const container = isMutableRef(rootRef) ? rootRef.current?.getBoundingClientRect() : null;
+        if (!tooltip || !target || !container)
+            return;
+        const tooltipPosition = tooltip.width === container.width || tooltip.x < container.x
+            ? 0
+            : target.left + target.width / 2 - container.left - tooltip.width / 2;
+        const arrowPosition = target.x - tooltip.x + target.width / 2 - tooltipPosition;
+        setTooltipPositions({
+            arrow: arrowPosition,
+            tooltip: tooltipPosition,
+        });
+    }, [tooltipReactionType, rootRef]);
     const getUsersPerReactionType = (type) => latestReactions
         .map((reaction) => {
         if (reaction.type === type) {
@@ -54,9 +59,9 @@ const UnMemoizedReactionSelector = React.forwardRef((props, ref) => {
     const iHaveReactedWithReaction = (reactionType) => ownReactions.find((reaction) => reaction.type === reactionType);
     const getLatestUserForReactionType = (type) => latestReactions.find((reaction) => reaction.type === type && !!reaction.user)?.user ||
         undefined;
-    return (React.createElement("div", { className: clsx('str-chat__reaction-selector str-chat__message-reaction-selector', {
+    return (React.createElement("div", { className: clsx('str-chat__reaction-selector str-chat__message-reaction-selector str-chat-react__message-reaction-selector', {
             'str-chat__reaction-selector--reverse': reverse,
-        }), "data-testid": 'reaction-selector', ref: ref },
+        }), "data-testid": 'reaction-selector', ref: rootRef },
         !!tooltipReactionType && detailedView && (React.createElement("div", { className: 'str-chat__reaction-selector-tooltip', ref: tooltipRef, style: {
                 left: tooltipPositions?.tooltip,
                 visibility: tooltipPositions ? 'visible' : 'hidden',
@@ -69,13 +74,18 @@ const UnMemoizedReactionSelector = React.forwardRef((props, ref) => {
             return (React.createElement("li", { key: reactionType },
                 React.createElement("button", { "aria-label": `Select Reaction: ${reactionName || reactionType}`, className: clsx('str-chat__message-reactions-list-item str-chat__message-reactions-option', {
                         'str-chat__message-reactions-option-selected': iHaveReactedWithReaction(reactionType),
-                    }), "data-text": reactionType, onClick: (event) => handleReaction(reactionType, event) },
+                    }), "data-testid": 'select-reaction-button', "data-text": reactionType, onClick: (event) => {
+                        handleReaction(reactionType, event);
+                        if (closeReactionSelectorOnClick) {
+                            dialog.close();
+                        }
+                    } },
                     !!count && detailedView && (React.createElement("div", { className: 'latest-user str-chat__message-reactions-last-user', onClick: hideTooltip, onMouseEnter: (e) => showTooltip(e, reactionType), onMouseLeave: hideTooltip }, latestUser ? (React.createElement(Avatar, { image: latestUser.image, name: latestUser.name, size: 20, user: latestUser })) : (React.createElement("div", { className: 'latest-user-not-found' })))),
                     React.createElement("span", { className: 'str-chat__message-reaction-emoji' },
                         React.createElement(Component, null)),
                     Boolean(count) && detailedView && (React.createElement("span", { className: 'str-chat__message-reactions-list-item__count' }, count || '')))));
         }))));
-});
+};
 /**
  * Component that allows a user to select a reaction.
  */

package/dist/components/Reactions/ReactionSelectorWithButton.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { DefaultStreamChatGenerics } from '../../types';
+import type { IconProps } from '../../types/types';
+type ReactionSelectorWithButtonProps = {
+    ReactionIcon: React.ComponentType<IconProps>;
+    theme: string;
+};
+/**
+ * Internal convenience component - not to be exported. It just groups the button and the dialog anchor and thus prevents
+ * cluttering the parent component.
+ */
+export declare const ReactionSelectorWithButton: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ ReactionIcon, theme, }: ReactionSelectorWithButtonProps) => React.JSX.Element;
+export {};

package/dist/components/Reactions/ReactionSelectorWithButton.js

@@ -0,0 +1,22 @@
+import React, { useRef } from 'react';
+import { ReactionSelector as DefaultReactionSelector } from './ReactionSelector';
+import { DialogAnchor, useDialog, useDialogIsOpen } from '../Dialog';
+import { useComponentContext, useMessageContext, useTranslationContext } from '../../context';
+/**
+ * Internal convenience component - not to be exported. It just groups the button and the dialog anchor and thus prevents
+ * cluttering the parent component.
+ */
+export const ReactionSelectorWithButton = ({ ReactionIcon, theme, }) => {
+    const { t } = useTranslationContext('ReactionSelectorWithButton');
+    const { isMyMessage, message } = useMessageContext('MessageOptions');
+    const { ReactionSelector = DefaultReactionSelector } = useComponentContext('MessageOptions');
+    const buttonRef = useRef(null);
+    const dialogId = `reaction-selector--${message.id}`;
+    const dialog = useDialog({ id: dialogId });
+    const dialogIsOpen = useDialogIsOpen(dialogId);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(DialogAnchor, { id: dialogId, placement: isMyMessage() ? 'top-end' : 'top-start', referenceElement: buttonRef.current, trapFocus: true },
+            React.createElement(ReactionSelector, null)),
+        React.createElement("button", { "aria-expanded": dialogIsOpen, "aria-label": t('aria/Open Reaction Selector'), className: `str-chat__message-${theme}__actions__action str-chat__message-${theme}__actions__action--reactions str-chat__message-reactions-button`, "data-testid": 'message-reaction-action', onClick: () => dialog?.toggle(), ref: buttonRef },
+            React.createElement(ReactionIcon, { className: 'str-chat__message-action-icon' }))));
+};

package/dist/components/Reactions/ReactionsList.d.ts

@@ -1,13 +1,10 @@
 import React from 'react';
 import type { ReactionGroupResponse, ReactionResponse } from 'stream-chat';
-import type { ReactEventHandler } from '../Message/types';
 import type { DefaultStreamChatGenerics } from '../../types/types';
 import type { ReactionOptions } from './reactionOptions';
 import type { ReactionDetailsComparator, ReactionsComparator } from './types';
 import { MessageContextValue } from '../../context';
 export type ReactionsListProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = Partial<Pick<MessageContextValue<StreamChatGenerics>, 'handleFetchReactions' | 'reactionDetailsSort'>> & {
-    /** Custom on click handler for an individual reaction, defaults to `onReactionListClick` from the `MessageContext` */
-    onClick?: ReactEventHandler;
     /** An array of the own reaction objects to distinguish own reactions visually */
     own_reactions?: ReactionResponse<StreamChatGenerics>[];
     /**
@@ -17,7 +14,10 @@ export type ReactionsListProps<StreamChatGenerics extends DefaultStreamChatGener
     reaction_counts?: Record<string, number>;
     /** An object containing summary for each reaction type on a message */
     reaction_groups?: Record<string, ReactionGroupResponse>;
-    /** A list of the currently supported reactions on a message */
+    /**
+     * @deprecated
+     * A list of the currently supported reactions on a message
+     * */
     reactionOptions?: ReactionOptions;
     /** An array of the reaction objects to display in the list */
     reactions?: ReactionResponse<StreamChatGenerics>[];

package/dist/components/Reactions/hooks/useProcessReactions.js

@@ -1,5 +1,6 @@
 import { useCallback, useMemo } from 'react';
 import { useComponentContext, useMessageContext } from '../../../context';
+import { defaultReactionOptions } from '../reactionOptions';
 export const defaultReactionsSort = (a, b) => {
     if (a.firstReactionAt && b.firstReactionAt) {
         return +a.firstReactionAt - +b.firstReactionAt;
@@ -9,7 +10,7 @@ export const defaultReactionsSort = (a, b) => {
 export const useProcessReactions = (params) => {
     const { own_reactions: propOwnReactions, reaction_groups: propReactionGroups, reactionOptions: propReactionOptions, reactions: propReactions, sortReactions: propSortReactions, } = params;
     const { message, sortReactions: contextSortReactions } = useMessageContext('useProcessReactions');
-    const { reactionOptions: contextReactionOptions } = useComponentContext('useProcessReactions');
+    const { reactionOptions: contextReactionOptions = defaultReactionOptions, } = useComponentContext('useProcessReactions');
     const reactionOptions = propReactionOptions ?? contextReactionOptions;
     const sortReactions = propSortReactions ?? contextSortReactions ?? defaultReactionsSort;
     const latestReactions = propReactions || message.latest_reactions;

package/dist/components/Thread/Thread.js

@@ -6,19 +6,32 @@ 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';
 /**
  * The Thread component renders a parent Message with a list of replies
  */
 export const Thread = (props) => {
     const { channel, channelConfig, thread } = useChannelStateContext('Thread');
-    if (!thread || channelConfig?.replies === false)
+    const threadInstance = useThreadContext();
+    if ((!thread && !threadInstance) || channelConfig?.replies === false)
         return null;
-    // The wrapper ensures a key variable is set and the component recreates on thread switch
-    return React.createElement(ThreadInner, { ...props, key: `thread-${thread.id}-${channel?.cid}` });
+    // the wrapper ensures a key variable is set and the component recreates on thread switch
+    return (
+    // FIXME: TS is having trouble here as at least one of the two would always be defined
+    React.createElement(ThreadInner, { ...props, key: `thread-${(thread ?? threadInstance)?.id}-${channel?.cid}` }));
 };
+const selector = (nextValue) => [
+    nextValue.replies,
+    nextValue.pagination.isLoadingPrev,
+    nextValue.pagination.isLoadingNext,
+    nextValue.parentMessage,
+];
 const ThreadInner = (props) => {
     const { additionalMessageInputProps, additionalMessageListProps, additionalParentMessageProps, additionalVirtualizedMessageListProps, autoFocus = true, enableDateSeparator = false, Input: PropInput, Message: PropMessage, messageActions = Object.keys(MESSAGE_ACTIONS), virtualized, } = props;
-    const { thread, threadHasMore, threadLoadingMore, threadMessages, threadSuppressAutoscroll, } = useChannelStateContext('Thread');
+    const threadInstance = useThreadContext();
+    const [latestReplies, isLoadingPrev, isLoadingNext, parentMessage] = useStateStore(threadInstance?.state, selector) ?? [];
+    const { thread, threadHasMore, threadLoadingMore, threadMessages = [], threadSuppressAutoscroll, } = useChannelStateContext('Thread');
     const { closeThread, loadMoreThread } = useChannelActionContext('Thread');
     const { customClasses } = useChatContext('Thread');
     const { ThreadInput: ContextInput, Message: ContextMessage, ThreadHead = DefaultThreadHead, ThreadHeader = DefaultThreadHeader, VirtualMessage, } = useComponentContext('Thread');
@@ -33,16 +46,31 @@ const ThreadInner = (props) => {
             loadMoreThread();
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, []);
-    if (!thread)
+    }, [thread, loadMoreThread]);
+    const threadProps = threadInstance
+        ? {
+            loadingMore: isLoadingPrev,
+            loadingMoreNewer: isLoadingNext,
+            loadMore: threadInstance.loadPrevPage,
+            loadMoreNewer: threadInstance.loadNextPage,
+            messages: latestReplies,
+        }
+        : {
+            hasMore: threadHasMore,
+            loadingMore: threadLoadingMore,
+            loadMore: loadMoreThread,
+            messages: threadMessages,
+        };
+    const messageAsThread = thread ?? parentMessage;
+    if (!messageAsThread)
         return null;
     const threadClass = customClasses?.thread ||
         clsx('str-chat__thread-container str-chat__thread', {
             'str-chat__thread--virtualized': virtualized,
         });
-    const head = (React.createElement(ThreadHead, { key: thread.id, message: thread, Message: MessageUIComponent, ...additionalParentMessageProps }));
+    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: thread }),
-        React.createElement(ThreadMessageList, { disableDateSeparator: !enableDateSeparator, hasMore: threadHasMore, head: head, loadingMore: threadLoadingMore, loadMore: loadMoreThread, Message: MessageUIComponent, messageActions: messageActions, messages: threadMessages || [], suppressAutoscroll: threadSuppressAutoscroll, threadList: true, ...(virtualized ? additionalVirtualizedMessageListProps : additionalMessageListProps) }),
-        React.createElement(MessageInput, { focus: autoFocus, Input: ThreadInput, parent: thread, publishTypingEvent: false, ...additionalMessageInputProps })));
+        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, parent: thread ?? parentMessage, publishTypingEvent: false, ...additionalMessageInputProps })));
 };

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { PropsWithChildren } from 'react';
+import { 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 ThreadProvider: ({ children, thread }: PropsWithChildren<{
+    thread?: Thread;
+}>) => React.JSX.Element;

package/dist/components/Threads/ThreadContext.js

@@ -0,0 +1,9 @@
+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 ThreadProvider = ({ children, thread }) => (React.createElement(ThreadContext.Provider, { value: thread },
+    React.createElement(Channel, { channel: thread?.channel }, children)));

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import { VirtuosoProps } from 'react-virtuoso';
+import type { Thread } from 'stream-chat';
+type ThreadListProps = {
+    virtuosoProps?: VirtuosoProps<Thread, unknown>;
+};
+export declare const useThreadList: () => void;
+export declare const ThreadList: ({ virtuosoProps }: ThreadListProps) => React.JSX.Element;
+export {};

package/dist/components/Threads/ThreadList/ThreadList.js

@@ -0,0 +1,41 @@
+import React, { useEffect } from 'react';
+import { Virtuoso } from 'react-virtuoso';
+import { ThreadListItem as DefaultThreadListItem } from './ThreadListItem';
+import { ThreadListEmptyPlaceholder as DefaultThreadListEmptyPlaceholder } from './ThreadListEmptyPlaceholder';
+import { ThreadListUnseenThreadsBanner as DefaultThreadListUnseenThreadsBanner } from './ThreadListUnseenThreadsBanner';
+import { ThreadListLoadingIndicator as DefaultThreadListLoadingIndicator } from './ThreadListLoadingIndicator';
+import { useChatContext, useComponentContext } from '../../../context';
+import { useStateStore } from '../../../store';
+const selector = (nextValue) => [nextValue.threads];
+const computeItemKey = (_, item) => item.id;
+export const useThreadList = () => {
+    const { client } = useChatContext();
+    useEffect(() => {
+        const handleVisibilityChange = () => {
+            if (document.visibilityState === 'visible') {
+                client.threads.activate();
+            }
+            if (document.visibilityState === 'hidden') {
+                client.threads.deactivate();
+            }
+        };
+        handleVisibilityChange();
+        document.addEventListener('visibilitychange', handleVisibilityChange);
+        return () => {
+            client.threads.deactivate();
+            document.removeEventListener('visibilitychange', handleVisibilityChange);
+        };
+    }, [client]);
+};
+export const ThreadList = ({ virtuosoProps }) => {
+    const { client } = useChatContext();
+    const { ThreadListItem = DefaultThreadListItem, ThreadListEmptyPlaceholder = DefaultThreadListEmptyPlaceholder, ThreadListLoadingIndicator = DefaultThreadListLoadingIndicator, ThreadListUnseenThreadsBanner = DefaultThreadListUnseenThreadsBanner, } = useComponentContext();
+    const [threads] = useStateStore(client.threads.state, selector);
+    useThreadList();
+    return (React.createElement("div", { className: 'str-chat__thread-list-container' },
+        React.createElement(ThreadListUnseenThreadsBanner, null),
+        React.createElement(Virtuoso, { atBottomStateChange: (atBottom) => atBottom && client.threads.loadNextPage(), className: 'str-chat__thread-list', components: {
+                EmptyPlaceholder: ThreadListEmptyPlaceholder,
+                Footer: ThreadListLoadingIndicator,
+            }, computeItemKey: computeItemKey, data: threads, itemContent: (_, thread) => React.createElement(ThreadListItem, { thread: thread }), ...virtuosoProps })));
+};

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

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const ThreadListEmptyPlaceholder: () => React.JSX.Element;

package/dist/components/Threads/ThreadList/ThreadListEmptyPlaceholder.js

@@ -0,0 +1,5 @@
+import React from 'react';
+import { Icon } from '../icons';
+export const ThreadListEmptyPlaceholder = () => (React.createElement("div", { className: 'str-chat__thread-list-empty-placeholder' },
+    React.createElement(Icon.MessageBubble, null),
+    "No threads here yet..."));

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

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