@sendbird/uikit-react 3.10.1 → 3.11.0

package/chunks/bundle-82c4Z7tx.js

@@ -0,0 +1,251 @@
+import { _ as __assign } from './bundle-fgwje9pW.js';
+import React__default, { useEffect, useState } from 'react';
+import { useChannelContext } from '../Channel/context.js';
+import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
+import { G as GroupChannelHeaderView, C as ChannelHeader } from './bundle-aaseqnuB.js';
+import { u as useGroupChannelContext } from './bundle-7jAH-Rav.js';
+import { useIIFE, useGroupChannelHandler } from '@sendbird/uikit-tools';
+import { T as TypingIndicatorType, M as MessageList$1 } from './bundle-wsahaI_Z.js';
+import PlaceHolder, { PlaceHolderTypes } from '../ui/PlaceHolder.js';
+import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
+import { g as getSuggestedReplies, Q as isSendableMessage } from './bundle-GQt7EDbt.js';
+import { i as isDisabledBecauseFrozen, a as isDisabledBecauseMuted, c as getComponentKeyFromMessage } from './bundle-2mo18Chz.js';
+import { a as MessageView } from './bundle-qGLQQXlH.js';
+import { a as FileViewerView } from './bundle-8CxBlReU.js';
+import { a as RemoveMessageModalView } from './bundle-1nyUxr-Z.js';
+import { getMessagePartsInfo } from '../Channel/utils/getMessagePartsInfo.js';
+import { U as UnreadCount } from './bundle-HRsLD2CW.js';
+import { F as FrozenNotification } from './bundle-xkOWTTW1.js';
+import { S as SCROLL_BUFFER } from './bundle-zpdae5WH.js';
+import { MessageProvider } from '../Message/context.js';
+import TypingIndicatorBubble from '../ui/TypingIndicatorBubble.js';
+import { T as TypingIndicator } from './bundle-2jWyEzHg.js';
+import ConnectionStatus from '../ui/ConnectionStatus.js';
+import { M as MessageInputWrapperView } from './bundle-b1IOVyYG.js';
+import './bundle-hOV701rb.js';
+import './bundle-eHUDbnaD.js';
+import '../VoiceRecorder/context.js';
+import './bundle-kVopRZZG.js';
+import './bundle-j8bOxoFa.js';
+import 'react-dom';
+import './bundle-SbHFlBY0.js';
+import '../ui/IconButton.js';
+import '../ui/Button.js';
+import { MessageInputWrapper as MessageInputWrapper$1 } from '../Channel/components/MessageInput.js';
+
+var GroupChannelHeader = function (_a) {
+    var className = _a.className;
+    var context = useGroupChannelContext();
+    return (React__default.createElement(GroupChannelHeaderView, __assign({}, context, { className: className, currentChannel: context.currentChannel })));
+};
+
+var FileViewer = function (props) {
+    var deleteMessage = useGroupChannelContext().deleteMessage;
+    return React__default.createElement(FileViewerView, __assign({}, props, { deleteMessage: deleteMessage }));
+};
+
+var RemoveMessageModal = function (props) {
+    var deleteMessage = useGroupChannelContext().deleteMessage;
+    return React__default.createElement(RemoveMessageModalView, __assign({}, props, { deleteMessage: deleteMessage }));
+};
+
+var Message = function (props) {
+    var _a = useSendbirdStateContext(), config = _a.config, emojiManager = _a.emojiManager;
+    var _b = useGroupChannelContext(), loading = _b.loading, currentChannel = _b.currentChannel, animatedMessageId = _b.animatedMessageId, setAnimatedMessageId = _b.setAnimatedMessageId, scrollToMessage = _b.scrollToMessage, replyType = _b.replyType, threadReplySelectType = _b.threadReplySelectType, isReactionEnabled = _b.isReactionEnabled, toggleReaction = _b.toggleReaction, nicknamesMap = _b.nicknamesMap, setQuoteMessage = _b.setQuoteMessage, renderUserMentionItem = _b.renderUserMentionItem, onQuoteMessageClick = _b.onQuoteMessageClick, onReplyInThreadClick = _b.onReplyInThreadClick, onMessageAnimated = _b.onMessageAnimated, messages = _b.messages, updateUserMessage = _b.updateUserMessage, sendUserMessage = _b.sendUserMessage, resendMessage = _b.resendMessage, deleteMessage = _b.deleteMessage;
+    var message = props.message;
+    var initialized = !loading && Boolean(currentChannel);
+    var shouldRenderSuggestedReplies = useIIFE(function () {
+        var _a, _b;
+        if (!((_a = config === null || config === void 0 ? void 0 : config.groupChannel) === null || _a === void 0 ? void 0 : _a.enableSuggestedReplies))
+            return false;
+        if (message.messageId !== ((_b = currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.lastMessage) === null || _b === void 0 ? void 0 : _b.messageId))
+            return false;
+        if (getSuggestedReplies(message).length === 0)
+            return false;
+        var lastMessage = messages[messages.length - 1];
+        if (lastMessage && isSendableMessage(lastMessage) && lastMessage.sendingStatus !== 'succeeded')
+            return false;
+        return true;
+    });
+    return (React__default.createElement(MessageView, __assign({}, props, { channel: currentChannel, emojiContainer: emojiManager.emojiContainer, editInputDisabled: !initialized || isDisabledBecauseFrozen(currentChannel) || isDisabledBecauseMuted(currentChannel) || !config.isOnline, shouldRenderSuggestedReplies: shouldRenderSuggestedReplies, isReactionEnabled: isReactionEnabled, replyType: replyType, threadReplySelectType: threadReplySelectType, nicknamesMap: nicknamesMap, renderUserMentionItem: renderUserMentionItem, scrollToMessage: scrollToMessage, toggleReaction: toggleReaction, setQuoteMessage: setQuoteMessage, onQuoteMessageClick: onQuoteMessageClick, onReplyInThreadClick: onReplyInThreadClick, sendUserMessage: sendUserMessage, updateUserMessage: updateUserMessage, resendMessage: resendMessage, deleteMessage: deleteMessage, animatedMessageId: animatedMessageId, setAnimatedMessageId: setAnimatedMessageId, onMessageAnimated: onMessageAnimated, renderFileViewer: function (props) { return React__default.createElement(FileViewer, __assign({}, props)); }, renderRemoveMessageModal: function (props) { return React__default.createElement(RemoveMessageModal, __assign({}, props)); } })));
+};
+
+function useScrollBehavior() {
+    var _a = useGroupChannelContext(), scrollRef = _a.scrollRef, _b = _a.scrollBehavior, scrollBehavior = _b === void 0 ? 'auto' : _b;
+    useEffect(function () {
+        if (scrollRef.current) {
+            scrollRef.current.style.scrollBehavior = scrollBehavior;
+        }
+    }, [scrollRef.current]);
+    return null;
+}
+
+var MessageList = function (_a) {
+    var _b, _c, _d, _e, _f;
+    var _g = _a.className, className = _g === void 0 ? '' : _g, renderMessage = _a.renderMessage, renderPlaceholderEmpty = _a.renderPlaceholderEmpty, renderCustomSeparator = _a.renderCustomSeparator, renderPlaceholderLoader = _a.renderPlaceholderLoader, renderFrozenNotification = _a.renderFrozenNotification;
+    var _h = useGroupChannelContext(), channelUrl = _h.channelUrl, hasNext = _h.hasNext, loading = _h.loading, messages = _h.messages, newMessages = _h.newMessages, scrollToBottom = _h.scrollToBottom, isScrollBottomReached = _h.isScrollBottomReached, isMessageGroupingEnabled = _h.isMessageGroupingEnabled, scrollRef = _h.scrollRef, scrollDistanceFromBottomRef = _h.scrollDistanceFromBottomRef, currentChannel = _h.currentChannel, replyType = _h.replyType, scrollPubSub = _h.scrollPubSub;
+    var store = useSendbirdStateContext();
+    var _j = useState(), unreadSinceDate = _j[0], setUnreadSinceDate = _j[1];
+    useScrollBehavior();
+    useEffect(function () {
+        if (isScrollBottomReached) {
+            setUnreadSinceDate(undefined);
+        }
+        else {
+            setUnreadSinceDate(new Date());
+        }
+    }, [isScrollBottomReached]);
+    /**
+     * 1. Move the message list scroll
+     *    when each message's height is changed by `reactions` OR `showEdit`
+     * 2. Keep the scrollBottom value after fetching new message list
+     */
+    var onMessageContentSizeChanged = function (isBottomMessageAffected) {
+        if (isBottomMessageAffected === void 0) { isBottomMessageAffected = false; }
+        var elem = scrollRef.current;
+        if (elem) {
+            var latestDistance = scrollDistanceFromBottomRef.current;
+            var currentDistance = elem.scrollHeight - elem.scrollTop - elem.offsetHeight;
+            if (latestDistance < currentDistance && (!isBottomMessageAffected || latestDistance < SCROLL_BUFFER)) {
+                var diff = currentDistance - latestDistance;
+                // Move the scroll as much as the height of the message has changed
+                scrollPubSub.publish('scroll', { top: elem.scrollTop + diff, lazy: false });
+            }
+        }
+    };
+    var renderer = {
+        frozenNotification: function () {
+            if (!currentChannel || !currentChannel.isFrozen)
+                return null;
+            if (renderFrozenNotification)
+                return renderFrozenNotification();
+            return React__default.createElement(FrozenNotification, { className: "sendbird-conversation__messages__notification" });
+        },
+        unreadMessagesNotification: function () {
+            if (isScrollBottomReached || !unreadSinceDate)
+                return null;
+            return (React__default.createElement(UnreadCount, { className: "sendbird-conversation__messages__notification", count: newMessages.length, lastReadAt: unreadSinceDate, onClick: scrollToBottom }));
+        },
+        scrollToBottomButton: function () {
+            if (!hasNext() && isScrollBottomReached)
+                return null;
+            return (React__default.createElement("div", { className: "sendbird-conversation__scroll-bottom-button", onClick: scrollToBottom, onKeyDown: scrollToBottom, tabIndex: 0, role: "button" },
+                React__default.createElement(Icon, { width: "24px", height: "24px", type: IconTypes.CHEVRON_DOWN, fillColor: IconColors.PRIMARY })));
+        },
+    };
+    if (loading) {
+        if (renderPlaceholderLoader)
+            return renderPlaceholderLoader();
+        return React__default.createElement(PlaceHolder, { type: PlaceHolderTypes.LOADING });
+    }
+    if (messages.length === 0) {
+        if (renderPlaceholderEmpty)
+            return renderPlaceholderEmpty();
+        return React__default.createElement(PlaceHolder, { className: "sendbird-conversation__no-messages", type: PlaceHolderTypes.NO_MESSAGES });
+    }
+    return (React__default.createElement(React__default.Fragment, null,
+        React__default.createElement("div", { className: "sendbird-conversation__messages ".concat(className) },
+            React__default.createElement("div", { className: "sendbird-conversation__scroll-container" },
+                React__default.createElement("div", { className: "sendbird-conversation__padding" }),
+                React__default.createElement("div", { className: "sendbird-conversation__messages-padding", ref: scrollRef },
+                    messages.map(function (message, idx) {
+                        var _a = getMessagePartsInfo({
+                            allMessages: messages,
+                            replyType: replyType,
+                            isMessageGroupingEnabled: isMessageGroupingEnabled,
+                            currentIndex: idx,
+                            currentMessage: message,
+                            currentChannel: currentChannel,
+                        }), chainTop = _a.chainTop, chainBottom = _a.chainBottom, hasSeparator = _a.hasSeparator;
+                        var isOutgoingMessage = message.isUserMessage() && message.sender.userId === store.config.userId;
+                        return (React__default.createElement(MessageProvider, { message: message, key: getComponentKeyFromMessage(message), isByMe: isOutgoingMessage },
+                            React__default.createElement(Message, { handleScroll: onMessageContentSizeChanged, renderMessage: renderMessage, message: message, hasSeparator: hasSeparator, chainTop: chainTop, chainBottom: chainBottom, renderCustomSeparator: renderCustomSeparator })));
+                    }),
+                    !hasNext()
+                        && ((_c = (_b = store === null || store === void 0 ? void 0 : store.config) === null || _b === void 0 ? void 0 : _b.groupChannel) === null || _c === void 0 ? void 0 : _c.enableTypingIndicator)
+                        && ((_f = (_e = (_d = store === null || store === void 0 ? void 0 : store.config) === null || _d === void 0 ? void 0 : _d.groupChannel) === null || _e === void 0 ? void 0 : _e.typingIndicatorTypes) === null || _f === void 0 ? void 0 : _f.has(TypingIndicatorType.Bubble)) && (React__default.createElement(TypingIndicatorBubbleWrapper, { channelUrl: channelUrl, handleScroll: onMessageContentSizeChanged })))),
+            React__default.createElement(React__default.Fragment, null, renderer.frozenNotification()),
+            React__default.createElement(React__default.Fragment, null, renderer.unreadMessagesNotification()),
+            React__default.createElement(React__default.Fragment, null, renderer.scrollToBottomButton()))));
+};
+var TypingIndicatorBubbleWrapper = function (props) {
+    var stores = useSendbirdStateContext().stores;
+    var _a = useState([]), typingMembers = _a[0], setTypingMembers = _a[1];
+    useGroupChannelHandler(stores.sdkStore.sdk, {
+        onTypingStatusUpdated: function (channel) {
+            if (channel.url === props.channelUrl) {
+                setTypingMembers(channel.getTypingUsers());
+            }
+        },
+    });
+    return React__default.createElement(TypingIndicatorBubble, { typingMembers: typingMembers, handleScroll: props.handleScroll });
+};
+
+var MessageInputWrapper = function (props) {
+    var _a;
+    var config = useSendbirdStateContext().config;
+    var context = useGroupChannelContext();
+    var messages = context.messages, currentChannel = context.currentChannel;
+    var lastMessage = currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.lastMessage;
+    var isLastMessageSuggestedRepliesEnabled = useIIFE(function () {
+        var _a;
+        if (!((_a = config === null || config === void 0 ? void 0 : config.groupChannel) === null || _a === void 0 ? void 0 : _a.enableSuggestedReplies))
+            return false;
+        if (getSuggestedReplies(lastMessage).length === 0)
+            return false;
+        var lastMessageInContext = messages[messages.length - 1];
+        if (isSendableMessage(lastMessageInContext) && lastMessageInContext.sendingStatus !== 'succeeded')
+            return false;
+        return true;
+    });
+    var disableMessageInput = props.disabled
+        || isLastMessageSuggestedRepliesEnabled && !!((_a = lastMessage.extendedMessagePayload) === null || _a === void 0 ? void 0 : _a['disable_chat_input']);
+    return (React__default.createElement(MessageInputWrapperView, __assign({}, props, { disabled: disableMessageInput }, context)));
+};
+
+var GroupChannelUIView = function (props) {
+    var _a, _b, _c, _d;
+    var requestedChannelUrl = props.requestedChannelUrl, loading = props.loading, isInvalid = props.isInvalid, _e = props.renderChannelHeader, renderChannelHeader = _e === void 0 ? function (props) { return (React__default.createElement(GroupChannelHeader, __assign({}, props))); } : _e, _f = props.renderMessageList, renderMessageList = _f === void 0 ? function (props) { return (React__default.createElement(MessageList, __assign({}, props, { className: "sendbird-conversation__message-list" }))); } : _f, _g = props.renderMessageInput, renderMessageInput = _g === void 0 ? function () { return React__default.createElement(MessageInputWrapper, null); } : _g, renderTypingIndicator = props.renderTypingIndicator, renderPlaceholderLoader = props.renderPlaceholderLoader, renderPlaceholderInvalid = props.renderPlaceholderInvalid;
+    var _h = useSendbirdStateContext(), stores = _h.stores, config = _h.config;
+    var sdkError = (_a = stores === null || stores === void 0 ? void 0 : stores.sdkStore) === null || _a === void 0 ? void 0 : _a.error;
+    var logger = config.logger, isOnline = config.isOnline;
+    if (loading) {
+        return React__default.createElement("div", { className: "sendbird-conversation" }, (renderPlaceholderLoader === null || renderPlaceholderLoader === void 0 ? void 0 : renderPlaceholderLoader()) || React__default.createElement(PlaceHolder, { type: PlaceHolderTypes.LOADING }));
+    }
+    if (!requestedChannelUrl) {
+        return (React__default.createElement("div", { className: "sendbird-conversation" }, (renderPlaceholderInvalid === null || renderPlaceholderInvalid === void 0 ? void 0 : renderPlaceholderInvalid()) || React__default.createElement(PlaceHolder, { type: PlaceHolderTypes.NO_CHANNELS })));
+    }
+    if (isInvalid) {
+        return React__default.createElement("div", { className: "sendbird-conversation" }, (renderPlaceholderInvalid === null || renderPlaceholderInvalid === void 0 ? void 0 : renderPlaceholderInvalid()) || React__default.createElement(PlaceHolder, { type: PlaceHolderTypes.WRONG }));
+    }
+    if (sdkError) {
+        return (React__default.createElement("div", { className: "sendbird-conversation" }, (renderPlaceholderInvalid === null || renderPlaceholderInvalid === void 0 ? void 0 : renderPlaceholderInvalid()) || (React__default.createElement(PlaceHolder, { type: PlaceHolderTypes.WRONG, retryToConnect: function () {
+                logger.info('Channel: reconnecting');
+                // reconnect();
+            } }))));
+    }
+    return (React__default.createElement("div", { className: 'sendbird-conversation' }, renderChannelHeader === null || renderChannelHeader === void 0 ? void 0 :
+        renderChannelHeader({ className: 'sendbird-conversation__channel-header' }), renderMessageList === null || renderMessageList === void 0 ? void 0 :
+        renderMessageList(props),
+        React__default.createElement("div", { className: "sendbird-conversation__footer" }, renderMessageInput === null || renderMessageInput === void 0 ? void 0 :
+            renderMessageInput(),
+            React__default.createElement("div", { className: "sendbird-conversation__footer__typing-indicator" },
+                (renderTypingIndicator === null || renderTypingIndicator === void 0 ? void 0 : renderTypingIndicator())
+                    || (((_b = config === null || config === void 0 ? void 0 : config.groupChannel) === null || _b === void 0 ? void 0 : _b.enableTypingIndicator)
+                        && ((_d = (_c = config === null || config === void 0 ? void 0 : config.groupChannel) === null || _c === void 0 ? void 0 : _c.typingIndicatorTypes) === null || _d === void 0 ? void 0 : _d.has(TypingIndicatorType.Text))
+                        && (React__default.createElement(TypingIndicator, { channelUrl: requestedChannelUrl }))),
+                !isOnline && React__default.createElement(ConnectionStatus, null)))));
+};
+
+var ChannelUI = function (props) {
+    var _a;
+    var context = useChannelContext();
+    var channelUrl = context.channelUrl, isInvalid = context.isInvalid, loading = context.loading;
+    return (React__default.createElement(GroupChannelUIView, __assign({}, props, context, { requestedChannelUrl: channelUrl, loading: (_a = props === null || props === void 0 ? void 0 : props.isLoading) !== null && _a !== void 0 ? _a : loading, isInvalid: isInvalid, renderChannelHeader: function (props) { return (React__default.createElement(ChannelHeader, __assign({}, props))); }, renderMessageList: function (props) { return (React__default.createElement(MessageList$1, __assign({}, props))); }, renderMessageInput: function () {
+            var _a, _b;
+            return ((_b = (_a = props.renderMessageInput) === null || _a === void 0 ? void 0 : _a.call(props)) !== null && _b !== void 0 ? _b : React__default.createElement(MessageInputWrapper$1, __assign({}, props)));
+        } })));
+};
+
+export { ChannelUI as C, GroupChannelUIView as G, MessageInputWrapper as M };
+//# sourceMappingURL=bundle-82c4Z7tx.js.map

