stream-chat-react 11.20.0 → 12.0.0-rc.1

package/dist/components/Channel/LoadingChannel.d.ts

@@ -1,3 +1,2 @@
 import React from 'react';
 export declare const LoadingChannel: () => React.JSX.Element;
-//# sourceMappingURL=LoadingChannel.d.ts.map

package/dist/components/Channel/LoadingChannel.js

@@ -1,20 +1,20 @@
 import React from 'react';
-var LoadingMessage = function () { return (React.createElement("div", { className: 'str-chat__loading-channel-message' },
+const LoadingMessage = () => (React.createElement("div", { className: 'str-chat__loading-channel-message' },
     React.createElement("div", { className: 'str-chat__loading-channel-message-avatar' }),
     React.createElement("div", { className: 'str-chat__loading-channel-message-end' },
         React.createElement("div", { className: 'str-chat__loading-channel-message-sender' }),
         React.createElement("div", { className: 'str-chat__loading-channel-message-last-row' },
             React.createElement("div", { className: 'str-chat__loading-channel-message-text' }),
-            React.createElement("div", { className: 'str-chat__loading-channel-message-date' }))))); };
-var LoadingMessageInput = function () { return (React.createElement("div", { className: 'str-chat__loading-channel-message-input-row' },
+            React.createElement("div", { className: 'str-chat__loading-channel-message-date' })))));
+const LoadingMessageInput = () => (React.createElement("div", { className: 'str-chat__loading-channel-message-input-row' },
     React.createElement("div", { className: 'str-chat__loading-channel-message-input' }),
-    React.createElement("div", { className: 'str-chat__loading-channel-message-send' }))); };
-var LoadingChannelHeader = function () { return (React.createElement("div", { className: 'str-chat__loading-channel-header' },
+    React.createElement("div", { className: 'str-chat__loading-channel-message-send' })));
+const LoadingChannelHeader = () => (React.createElement("div", { className: 'str-chat__loading-channel-header' },
     React.createElement("div", { className: 'str-chat__loading-channel-header-avatar' }),
     React.createElement("div", { className: 'str-chat__loading-channel-header-end' },
         React.createElement("div", { className: 'str-chat__loading-channel-header-name' }),
-        React.createElement("div", { className: 'str-chat__loading-channel-header-info' })))); };
-export var LoadingChannel = function () { return (React.createElement("div", { className: 'str-chat__loading-channel' },
+        React.createElement("div", { className: 'str-chat__loading-channel-header-info' }))));
+export const LoadingChannel = () => (React.createElement("div", { className: 'str-chat__loading-channel' },
     React.createElement(LoadingChannelHeader, null),
-    React.createElement("div", { className: 'str-chat__loading-channel-message-list' }, Array.from(Array(3)).map(function (_, i) { return (React.createElement(LoadingMessage, { key: "loading-message-".concat(i) })); })),
-    React.createElement(LoadingMessageInput, null))); };
+    React.createElement("div", { className: 'str-chat__loading-channel-message-list' }, Array.from(Array(3)).map((_, i) => (React.createElement(LoadingMessage, { key: `loading-message-${i}` })))),
+    React.createElement(LoadingMessageInput, null)));

package/dist/components/Channel/channelState.d.ts

@@ -83,4 +83,3 @@ export declare const initialState: {
     watcherCount: number;
     watchers: {};
 };
-//# sourceMappingURL=channelState.d.ts.map

package/dist/components/Channel/channelState.js

@@ -1,86 +1,157 @@
-import { __assign, __spreadArray } from "tslib";
-export var channelReducer = function (state, action) {
-    var _a;
+export const channelReducer = (state, action) => {
     switch (action.type) {
         case 'closeThread': {
-            return __assign(__assign({}, state), { thread: null, threadLoadingMore: false, threadMessages: [] });
+            return {
+                ...state,
+                thread: null,
+                threadLoadingMore: false,
+                threadMessages: [],
+            };
         }
         case 'copyMessagesFromChannel': {
-            var channel = action.channel, parentId = action.parentId;
-            return __assign(__assign({}, state), { messages: __spreadArray([], channel.state.messages, true), pinnedMessages: __spreadArray([], channel.state.pinnedMessages, true), 
+            const { channel, parentId } = action;
+            return {
+                ...state,
+                messages: [...channel.state.messages],
+                pinnedMessages: [...channel.state.pinnedMessages],
                 // copying messages from channel happens with new message - this resets the suppressAutoscroll
-                suppressAutoscroll: false, threadMessages: parentId
-                    ? __assign({}, channel.state.threads)[parentId] || []
-                    : state.threadMessages });
+                suppressAutoscroll: false,
+                threadMessages: parentId
+                    ? { ...channel.state.threads }[parentId] || []
+                    : state.threadMessages,
+            };
         }
         case 'copyStateFromChannelOnEvent': {
-            var channel = action.channel;
-            return __assign(__assign({}, state), { members: __assign({}, channel.state.members), messages: __spreadArray([], channel.state.messages, true), pinnedMessages: __spreadArray([], channel.state.pinnedMessages, true), read: __assign({}, channel.state.read), watcherCount: channel.state.watcher_count, watchers: __assign({}, channel.state.watchers) });
+            const { channel } = action;
+            return {
+                ...state,
+                members: { ...channel.state.members },
+                messages: [...channel.state.messages],
+                pinnedMessages: [...channel.state.pinnedMessages],
+                read: { ...channel.state.read },
+                watcherCount: channel.state.watcher_count,
+                watchers: { ...channel.state.watchers },
+            };
         }
         case 'initStateFromChannel': {
-            var channel = action.channel, hasMore = action.hasMore;
-            return __assign(__assign({}, state), { hasMore: hasMore, loading: false, members: __assign({}, channel.state.members), messages: __spreadArray([], channel.state.messages, true), pinnedMessages: __spreadArray([], channel.state.pinnedMessages, true), read: __assign({}, channel.state.read), watcherCount: channel.state.watcher_count, watchers: __assign({}, channel.state.watchers) });
+            const { channel, hasMore } = action;
+            return {
+                ...state,
+                hasMore,
+                loading: false,
+                members: { ...channel.state.members },
+                messages: [...channel.state.messages],
+                pinnedMessages: [...channel.state.pinnedMessages],
+                read: { ...channel.state.read },
+                watcherCount: channel.state.watcher_count,
+                watchers: { ...channel.state.watchers },
+            };
         }
         case 'jumpToLatestMessage': {
-            return __assign(__assign({}, state), { hasMoreNewer: false, highlightedMessageId: undefined, loading: false, suppressAutoscroll: false });
+            return {
+                ...state,
+                hasMoreNewer: false,
+                highlightedMessageId: undefined,
+                loading: false,
+                suppressAutoscroll: false,
+            };
         }
         case 'jumpToMessageFinished': {
-            return __assign(__assign({}, state), { hasMoreNewer: action.hasMoreNewer, highlightedMessageId: action.highlightedMessageId });
+            return {
+                ...state,
+                hasMoreNewer: action.hasMoreNewer,
+                highlightedMessageId: action.highlightedMessageId,
+            };
         }
         case 'clearHighlightedMessage': {
-            return __assign(__assign({}, state), { highlightedMessageId: undefined });
+            return {
+                ...state,
+                highlightedMessageId: undefined,
+            };
         }
         case 'loadMoreFinished': {
-            var hasMore = action.hasMore, messages = action.messages;
-            return __assign(__assign({}, state), { hasMore: hasMore, loadingMore: false, messages: messages, suppressAutoscroll: false });
+            const { hasMore, messages } = action;
+            return {
+                ...state,
+                hasMore,
+                loadingMore: false,
+                messages,
+                suppressAutoscroll: false,
+            };
         }
         case 'loadMoreNewerFinished': {
-            var hasMoreNewer = action.hasMoreNewer, messages = action.messages;
-            return __assign(__assign({}, state), { hasMoreNewer: hasMoreNewer, loadingMoreNewer: false, messages: messages });
+            const { hasMoreNewer, messages } = action;
+            return {
+                ...state,
+                hasMoreNewer,
+                loadingMoreNewer: false,
+                messages,
+            };
         }
         case 'loadMoreThreadFinished': {
-            var threadHasMore = action.threadHasMore, threadMessages = action.threadMessages;
-            return __assign(__assign({}, state), { threadHasMore: threadHasMore, threadLoadingMore: false, threadMessages: threadMessages });
+            const { threadHasMore, threadMessages } = action;
+            return {
+                ...state,
+                threadHasMore,
+                threadLoadingMore: false,
+                threadMessages,
+            };
         }
         case 'openThread': {
-            var channel = action.channel, message = action.message;
-            return __assign(__assign({}, state), { thread: message, threadMessages: message.id ? __assign({}, channel.state.threads)[message.id] || [] : [], threadSuppressAutoscroll: false });
+            const { channel, message } = action;
+            return {
+                ...state,
+                thread: message,
+                threadMessages: message.id ? { ...channel.state.threads }[message.id] || [] : [],
+                threadSuppressAutoscroll: false,
+            };
         }
         case 'setError': {
-            var error = action.error;
-            return __assign(__assign({}, state), { error: error });
+            const { error } = action;
+            return { ...state, error };
         }
         case 'setLoadingMore': {
-            var loadingMore = action.loadingMore;
+            const { loadingMore } = action;
             // suppress the autoscroll behavior
-            return __assign(__assign({}, state), { loadingMore: loadingMore, suppressAutoscroll: loadingMore });
+            return { ...state, loadingMore, suppressAutoscroll: loadingMore };
         }
         case 'setLoadingMoreNewer': {
-            var loadingMoreNewer = action.loadingMoreNewer;
-            return __assign(__assign({}, state), { loadingMoreNewer: loadingMoreNewer });
+            const { loadingMoreNewer } = action;
+            return { ...state, loadingMoreNewer };
         }
         case 'setThread': {
-            var message = action.message;
-            return __assign(__assign({}, state), { thread: message });
+            const { message } = action;
+            return { ...state, thread: message };
         }
         case 'setTyping': {
-            var channel = action.channel;
-            return __assign(__assign({}, state), { typing: __assign({}, channel.state.typing) });
+            const { channel } = action;
+            return {
+                ...state,
+                typing: { ...channel.state.typing },
+            };
         }
         case 'startLoadingThread': {
-            return __assign(__assign({}, state), { threadLoadingMore: true, threadSuppressAutoscroll: true });
+            return {
+                ...state,
+                threadLoadingMore: true,
+                threadSuppressAutoscroll: true,
+            };
         }
         case 'updateThreadOnEvent': {
-            var channel = action.channel, message = action.message;
+            const { channel, message } = action;
             if (!state.thread)
                 return state;
-            return __assign(__assign({}, state), { thread: (message === null || message === void 0 ? void 0 : message.id) === state.thread.id ? channel.state.formatMessage(message) : state.thread, threadMessages: ((_a = state.thread) === null || _a === void 0 ? void 0 : _a.id) ? __assign({}, channel.state.threads)[state.thread.id] || [] : [] });
+            return {
+                ...state,
+                thread: message?.id === state.thread.id ? channel.state.formatMessage(message) : state.thread,
+                threadMessages: state.thread?.id ? { ...channel.state.threads }[state.thread.id] || [] : [],
+            };
         }
         default:
             return state;
     }
 };
-export var initialState = {
+export const initialState = {
     error: null,
     hasMore: true,
     hasMoreNewer: false,

package/dist/components/Channel/hooks/useChannelContainerClasses.d.ts

@@ -6,4 +6,3 @@ export declare const useChannelContainerClasses: <StreamChatGenerics extends Def
     chatContainerClass: string;
     windowsEmojiClass: string;
 };
-//# sourceMappingURL=useChannelContainerClasses.d.ts.map

package/dist/components/Channel/hooks/useChannelContainerClasses.js

@@ -1,12 +1,10 @@
 import { useChatContext } from '../../../context/ChatContext';
-export var useChannelContainerClasses = function (_a) {
-    var _b, _c, _d;
-    var customClasses = _a.customClasses;
-    var useImageFlagEmojisOnWindows = useChatContext('Channel').useImageFlagEmojisOnWindows;
+export const useChannelContainerClasses = ({ customClasses, }) => {
+    const { useImageFlagEmojisOnWindows } = useChatContext('Channel');
     return {
-        channelClass: (_b = customClasses === null || customClasses === void 0 ? void 0 : customClasses.channel) !== null && _b !== void 0 ? _b : 'str-chat-channel str-chat__channel',
-        chatClass: (_c = customClasses === null || customClasses === void 0 ? void 0 : customClasses.chat) !== null && _c !== void 0 ? _c : 'str-chat',
-        chatContainerClass: (_d = customClasses === null || customClasses === void 0 ? void 0 : customClasses.chatContainer) !== null && _d !== void 0 ? _d : 'str-chat__container',
+        channelClass: customClasses?.channel ?? 'str-chat__channel',
+        chatClass: customClasses?.chat ?? 'str-chat',
+        chatContainerClass: customClasses?.chatContainer ?? 'str-chat__container',
         windowsEmojiClass: useImageFlagEmojisOnWindows && navigator.userAgent.match(/Win/)
             ? 'str-chat--windows-flags'
             : '',

package/dist/components/Channel/hooks/useCreateChannelStateContext.d.ts

@@ -1,7 +1,6 @@
 import type { ChannelStateContextValue } from '../../../context/ChannelStateContext';
 import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useCreateChannelStateContext: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(value: Omit<ChannelStateContextValue<StreamChatGenerics>, "channelCapabilities"> & {
+export declare const useCreateChannelStateContext: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(value: Omit<ChannelStateContextValue<StreamChatGenerics>, 'channelCapabilities'> & {
     channelCapabilitiesArray: string[];
-    skipMessageDataMemoization?: boolean | undefined;
+    skipMessageDataMemoization?: boolean;
 }) => ChannelStateContextValue<StreamChatGenerics>;
-//# sourceMappingURL=useCreateChannelStateContext.d.ts.map

package/dist/components/Channel/hooks/useCreateChannelStateContext.js

@@ -1,86 +1,70 @@
 import { useMemo } from 'react';
 import { isDate, isDayOrMoment } from '../../../context/TranslationContext';
-export var useCreateChannelStateContext = function (value) {
-    var _a;
-    var acceptedFiles = value.acceptedFiles, channel = value.channel, _b = value.channelCapabilitiesArray, channelCapabilitiesArray = _b === void 0 ? [] : _b, channelConfig = value.channelConfig, debounceURLEnrichmentMs = value.debounceURLEnrichmentMs, dragAndDropWindow = value.dragAndDropWindow, enrichURLForPreview = value.enrichURLForPreview, giphyVersion = value.giphyVersion, error = value.error, findURLFn = value.findURLFn, hasMore = value.hasMore, hasMoreNewer = value.hasMoreNewer, imageAttachmentSizeHandler = value.imageAttachmentSizeHandler, suppressAutoscroll = value.suppressAutoscroll, highlightedMessageId = value.highlightedMessageId, loading = value.loading, loadingMore = value.loadingMore, maxNumberOfFiles = value.maxNumberOfFiles, members = value.members, _c = value.messages, messages = _c === void 0 ? [] : _c, multipleUploads = value.multipleUploads, mutes = value.mutes, notifications = value.notifications, onLinkPreviewDismissed = value.onLinkPreviewDismissed, pinnedMessages = value.pinnedMessages, quotedMessage = value.quotedMessage, _d = value.read, read = _d === void 0 ? {} : _d, shouldGenerateVideoThumbnail = value.shouldGenerateVideoThumbnail, skipMessageDataMemoization = value.skipMessageDataMemoization, thread = value.thread, threadHasMore = value.threadHasMore, threadLoadingMore = value.threadLoadingMore, _e = value.threadMessages, threadMessages = _e === void 0 ? [] : _e, channelUnreadUiState = value.channelUnreadUiState, videoAttachmentSizeHandler = value.videoAttachmentSizeHandler, watcherCount = value.watcherCount, watcher_count = value.watcher_count, watchers = value.watchers;
-    var channelId = channel.cid;
-    var lastRead = channel.initialized && ((_a = channel.lastRead()) === null || _a === void 0 ? void 0 : _a.getTime());
-    var membersLength = Object.keys(members || []).length;
-    var notificationsLength = notifications.length;
-    var readUsers = Object.values(read);
-    var readUsersLength = readUsers.length;
-    var readUsersLastReads = readUsers.map(function (_a) {
-        var last_read = _a.last_read;
-        return last_read.toISOString();
-    }).join();
-    var threadMessagesLength = threadMessages === null || threadMessages === void 0 ? void 0 : threadMessages.length;
-    var channelCapabilities = {};
-    channelCapabilitiesArray.forEach(function (capability) {
+export const useCreateChannelStateContext = (value) => {
+    const { acceptedFiles, channel, channelCapabilitiesArray = [], channelConfig, debounceURLEnrichmentMs, dragAndDropWindow, enrichURLForPreview, giphyVersion, error, findURLFn, hasMore, hasMoreNewer, imageAttachmentSizeHandler, suppressAutoscroll, highlightedMessageId, loading, loadingMore, maxNumberOfFiles, members, messages = [], multipleUploads, mutes, notifications, onLinkPreviewDismissed, pinnedMessages, quotedMessage, read = {}, shouldGenerateVideoThumbnail, skipMessageDataMemoization, thread, threadHasMore, threadLoadingMore, threadMessages = [], channelUnreadUiState, videoAttachmentSizeHandler, watcherCount, watcher_count, watchers, } = value;
+    const channelId = channel.cid;
+    const lastRead = channel.initialized && channel.lastRead()?.getTime();
+    const membersLength = Object.keys(members || []).length;
+    const notificationsLength = notifications.length;
+    const readUsers = Object.values(read);
+    const readUsersLength = readUsers.length;
+    const readUsersLastReads = readUsers.map(({ last_read }) => last_read.toISOString()).join();
+    const threadMessagesLength = threadMessages?.length;
+    const channelCapabilities = {};
+    channelCapabilitiesArray.forEach((capability) => {
         channelCapabilities[capability] = true;
     });
-    var memoizedMessageData = skipMessageDataMemoization
+    const memoizedMessageData = skipMessageDataMemoization
         ? messages
         : messages
-            .map(function (_a) {
-            var deleted_at = _a.deleted_at, latest_reactions = _a.latest_reactions, pinned = _a.pinned, reply_count = _a.reply_count, status = _a.status, updated_at = _a.updated_at, user = _a.user;
-            return "".concat(deleted_at).concat(latest_reactions ? latest_reactions.map(function (_a) {
-                var type = _a.type;
-                return type;
-            }).join() : '').concat(pinned).concat(reply_count).concat(status).concat(updated_at && (isDayOrMoment(updated_at) || isDate(updated_at))
-                ? updated_at.toISOString()
-                : updated_at || '').concat(user === null || user === void 0 ? void 0 : user.updated_at);
-        })
-            .join();
-    var memoizedThreadMessageData = threadMessages
-        .map(function (_a) {
-        var deleted_at = _a.deleted_at, latest_reactions = _a.latest_reactions, pinned = _a.pinned, status = _a.status, updated_at = _a.updated_at, user = _a.user;
-        return "".concat(deleted_at).concat(latest_reactions ? latest_reactions.map(function (_a) {
-            var type = _a.type;
-            return type;
-        }).join() : '').concat(pinned).concat(status).concat(updated_at && (isDayOrMoment(updated_at) || isDate(updated_at))
+            .map(({ deleted_at, latest_reactions, pinned, reply_count, status, updated_at, user }) => `${deleted_at}${latest_reactions ? latest_reactions.map(({ type }) => type).join() : ''}${pinned}${reply_count}${status}${updated_at && (isDayOrMoment(updated_at) || isDate(updated_at))
             ? updated_at.toISOString()
-            : updated_at || '').concat(user === null || user === void 0 ? void 0 : user.updated_at);
-    })
+            : updated_at || ''}${user?.updated_at}`)
+            .join();
+    const memoizedThreadMessageData = threadMessages
+        .map(({ deleted_at, latest_reactions, pinned, status, updated_at, user }) => `${deleted_at}${latest_reactions ? latest_reactions.map(({ type }) => type).join() : ''}${pinned}${status}${updated_at && (isDayOrMoment(updated_at) || isDate(updated_at))
+        ? updated_at.toISOString()
+        : updated_at || ''}${user?.updated_at}`)
         .join();
-    var channelStateContext = useMemo(function () { return ({
-        acceptedFiles: acceptedFiles,
-        channel: channel,
-        channelCapabilities: channelCapabilities,
-        channelConfig: channelConfig,
-        channelUnreadUiState: channelUnreadUiState,
-        debounceURLEnrichmentMs: debounceURLEnrichmentMs,
-        dragAndDropWindow: dragAndDropWindow,
-        enrichURLForPreview: enrichURLForPreview,
-        error: error,
-        findURLFn: findURLFn,
-        giphyVersion: giphyVersion,
-        hasMore: hasMore,
-        hasMoreNewer: hasMoreNewer,
-        highlightedMessageId: highlightedMessageId,
-        imageAttachmentSizeHandler: imageAttachmentSizeHandler,
-        loading: loading,
-        loadingMore: loadingMore,
-        maxNumberOfFiles: maxNumberOfFiles,
-        members: members,
-        messages: messages,
-        multipleUploads: multipleUploads,
-        mutes: mutes,
-        notifications: notifications,
-        onLinkPreviewDismissed: onLinkPreviewDismissed,
-        pinnedMessages: pinnedMessages,
-        quotedMessage: quotedMessage,
-        read: read,
-        shouldGenerateVideoThumbnail: shouldGenerateVideoThumbnail,
-        suppressAutoscroll: suppressAutoscroll,
-        thread: thread,
-        threadHasMore: threadHasMore,
-        threadLoadingMore: threadLoadingMore,
-        threadMessages: threadMessages,
-        videoAttachmentSizeHandler: videoAttachmentSizeHandler,
-        watcher_count: watcher_count,
-        watcherCount: watcherCount,
-        watchers: watchers,
-    }); }, 
+    const channelStateContext = useMemo(() => ({
+        acceptedFiles,
+        channel,
+        channelCapabilities,
+        channelConfig,
+        channelUnreadUiState,
+        debounceURLEnrichmentMs,
+        dragAndDropWindow,
+        enrichURLForPreview,
+        error,
+        findURLFn,
+        giphyVersion,
+        hasMore,
+        hasMoreNewer,
+        highlightedMessageId,
+        imageAttachmentSizeHandler,
+        loading,
+        loadingMore,
+        maxNumberOfFiles,
+        members,
+        messages,
+        multipleUploads,
+        mutes,
+        notifications,
+        onLinkPreviewDismissed,
+        pinnedMessages,
+        quotedMessage,
+        read,
+        shouldGenerateVideoThumbnail,
+        suppressAutoscroll,
+        thread,
+        threadHasMore,
+        threadLoadingMore,
+        threadMessages,
+        videoAttachmentSizeHandler,
+        watcher_count,
+        watcherCount,
+        watchers,
+    }), 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [
         channelId,

package/dist/components/Channel/hooks/useCreateTypingContext.d.ts

@@ -1,4 +1,3 @@
 import type { TypingContextValue } from '../../../context/TypingContext';
 import type { DefaultStreamChatGenerics } from '../../../types/types';
 export declare const useCreateTypingContext: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(value: TypingContextValue<StreamChatGenerics>) => TypingContextValue<StreamChatGenerics>;
-//# sourceMappingURL=useCreateTypingContext.d.ts.map

package/dist/components/Channel/hooks/useCreateTypingContext.js

@@ -1,10 +1,10 @@
 import { useMemo } from 'react';
-export var useCreateTypingContext = function (value) {
-    var typing = value.typing;
-    var typingValue = Object.keys(typing || {}).join();
-    var typingContext = useMemo(function () { return ({
-        typing: typing,
-    }); }, 
+export const useCreateTypingContext = (value) => {
+    const { typing } = value;
+    const typingValue = Object.keys(typing || {}).join();
+    const typingContext = useMemo(() => ({
+        typing,
+    }), 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [typingValue]);
     return typingContext;

package/dist/components/Channel/hooks/useEditMessageHandler.d.ts

@@ -1,6 +1,5 @@
 import type { StreamChat, UpdatedMessage } from 'stream-chat';
 import type { DefaultStreamChatGenerics, UpdateMessageOptions } from '../../../types/types';
 type UpdateHandler<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = (cid: string, updatedMessage: UpdatedMessage<StreamChatGenerics>, options?: UpdateMessageOptions) => ReturnType<StreamChat<StreamChatGenerics>['updateMessage']>;
-export declare const useEditMessageHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(doUpdateMessageRequest?: UpdateHandler<StreamChatGenerics> | undefined) => (updatedMessage: UpdatedMessage<StreamChatGenerics>, options?: UpdateMessageOptions) => Promise<import("stream-chat").UpdateMessageAPIResponse<StreamChatGenerics>>;
+export declare const useEditMessageHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(doUpdateMessageRequest?: UpdateHandler<StreamChatGenerics>) => (updatedMessage: UpdatedMessage<StreamChatGenerics>, options?: UpdateMessageOptions) => Promise<import("stream-chat").UpdateMessageAPIResponse<StreamChatGenerics>>;
 export {};
-//# sourceMappingURL=useEditMessageHandler.d.ts.map

package/dist/components/Channel/hooks/useEditMessageHandler.js

@@ -1,7 +1,7 @@
 import { useChatContext } from '../../../context/ChatContext';
-export var useEditMessageHandler = function (doUpdateMessageRequest) {
-    var _a = useChatContext('useEditMessageHandler'), channel = _a.channel, client = _a.client;
-    return function (updatedMessage, options) {
+export const useEditMessageHandler = (doUpdateMessageRequest) => {
+    const { channel, client } = useChatContext('useEditMessageHandler');
+    return (updatedMessage, options) => {
         if (doUpdateMessageRequest && channel) {
             return Promise.resolve(doUpdateMessageRequest(channel.cid, updatedMessage, options));
         }

package/dist/components/Channel/hooks/useIsMounted.d.ts

@@ -1,2 +1,2 @@
+/// <reference types="react" />
 export declare const useIsMounted: () => import("react").MutableRefObject<boolean>;
-//# sourceMappingURL=useIsMounted.d.ts.map

package/dist/components/Channel/hooks/useIsMounted.js

@@ -1,9 +1,9 @@
 import { useEffect, useRef } from 'react';
-export var useIsMounted = function () {
-    var isMounted = useRef(false);
-    useEffect(function () {
+export const useIsMounted = () => {
+    const isMounted = useRef(false);
+    useEffect(() => {
         isMounted.current = true;
-        return function () {
+        return () => {
             isMounted.current = false;
         };
     }, []);

package/dist/components/Channel/hooks/useMentionsHandlers.d.ts

@@ -2,5 +2,4 @@ import React from 'react';
 import type { UserResponse } from 'stream-chat';
 import type { DefaultStreamChatGenerics } from '../../../types/types';
 export type OnMentionAction<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = (event: React.BaseSyntheticEvent, user?: UserResponse<StreamChatGenerics>) => void;
-export declare const useMentionsHandlers: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(onMentionsHover?: OnMentionAction<StreamChatGenerics> | undefined, onMentionsClick?: OnMentionAction<StreamChatGenerics> | undefined) => (event: React.BaseSyntheticEvent, mentioned_users: UserResponse<StreamChatGenerics>[]) => void;
-//# sourceMappingURL=useMentionsHandlers.d.ts.map
+export declare const useMentionsHandlers: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(onMentionsHover?: OnMentionAction<StreamChatGenerics>, onMentionsClick?: OnMentionAction<StreamChatGenerics>) => (event: React.BaseSyntheticEvent, mentioned_users: UserResponse<StreamChatGenerics>[]) => void;

package/dist/components/Channel/hooks/useMentionsHandlers.js

@@ -1,25 +1,20 @@
 import { useCallback } from 'react';
-export var useMentionsHandlers = function (onMentionsHover, onMentionsClick) {
-    return useCallback(function (event, mentioned_users) {
-        if ((!onMentionsHover && !onMentionsClick) || !(event.target instanceof HTMLElement)) {
-            return;
+export const useMentionsHandlers = (onMentionsHover, onMentionsClick) => useCallback((event, mentioned_users) => {
+    if ((!onMentionsHover && !onMentionsClick) || !(event.target instanceof HTMLElement)) {
+        return;
+    }
+    const target = event.target;
+    const textContent = target.innerHTML.replace('*', '');
+    if (textContent[0] === '@') {
+        const userName = textContent.replace('@', '');
+        const user = mentioned_users?.find(({ id, name }) => name === userName || id === userName);
+        if (onMentionsHover &&
+            typeof onMentionsHover === 'function' &&
+            event.type === 'mouseover') {
+            onMentionsHover(event, user);
         }
-        var target = event.target;
-        var textContent = target.innerHTML.replace('*', '');
-        if (textContent[0] === '@') {
-            var userName_1 = textContent.replace('@', '');
-            var user = mentioned_users === null || mentioned_users === void 0 ? void 0 : mentioned_users.find(function (_a) {
-                var id = _a.id, name = _a.name;
-                return name === userName_1 || id === userName_1;
-            });
-            if (onMentionsHover &&
-                typeof onMentionsHover === 'function' &&
-                event.type === 'mouseover') {
-                onMentionsHover(event, user);
-            }
-            if (onMentionsClick && event.type === 'click' && typeof onMentionsClick === 'function') {
-                onMentionsClick(event, user);
-            }
+        if (onMentionsClick && event.type === 'click' && typeof onMentionsClick === 'function') {
+            onMentionsClick(event, user);
         }
-    }, [onMentionsClick, onMentionsHover]);
-};
+    }
+}, [onMentionsClick, onMentionsHover]);

package/dist/components/Channel/index.d.ts

@@ -1,4 +1,3 @@
 export * from './Channel';
 export { useEditMessageHandler as useChannelEditMessageHandler } from './hooks/useEditMessageHandler';
 export { useMentionsHandlers as useChannelMentionsHandler } from './hooks/useMentionsHandlers';
-//# sourceMappingURL=index.d.ts.map

package/dist/components/Channel/utils.d.ts

@@ -1,3 +1,8 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
 import type { Dispatch, SetStateAction } from 'react';
 import type { ChannelState, MessageResponse } from 'stream-chat';
 import type { ChannelNotifications } from '../../context/ChannelStateContext';
@@ -8,7 +13,7 @@ export declare const makeAddNotifications: (setNotifications: Dispatch<SetStateA
  * @param targetId
  * @param msgSet
  */
-export declare const findInMsgSetById: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(targetId: string, msgSet: import("stream-chat").FormatMessageResponse<StreamChatGenerics>[]) => {
+export declare const findInMsgSetById: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(targetId: string, msgSet: ReturnType<ChannelState<StreamChatGenerics>['formatMessage']>[]) => {
     index: number;
     target: import("stream-chat").FormatMessageResponse<StreamChatGenerics>;
 } | {
@@ -21,11 +26,10 @@ export declare const findInMsgSetById: <StreamChatGenerics extends DefaultStream
  * @param msgSet
  * @param exact
  */
-export declare const findInMsgSetByDate: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(targetDate: Date, msgSet: MessageResponse<StreamChatGenerics>[] | import("stream-chat").FormatMessageResponse<StreamChatGenerics>[], exact?: boolean) => {
+export declare const findInMsgSetByDate: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(targetDate: Date, msgSet: MessageResponse<StreamChatGenerics>[] | ReturnType<ChannelState<StreamChatGenerics>['formatMessage']>[], exact?: boolean) => {
     index: number;
     target: MessageResponse<StreamChatGenerics> | import("stream-chat").FormatMessageResponse<StreamChatGenerics>;
 } | {
     index: number;
     target?: undefined;
 };
-//# sourceMappingURL=utils.d.ts.map