package/chunks/{bundle-NYZlEPQ4.js.map → bundle-82c4Z7tx.js.map}

@@ -1 +1 @@
-{"version":3,"file":"bundle-NYZlEPQ4.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"bundle-82c4Z7tx.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/chunks/bundle-8CxBlReU.js

@@ -0,0 +1,61 @@
+import { _ as __assign } from './bundle-fgwje9pW.js';
+import React__default from 'react';
+import { createPortal } from 'react-dom';
+import { A as Avatar } from './bundle-2QckWBqt.js';
+import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
+import { L as Label, a as LabelTypography, b as LabelColors } from './bundle-kVopRZZG.js';
+import { F as isSupportedFileView, x as isVideo, v as isImage } from './bundle-GQt7EDbt.js';
+import '../hooks/useModal.js';
+import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
+import { a as MODAL_ROOT } from './bundle-K0s-Ect1.js';
+import { useChannelContext } from '../Channel/context.js';
+
+var FileViewerView = function (_a) {
+    var message = _a.message, onCancel = _a.onCancel, deleteMessage = _a.deleteMessage;
+    var sender = message.sender, type = message.type, url = message.url, _b = message.name, name = _b === void 0 ? '' : _b, threadInfo = message.threadInfo;
+    var profileUrl = sender.profileUrl, nickname = sender.nickname, userId = sender.userId;
+    var config = useSendbirdStateContext().config;
+    return createPortal(React__default.createElement(FileViewerComponent, { profileUrl: profileUrl, nickname: nickname, type: type, url: url, name: name, onCancel: onCancel, onDelete: function () { return deleteMessage(message).then(function () { return onCancel(); }); }, isByMe: config.userId === userId, disableDelete: (threadInfo === null || threadInfo === void 0 ? void 0 : threadInfo.replyCount) > 0 }), document.getElementById(MODAL_ROOT));
+};
+var FileViewerComponent = function (_a) {
+    var 
+    // sender
+    profileUrl = _a.profileUrl, nickname = _a.nickname, 
+    // file
+    name = _a.name, type = _a.type, url = _a.url, 
+    // others
+    isByMe = _a.isByMe, onCancel = _a.onCancel, onDelete = _a.onDelete, disableDelete = _a.disableDelete;
+    return (React__default.createElement("div", { className: "sendbird-fileviewer" },
+        React__default.createElement("div", { className: "sendbird-fileviewer__header" },
+            React__default.createElement("div", { className: "sendbird-fileviewer__header__left" },
+                React__default.createElement("div", { className: "sendbird-fileviewer__header__left__avatar" },
+                    React__default.createElement(Avatar, { height: "32px", width: "32px", src: profileUrl })),
+                React__default.createElement(Label, { className: "sendbird-fileviewer__header__left__filename", type: LabelTypography.H_2, color: LabelColors.ONBACKGROUND_1 }, name),
+                React__default.createElement(Label, { className: "sendbird-fileviewer__header__left__sender-name", type: LabelTypography.BODY_1, color: LabelColors.ONBACKGROUND_2 }, nickname)),
+            React__default.createElement("div", { className: "sendbird-fileviewer__header__right" },
+                isSupportedFileView(type) && (React__default.createElement("div", { className: "sendbird-fileviewer__header__right__actions" },
+                    React__default.createElement("a", { className: "sendbird-fileviewer__header__right__actions__download", rel: "noopener noreferrer", href: url, target: "_blank" },
+                        React__default.createElement(Icon, { type: IconTypes.DOWNLOAD, fillColor: IconColors.ON_BACKGROUND_1, height: "24px", width: "24px" })),
+                    onDelete && isByMe && (React__default.createElement("div", { className: "sendbird-fileviewer__header__right__actions__delete" },
+                        React__default.createElement(Icon, { className: disableDelete ? 'disabled' : '', type: IconTypes.DELETE, fillColor: disableDelete ? IconColors.GRAY : IconColors.ON_BACKGROUND_1, height: "24px", width: "24px", onClick: function () {
+                                if (!disableDelete) {
+                                    onDelete();
+                                }
+                            } }))))),
+                React__default.createElement("div", { className: "sendbird-fileviewer__header__right__actions__close" },
+                    React__default.createElement(Icon, { type: IconTypes.CLOSE, fillColor: IconColors.ON_BACKGROUND_1, height: "24px", width: "24px", onClick: onCancel })))),
+        React__default.createElement("div", { className: "sendbird-fileviewer__content" },
+            isVideo(type) && (React__default.createElement("video", { controls: true, className: "sendbird-fileviewer__content__video" },
+                React__default.createElement("source", { src: url, type: type }))),
+            isImage(type) && React__default.createElement("img", { src: url, alt: name, className: "sendbird-fileviewer__content__img" }),
+            !isSupportedFileView(type) && (React__default.createElement("div", { className: "sendbird-fileviewer__content__unsupported" },
+                React__default.createElement(Label, { type: LabelTypography.H_1, color: LabelColors.ONBACKGROUND_1 }, "Unsupoprted message"))))));
+};
+
+var FileViewer = function (props) {
+    var deleteMessage = useChannelContext().deleteMessage;
+    return React__default.createElement(FileViewerView, __assign({}, props, { deleteMessage: deleteMessage }));
+};
+
+export { FileViewer as F, FileViewerView as a };
+//# sourceMappingURL=bundle-8CxBlReU.js.map

package/chunks/bundle-8CxBlReU.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-8CxBlReU.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/chunks/{bundle-xgiw36M5.js → bundle-9lUB2eTP.js}

@@ -15,4 +15,4 @@ function useKeyDown(ref, keyDownCallbackMap) {
 }
 
 export { useKeyDown as u };
-//# sourceMappingURL=bundle-xgiw36M5.js.map
+//# sourceMappingURL=bundle-9lUB2eTP.js.map

package/chunks/bundle-9lUB2eTP.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-9lUB2eTP.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;"}

package/chunks/bundle-AnoUW9yQ.js

@@ -0,0 +1,199 @@
+import React__default, { useEffect, useState, useContext } from 'react';
+import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
+import { u as useLocalization } from './bundle-hOV701rb.js';
+import { u as useChannelListContext } from './bundle-areDE3aT.js';
+import { g as getTotalMembers, M as MessageStatus, a as getLastMessageCreatedAt, b as getLastMessage, c as getChannelUnreadMessageCount, d as getChannelTitle } from './bundle-rgUMi-vG.js';
+import { _ as __assign } from './bundle-fgwje9pW.js';
+import { GroupChannelFilter } from '@sendbird/chat/groupChannel';
+import { useGroupChannelList, useGroupChannelHandler } from '@sendbird/uikit-tools';
+import { U as UserProfileProvider } from './bundle-NQlEMhhs.js';
+import { u as useOnlineStatus, a as useMarkAsDeliveredScheduler } from './bundle-W8as0zrL.js';
+import { n as noop } from './bundle-tOpyp2TM.js';
+import { u as useLongPress } from './bundle-jXtqc1kU.js';
+import { u as useMediaQueryContext } from './bundle-SbHFlBY0.js';
+import { i as isVoiceMessage } from './bundle-GQt7EDbt.js';
+import { a as TypingIndicatorText } from './bundle-2jWyEzHg.js';
+import Badge from '../ui/Badge.js';
+import ChannelAvatar from '../ui/ChannelAvatar.js';
+import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
+import { L as Label, a as LabelTypography, b as LabelColors } from './bundle-kVopRZZG.js';
+import MentionUserLabel from '../ui/MentionUserLabel.js';
+import { M as Modal } from './bundle-K0s-Ect1.js';
+import TextButton from '../ui/TextButton.js';
+
+var GroupChannelListContext = React__default.createContext(null);
+var GroupChannelListProvider = function (props) {
+    var 
+    // Default
+    children = props.children, _a = props.className, className = _a === void 0 ? '' : _a, selectedChannelUrl = props.selectedChannelUrl, 
+    // Flags
+    _b = props.allowProfileEdit, 
+    // Flags
+    allowProfileEdit = _b === void 0 ? true : _b, _c = props.disableAutoSelect, disableAutoSelect = _c === void 0 ? false : _c, _d = props.isTypingIndicatorEnabled, isTypingIndicatorEnabled = _d === void 0 ? false : _d, _e = props.isMessageReceiptStatusEnabled, isMessageReceiptStatusEnabled = _e === void 0 ? false : _e, 
+    // Custom
+    channelListQueryParams = props.channelListQueryParams, onThemeChange = props.onThemeChange, _f = props.onChannelSelect, onChannelSelect = _f === void 0 ? noop : _f, _g = props.onChannelCreated, onChannelCreated = _g === void 0 ? noop : _g, onCreateChannelClick = props.onCreateChannelClick, onBeforeCreateChannel = props.onBeforeCreateChannel, onUserProfileUpdated = props.onUserProfileUpdated, 
+    // UserProfile
+    disableUserProfile = props.disableUserProfile, renderUserProfile = props.renderUserProfile, onUserProfileMessage = props.onUserProfileMessage;
+    var globalStore = useSendbirdStateContext();
+    var config = globalStore.config, stores = globalStore.stores;
+    var sdkStore = stores.sdkStore;
+    var _h = config.isTypingIndicatorEnabledOnChannelList, isTypingIndicatorEnabledOnChannelList = _h === void 0 ? false : _h, _j = config.isMessageReceiptStatusEnabledOnChannelList, isMessageReceiptStatusEnabledOnChannelList = _j === void 0 ? false : _j;
+    var sdk = sdkStore.sdk;
+    var isConnected = useOnlineStatus(sdk, config.logger);
+    var scheduler = useMarkAsDeliveredScheduler({ isConnected: isConnected }, config);
+    var channelListDataSource = useGroupChannelList(sdk, {
+        collectionCreator: getCollectionCreator(sdk, channelListQueryParams),
+        markAsDelivered: function (channels) { return channels.forEach(scheduler.push); },
+        onChannelsDeleted: function (channelUrls) {
+            channelUrls.forEach(function (url) {
+                if (url === selectedChannelUrl)
+                    onChannelSelect(null);
+            });
+        },
+    });
+    var refreshing = channelListDataSource.refreshing, initialized = channelListDataSource.initialized, groupChannels = channelListDataSource.groupChannels, refresh = channelListDataSource.refresh, loadMore = channelListDataSource.loadMore;
+    // SideEffect: Auto select channel
+    useEffect(function () {
+        var _a;
+        if (!disableAutoSelect && stores.sdkStore.initialized && initialized) {
+            if (!selectedChannelUrl)
+                onChannelSelect((_a = groupChannels[0]) !== null && _a !== void 0 ? _a : null);
+        }
+    }, [disableAutoSelect, stores.sdkStore.initialized, initialized, selectedChannelUrl]);
+    var _k = useState([]), typingChannelUrls = _k[0], setTypingChannelUrls = _k[1];
+    useGroupChannelHandler(sdk, {
+        onTypingStatusUpdated: function (channel) {
+            var _a;
+            var channelList = typingChannelUrls.filter(function (channelUrl) { return channelUrl !== channel.url; });
+            if (((_a = channel.getTypingUsers()) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                setTypingChannelUrls(channelList.concat(channel.url));
+            }
+            else {
+                setTypingChannelUrls(channelList);
+            }
+        },
+    });
+    return (React__default.createElement(GroupChannelListContext.Provider, { value: {
+            // Default
+            className: className,
+            selectedChannelUrl: selectedChannelUrl,
+            // Flags
+            allowProfileEdit: allowProfileEdit !== null && allowProfileEdit !== void 0 ? allowProfileEdit : config === null || config === void 0 ? void 0 : config.allowProfileEdit,
+            disableAutoSelect: disableAutoSelect,
+            isTypingIndicatorEnabled: isTypingIndicatorEnabled !== null && isTypingIndicatorEnabled !== void 0 ? isTypingIndicatorEnabled : isTypingIndicatorEnabledOnChannelList,
+            isMessageReceiptStatusEnabled: isMessageReceiptStatusEnabled !== null && isMessageReceiptStatusEnabled !== void 0 ? isMessageReceiptStatusEnabled : isMessageReceiptStatusEnabledOnChannelList,
+            // Essential
+            onChannelSelect: onChannelSelect,
+            onChannelCreated: onChannelCreated,
+            // Partial props
+            onThemeChange: onThemeChange,
+            onCreateChannelClick: onCreateChannelClick,
+            onBeforeCreateChannel: onBeforeCreateChannel,
+            onUserProfileUpdated: onUserProfileUpdated,
+            // Internal
+            typingChannelUrls: typingChannelUrls,
+            // ReturnType<UseGroupChannelList>
+            refreshing: refreshing,
+            initialized: initialized,
+            groupChannels: groupChannels,
+            refresh: refresh,
+            loadMore: loadMore,
+        } },
+        React__default.createElement(UserProfileProvider, { disableUserProfile: disableUserProfile !== null && disableUserProfile !== void 0 ? disableUserProfile : config === null || config === void 0 ? void 0 : config.disableUserProfile, renderUserProfile: renderUserProfile !== null && renderUserProfile !== void 0 ? renderUserProfile : config === null || config === void 0 ? void 0 : config.renderUserProfile, onUserProfileMessage: onUserProfileMessage !== null && onUserProfileMessage !== void 0 ? onUserProfileMessage : config === null || config === void 0 ? void 0 : config.onUserProfileMessage },
+            React__default.createElement("div", { className: "sendbird-channel-list ".concat(className) }, children))));
+};
+var useGroupChannelListContext = function () {
+    var context = useContext(GroupChannelListContext);
+    if (!context)
+        throw new Error('GroupChannelListContext not found. Use within the GroupChannelList module.');
+    return context;
+};
+function getCollectionCreator(sdk, channelListQueryParams) {
+    return function (defaultParams) {
+        var params = __assign(__assign({}, defaultParams), channelListQueryParams);
+        return sdk.groupChannel.createGroupChannelCollection(__assign(__assign({}, params), { filter: new GroupChannelFilter(params) }));
+    };
+}
+
+var GroupChannelListItemView = function (_a) {
+    var channel = _a.channel, tabIndex = _a.tabIndex, isTyping = _a.isTyping, isSelected = _a.isSelected, channelName = _a.channelName, _b = _a.isMessageStatusEnabled, isMessageStatusEnabled = _b === void 0 ? true : _b, _c = _a.onClick, onClick = _c === void 0 ? noop : _c, _d = _a.onLeaveChannel, onLeaveChannel = _d === void 0 ? noop : _d, renderChannelAction = _a.renderChannelAction;
+    var config = useSendbirdStateContext().config;
+    var theme = config.theme, isMentionEnabled = config.isMentionEnabled, userId = config.userId;
+    var _e = useLocalization(), dateLocale = _e.dateLocale, stringSet = _e.stringSet;
+    var isMobile = useMediaQueryContext().isMobile;
+    var _f = useState(false), showMobileLeave = _f[0], setShowMobileLeave = _f[1];
+    var onLongPress = useLongPress({
+        onLongPress: function () {
+            if (isMobile) {
+                setShowMobileLeave(true);
+            }
+        },
+        onClick: onClick,
+    }, {
+        delay: 1000,
+    });
+    return (React__default.createElement(React__default.Fragment, null,
+        React__default.createElement("div", __assign({ className: [
+                'sendbird-channel-preview',
+                isSelected ? 'sendbird-channel-preview--active' : '',
+            ].join(' '), role: "link", tabIndex: tabIndex }, (isMobile ? __assign({}, onLongPress) : { onClick: onClick })),
+            React__default.createElement("div", { className: "sendbird-channel-preview__avatar" },
+                React__default.createElement(ChannelAvatar, { channel: channel, userId: userId, theme: theme })),
+            React__default.createElement("div", { className: "sendbird-channel-preview__content" },
+                React__default.createElement("div", { className: "sendbird-channel-preview__content__upper" },
+                    React__default.createElement("div", { className: "sendbird-channel-preview__content__upper__header" },
+                        (channel.isBroadcast || false) && (React__default.createElement("div", { className: "sendbird-channel-preview__content__upper__header__broadcast-icon" },
+                            React__default.createElement(Icon, { type: IconTypes.BROADCAST, fillColor: IconColors.SECONDARY, height: "16px", width: "16px" }))),
+                        React__default.createElement(Label, { className: "sendbird-channel-preview__content__upper__header__channel-name", type: LabelTypography.SUBTITLE_2, color: LabelColors.ONBACKGROUND_1 }, channelName),
+                        React__default.createElement(Label, { className: "sendbird-channel-preview__content__upper__header__total-members", type: LabelTypography.CAPTION_2, color: LabelColors.ONBACKGROUND_2 }, getTotalMembers(channel)),
+                        (channel.isFrozen) && (React__default.createElement("div", { title: "Frozen", className: "sendbird-channel-preview__content__upper__header__frozen-icon" },
+                            React__default.createElement(Icon, { type: IconTypes.FREEZE, fillColor: IconColors.PRIMARY, height: 12, width: 12 })))),
+                    !channel.isEphemeral && isMessageStatusEnabled && (React__default.createElement(MessageStatus, { className: "sendbird-channel-preview__content__upper__last-message-at", channel: channel, message: channel.lastMessage, isDateSeparatorConsidered: false })),
+                    !channel.isEphemeral && !isMessageStatusEnabled && (React__default.createElement(Label, { className: "sendbird-channel-preview__content__upper__last-message-at", type: LabelTypography.CAPTION_3, color: LabelColors.ONBACKGROUND_2 }, getLastMessageCreatedAt({
+                        channel: channel,
+                        locale: dateLocale,
+                        stringSet: stringSet,
+                    })))),
+                React__default.createElement("div", { className: "sendbird-channel-preview__content__lower" },
+                    React__default.createElement(Label, { className: "sendbird-channel-preview__content__lower__last-message", type: LabelTypography.BODY_2, color: LabelColors.ONBACKGROUND_3 },
+                        isTyping && (React__default.createElement(TypingIndicatorText, { members: channel.getTypingUsers() })),
+                        !isTyping
+                            && !isVoiceMessage(channel.lastMessage)
+                            && getLastMessage(channel, stringSet),
+                        !isTyping
+                            && isVoiceMessage(channel.lastMessage)
+                            && stringSet.VOICE_MESSAGE),
+                    /**
+                     * Do not show unread count for focused channel. This is because of the limitation where
+                     * isScrollBottom and hasNext states needs to be added globally but they are from channel context
+                     * so channel list cannot see them with the current architecture.
+                     */
+                    !isSelected && !channel.isEphemeral && (React__default.createElement("div", { className: "sendbird-channel-preview__content__lower__unread-message-count" },
+                        isMentionEnabled && channel.unreadMentionCount > 0 ? (React__default.createElement(MentionUserLabel, { className: "sendbird-channel-preview__content__lower__unread-message-count__mention", color: "purple" }, '@')) : null,
+                        getChannelUnreadMessageCount(channel) ? ( // return number
+                        React__default.createElement(Badge, { count: getChannelUnreadMessageCount(channel) })) : null)))),
+            !isMobile && (React__default.createElement("div", { className: "sendbird-channel-preview__action" }, renderChannelAction({ channel: channel })))),
+        showMobileLeave && isMobile && (React__default.createElement(Modal, { className: "sendbird-channel-preview__leave--mobile", titleText: channelName, hideFooter: true, isCloseOnClickOutside: true, onCancel: function () { return setShowMobileLeave(false); } },
+            React__default.createElement(TextButton, { onClick: function () {
+                    onLeaveChannel();
+                    setShowMobileLeave(false);
+                }, className: "sendbird-channel-preview__leave-label--mobile" },
+                React__default.createElement(Label, { type: LabelTypography.SUBTITLE_1, color: LabelColors.ONBACKGROUND_1 }, stringSet.CHANNEL_PREVIEW_MOBILE_LEAVE))))));
+};
+
+var ChannelPreview = function (_a) {
+    var _b, _c, _d, _e, _f, _g, _h;
+    var channel = _a.channel, _j = _a.isActive, isActive = _j === void 0 ? false : _j, _k = _a.isTyping, isTyping = _k === void 0 ? false : _k, renderChannelAction = _a.renderChannelAction, onLeaveChannel = _a.onLeaveChannel, onClick = _a.onClick, tabIndex = _a.tabIndex;
+    var sbState = useSendbirdStateContext();
+    var _l = useChannelListContext(), _m = _l.isTypingIndicatorEnabled, isTypingIndicatorEnabled = _m === void 0 ? false : _m, _o = _l.isMessageReceiptStatusEnabled, isMessageReceiptStatusEnabled = _o === void 0 ? false : _o;
+    var stringSet = useLocalization().stringSet;
+    var userId = (_d = (_c = (_b = sbState === null || sbState === void 0 ? void 0 : sbState.stores) === null || _b === void 0 ? void 0 : _b.userStore) === null || _c === void 0 ? void 0 : _c.user) === null || _d === void 0 ? void 0 : _d.userId;
+    var isMessageStatusEnabled = isMessageReceiptStatusEnabled
+        && (((_e = channel === null || channel === void 0 ? void 0 : channel.lastMessage) === null || _e === void 0 ? void 0 : _e.messageType) === 'user' || ((_f = channel === null || channel === void 0 ? void 0 : channel.lastMessage) === null || _f === void 0 ? void 0 : _f.messageType) === 'file')
+        && ((_h = (_g = channel === null || channel === void 0 ? void 0 : channel.lastMessage) === null || _g === void 0 ? void 0 : _g.sender) === null || _h === void 0 ? void 0 : _h.userId) === userId;
+    var channelName = getChannelTitle(channel, userId, stringSet);
+    return (React__default.createElement(GroupChannelListItemView, { channel: channel, tabIndex: tabIndex, isTyping: isTypingIndicatorEnabled && isTyping, isSelected: isActive, channelName: channelName, isMessageStatusEnabled: isMessageStatusEnabled, onClick: onClick, onLeaveChannel: onLeaveChannel, renderChannelAction: renderChannelAction }));
+};
+
+export { ChannelPreview as C, GroupChannelListItemView as G, GroupChannelListProvider as a, useGroupChannelListContext as u };
+//# sourceMappingURL=bundle-AnoUW9yQ.js.map

package/chunks/{bundle-ETZY-eQc.js.map → bundle-AnoUW9yQ.js.map}

@@ -1 +1 @@
-{"version":3,"file":"bundle-ETZY-eQc.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"bundle-AnoUW9yQ.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/chunks/{bundle-xsV7pD8p.js → bundle-BbdMr4SL.js}

@@ -1,6 +1,4 @@
-import { a as __spreadArray } from './bundle-GKopZh-T.js';
-import { f as format } from './bundle-WDOQg3ty.js';
-import { a as isReadMessage } from './bundle-uk2Y0AQu.js';
+import { a as __spreadArray } from './bundle-fgwje9pW.js';
 import { SendingStatus } from '@sendbird/chat/message';
 
 var scrollToRenderedMessage = function (scrollRef, initialTimeStamp, setIsScrolled) {
@@ -99,28 +97,6 @@ var mergeAndSortMessages = function (oldMessages, newMessages) {
     var unique = getUniqueListByMessageId(mergedMessages);
     return sortByCreatedAt(unique);
 };
-var getMessageCreatedAt = function (message) { return format(message.createdAt, 'p'); };
-var isSameGroup = function (message, comparingMessage, currentChannel) {
-    var _a, _b;
-    if (!(message
-        && comparingMessage
-        && message.messageType
-        && message.messageType !== 'admin'
-        && comparingMessage.messageType
-        && (comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.messageType) !== 'admin'
-        && 'sender' in message
-        && 'sender' in comparingMessage
-        && message.createdAt
-        && comparingMessage.createdAt
-        && message.sender.userId
-        && comparingMessage.sender.userId)) {
-        return false;
-    }
-    return ((message === null || message === void 0 ? void 0 : message.sendingStatus) === (comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.sendingStatus)
-        && ((_a = message === null || message === void 0 ? void 0 : message.sender) === null || _a === void 0 ? void 0 : _a.userId) === ((_b = comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.sender) === null || _b === void 0 ? void 0 : _b.userId)
-        && getMessageCreatedAt(message) === getMessageCreatedAt(comparingMessage)
-        && isReadMessage(currentChannel, message) === isReadMessage(currentChannel, comparingMessage));
-};
 var passUnsuccessfullMessages = function (allMessages, newMessage) {
     if ('sendingStatus' in newMessage
         && (newMessage.sendingStatus === SendingStatus.SUCCEEDED || newMessage.sendingStatus === SendingStatus.PENDING)) {
@@ -143,5 +119,5 @@ var isAboutSame = function (a, b, px) {
     return Math.abs(a - b) <= px;
 };
 
-export { scrollToRenderedMessage as a, isDisabledBecauseMuted as b, isOperator as c, isSameGroup as d, isAboutSame as e, getNicknamesMapFromMembers as f, getAllEmojisMapFromEmojiContainer as g, isDisabledBecauseFrozen as i, mergeAndSortMessages as m, passUnsuccessfullMessages as p, scrollIntoLast as s };
-//# sourceMappingURL=bundle-xsV7pD8p.js.map
+export { scrollToRenderedMessage as a, isDisabledBecauseFrozen as b, isDisabledBecauseMuted as c, getNicknamesMapFromMembers as d, getAllEmojisMapFromEmojiContainer as g, isAboutSame as i, mergeAndSortMessages as m, passUnsuccessfullMessages as p, scrollIntoLast as s };
+//# sourceMappingURL=bundle-BbdMr4SL.js.map

package/chunks/bundle-BbdMr4SL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-BbdMr4SL.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/chunks/{bundle-F3QT9IFj.js → bundle-Bph6KjZN.js}

@@ -1,7 +1,7 @@
 import React__default from 'react';
 import ContextMenu, { MenuItems, MenuItem } from '../ui/ContextMenu.js';
 import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
-import { u as useLocalization } from './bundle-y_LgB6DS.js';
+import { u as useLocalization } from './bundle-hOV701rb.js';
 
 var OpenChannelMessageStatusTypes = {
     NONE: 'none',
@@ -95,4 +95,4 @@ var OpenChannelMobileMenu = function (props) {
 };
 
 export { OpenChannelMobileMenu as O, isFineEdit as a, isFineResend as b, isFineDelete as c, checkIsPending as d, checkIsFailed as e, checkIsSent as f, getSenderFromMessage as g, isFineCopy as i, showMenuTrigger as s };
-//# sourceMappingURL=bundle-F3QT9IFj.js.map
+//# sourceMappingURL=bundle-Bph6KjZN.js.map

package/chunks/{bundle-GKopZh-T.js.map → bundle-Bph6KjZN.js.map}

@@ -1 +1 @@
-{"version":3,"file":"bundle-GKopZh-T.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"bundle-Bph6KjZN.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}