@sendbird/uikit-react 3.10.0 → 3.10.2-alpha.0

package/chunks/bundle-GnFOVDL2.js

@@ -0,0 +1,230 @@
+import { _ as __assign } from './bundle-BA7tv0JB.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-3GWXgoxj.js';
+import { u as useGroupChannelContext } from './bundle-zKBdD-J6.js';
+import { useIIFE, useGroupChannelHandler } from '@sendbird/uikit-tools';
+import { T as TypingIndicatorType, M as MessageList$1 } from './bundle-1zn-WT_r.js';
+import PlaceHolder, { PlaceHolderTypes } from '../ui/PlaceHolder.js';
+import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
+import { L as getSuggestedReplies, Q as isSendableMessage } from './bundle-N9hMnIRl.js';
+import { i as isDisabledBecauseFrozen, a as isDisabledBecauseMuted, c as getComponentKeyFromMessage } from './bundle-tPCzzoc1.js';
+import { a as MessageView } from './bundle-beMggMMW.js';
+import { a as FileViewerView } from './bundle-khgxDrnA.js';
+import { a as RemoveMessageModalView } from './bundle-bAY1j7eP.js';
+import { getMessagePartsInfo } from '../Channel/utils/getMessagePartsInfo.js';
+import { U as UnreadCount } from './bundle-VbkO6hwH.js';
+import { F as FrozenNotification } from './bundle-G7HnuZsw.js';
+import { S as SCROLL_BUFFER } from './bundle-MBrlu_LK.js';
+import { MessageProvider } from '../Message/context.js';
+import TypingIndicatorBubble from '../ui/TypingIndicatorBubble.js';
+import { T as TypingIndicator } from './bundle-uIetzCLw.js';
+import ConnectionStatus from '../ui/ConnectionStatus.js';
+import { M as MessageInputWrapperView } from './bundle-DSoowPBh.js';
+import './bundle-BBjosDA0.js';
+import './bundle-drww6xht.js';
+import '../VoiceRecorder/context.js';
+import '../withSendbird.js';
+import './bundle-I8JFwttJ.js';
+import './bundle-LWD0OLz8.js';
+import 'react-dom';
+import './bundle-r9j_eCHc.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;
+        if (message.messageId !== ((_a = currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.lastMessage) === null || _a === void 0 ? void 0 : _a.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 context = useGroupChannelContext();
+    return (React__default.createElement(MessageInputWrapperView, __assign({}, props, 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 () { return (React__default.createElement(MessageInputWrapper$1, __assign({}, props))); } })));
+};
+
+export { ChannelUI as C, GroupChannelUIView as G };
+//# sourceMappingURL=bundle-GnFOVDL2.js.map

package/chunks/{bundle-P_LfQm7L.js.map → bundle-GnFOVDL2.js.map}

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

package/chunks/{bundle-cYhstyoi.js → bundle-I8JFwttJ.js}

@@ -1,6 +1,6 @@
-import { a as __spreadArray } from './bundle-Dv_OpODB.js';
+import { a as __spreadArray } from './bundle-BA7tv0JB.js';
 import React__default from 'react';
-import { g as getStringSet } from './bundle-P_LfQm7L.js';
+import { g as getStringSet } from './bundle-jy6_UG14.js';
 
 var Typography = {
     H_1: 'H_1',
@@ -77,4 +77,4 @@ var LabelColors = Colors;
 var LabelStringSet = getStringSet('en');
 
 export { Label as L, LabelTypography as a, LabelColors as b, LabelStringSet as c, changeColorToClassName as d };
-//# sourceMappingURL=bundle-cYhstyoi.js.map
+//# sourceMappingURL=bundle-I8JFwttJ.js.map

package/chunks/bundle-I8JFwttJ.js.map

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

package/chunks/{bundle-ZExhHi47.js → bundle-IRlSmJVg.js}

@@ -1,5 +1,4 @@
-import { a as __spreadArray } from './bundle-Dv_OpODB.js';
-import { K as isUrl } from './bundle-aD4V4aI8.js';
+import { a as __spreadArray } from './bundle-BA7tv0JB.js';
 
 var USER_MENTION_PREFIX = '@';
 
@@ -52,21 +51,38 @@ function identifyMentions(_a) {
     return results;
 }
 function identifyUrlsAndStrings(token) {
+    var URL_REG = /(?:https?:\/\/|www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.(xn--)?[a-z0-9-]{2,20}\b([-a-zA-Z0-9@:%_+[\],.~#?&/=]*[-a-zA-Z0-9@:%_+~#?&/=])*/g;
     var results = token.map(function (token) {
         if (token.type !== TOKEN_TYPES.undetermined) {
             return token;
         }
         var _a = token.value, value = _a === void 0 ? '' : _a;
-        var parts = value.split(' ');
-        var tokens = parts.map(function (part) {
-            if (isUrl(part)) {
-                return { value: part, type: TOKEN_TYPES.url };
-            }
-            else {
-                return { value: part, type: TOKEN_TYPES.string };
-            }
+        var matches = Array.from(value.matchAll(URL_REG));
+        var founds = matches.map(function (value) {
+            var _a;
+            var text = value[0];
+            var start = (_a = value.index) !== null && _a !== void 0 ? _a : 0;
+            var end = start + text.length;
+            return { text: text, start: start, end: end };
         });
-        return tokens;
+        var items = [{ value: value, type: TOKEN_TYPES.string }];
+        var cursor = 0;
+        founds.forEach(function (_a) {
+            var text = _a.text, start = _a.start, end = _a.end;
+            var restText = items.pop().value;
+            var head = restText.slice(0, start - cursor);
+            var mid = text;
+            var tail = restText.slice(end - cursor);
+            items.push({ value: head, type: TOKEN_TYPES.string }, { value: mid, type: TOKEN_TYPES.url });
+            if (tail.length > 0)
+                items.push({ value: tail, type: TOKEN_TYPES.string });
+            cursor = end;
+        });
+        // Remove the first empty string
+        if (items[0].value === '' && items[0].type === TOKEN_TYPES.string) {
+            items.shift();
+        }
+        return items;
     }).flat();
     return results;
 }
@@ -74,7 +90,7 @@ function combineNearbyStrings(tokens) {
     var results = tokens.reduce(function (acc, token) {
         var lastToken = acc[acc.length - 1];
         if ((lastToken === null || lastToken === void 0 ? void 0 : lastToken.type) === TOKEN_TYPES.string && token.type === TOKEN_TYPES.string) {
-            lastToken.value = "".concat(lastToken.value, " ").concat(token.value);
+            lastToken.value = "".concat(lastToken.value).concat(token.value);
             return acc;
         }
         return __spreadArray(__spreadArray([], acc, true), [token], false);
@@ -129,4 +145,4 @@ function getWhiteSpacePreservedText(text) {
 }
 
 export { TOKEN_TYPES as T, USER_MENTION_PREFIX as U, getWhiteSpacePreservedText as g, tokenizeMessage as t };
-//# sourceMappingURL=bundle-ZExhHi47.js.map
+//# sourceMappingURL=bundle-IRlSmJVg.js.map

package/chunks/bundle-IRlSmJVg.js.map

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

package/chunks/{bundle-fDGhJhA3.js → bundle-J3DrW9X2.js}

@@ -1,13 +1,13 @@
-import { a as __spreadArray } from './bundle-Dv_OpODB.js';
+import { a as __spreadArray } from './bundle-BA7tv0JB.js';
 import React__default from 'react';
-import { f as format } from './bundle-gzQGUVJt.js';
+import { f as format } from './bundle-hDx2-CRe.js';
 import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
-import { c as LabelStringSet, L as Label, a as LabelTypography, b as LabelColors } from './bundle-cYhstyoi.js';
+import { c as LabelStringSet, L as Label, a as LabelTypography, b as LabelColors } from './bundle-I8JFwttJ.js';
 import Loader from '../ui/Loader.js';
-import { c as isImage, s as isGif, f as isVideo, A as isAudio, B as isVoiceMessageMimeType, C as isSentStatus } from './bundle-aD4V4aI8.js';
+import { u as isImage, x as isGif, w as isVideo, z as isAudio, A as isVoiceMessageMimeType, B as isSentStatus } from './bundle-N9hMnIRl.js';
 import { getOutgoingMessageState, OutgoingMessageStates } from '../utils/message/getOutgoingMessageState.js';
-import { i as isToday, a as isYesterday, b as isThisYear } from './bundle-cN2gAFB_.js';
-import { u as useLocalization } from './bundle-AilPIINY.js';
+import { i as isToday, a as isYesterday, b as isThisYear } from './bundle-lUrIOx9p.js';
+import { u as useLocalization } from './bundle-BBjosDA0.js';
 
 var getChannelTitle = function (channel, currentUserId, stringSet) {
     var _a;
@@ -127,5 +127,5 @@ function MessageStatus(_a) {
             : getLastMessageCreatedAt({ channel: channel, locale: dateLocale, stringSet: stringSet })))));
 }
 
-export { MessageStatus as M, getTotalMembers as a, getLastMessageCreatedAt as b, getLastMessage as c, getChannelUnreadMessageCount as d, MessageStatusTypes as e, getChannelTitle as g };
-//# sourceMappingURL=bundle-fDGhJhA3.js.map
+export { MessageStatus as M, getLastMessageCreatedAt as a, getLastMessage as b, getChannelUnreadMessageCount as c, getChannelTitle as d, MessageStatusTypes as e, getTotalMembers as g };
+//# sourceMappingURL=bundle-J3DrW9X2.js.map

package/chunks/bundle-J3DrW9X2.js.map

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

package/chunks/{bundle-y_DSrC-A.js → bundle-LWD0OLz8.js}

@@ -23,4 +23,4 @@ var changeColorToClassName = function (color) {
 };
 
 export { Colors as C, changeColorToClassName as c };
-//# sourceMappingURL=bundle-y_DSrC-A.js.map
+//# sourceMappingURL=bundle-LWD0OLz8.js.map

package/chunks/bundle-LWD0OLz8.js.map

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

package/chunks/{bundle-QjcHKpDK.js → bundle-MBrlu_LK.js}

@@ -27,5 +27,5 @@ var SLIDER_BUTTON_ICON_SIDE_LENGTH = '32px';
 // multiple files message file info count limit
 var DEFAULT_MULTIPLE_FILES_MESSAGE_LIMIT = 10;
 
-export { BROWSER_SUPPORT_MIME_TYPE_LIST as B, DELIVERY_RECEIPT as D, META_ARRAY_VOICE_DURATION_KEY as M, ONE_MiB as O, SCROLL_BUFFER as S, VOICE_RECORDER_AUDIO_BIT_RATE as V, VOICE_MESSAGE_FILE_NAME as a, VOICE_MESSAGE_MIME_TYPE as b, VOICE_RECORDER_DEFAULT_MIN as c, VOICE_RECORDER_AUDIO_SAMPLE_RATE as d, VOICE_PLAYER_AUDIO_ID as e, VOICE_RECORDER_CLICK_BUFFER_TIME as f, VOICE_PLAYER_ROOT_ID as g, SLIDER_BUTTON_ICON_SIDE_LENGTH as h, META_ARRAY_MESSAGE_TYPE_KEY as i, META_ARRAY_MESSAGE_TYPE_VALUE__VOICE as j, DEFAULT_MULTIPLE_FILES_MESSAGE_LIMIT as k, VOICE_RECORDER_DEFAULT_MAX as l };
-//# sourceMappingURL=bundle-QjcHKpDK.js.map
+export { BROWSER_SUPPORT_MIME_TYPE_LIST as B, DELIVERY_RECEIPT as D, META_ARRAY_VOICE_DURATION_KEY as M, ONE_MiB as O, SCROLL_BUFFER as S, VOICE_RECORDER_AUDIO_BIT_RATE as V, VOICE_MESSAGE_FILE_NAME as a, VOICE_MESSAGE_MIME_TYPE as b, VOICE_RECORDER_AUDIO_SAMPLE_RATE as c, VOICE_PLAYER_AUDIO_ID as d, VOICE_RECORDER_CLICK_BUFFER_TIME as e, VOICE_RECORDER_DEFAULT_MIN as f, VOICE_PLAYER_ROOT_ID as g, META_ARRAY_MESSAGE_TYPE_KEY as h, META_ARRAY_MESSAGE_TYPE_VALUE__VOICE as i, SLIDER_BUTTON_ICON_SIDE_LENGTH as j, DEFAULT_MULTIPLE_FILES_MESSAGE_LIMIT as k, VOICE_RECORDER_DEFAULT_MAX as l };
+//# sourceMappingURL=bundle-MBrlu_LK.js.map

package/chunks/bundle-MBrlu_LK.js.map

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

package/chunks/{bundle-aD4V4aI8.js → bundle-N9hMnIRl.js}

@@ -1,6 +1,7 @@
-import { _ as __assign, a as __spreadArray } from './bundle-Dv_OpODB.js';
+import { _ as __assign, a as __spreadArray } from './bundle-BA7tv0JB.js';
+import { GroupChannelListOrder } from '@sendbird/chat/groupChannel';
 import { OutgoingMessageStates, getOutgoingMessageState } from '../utils/message/getOutgoingMessageState.js';
-import { K } from './bundle-rQ1k1Cpu.js';
+import { K } from './bundle-aKXnhi3A.js';
 
 // https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Complete_list_of_MIME_types
 var SUPPORTED_MIMES = {
@@ -251,7 +252,10 @@ function getSuggestedReplies(message) {
         return [];
     }
 }
-var URL_REG = /^((http|https):\/\/)?([a-z\d]+\.)+[a-z]{2,6}(\:[0-9]{1,5})?(\/[-a-zA-Z\d%_.~+&=]*)*(\?[;&a-zA-Z\d%_.~+=-]*)?(#\S*)?$/;
+var URL_REG = /^((http|https):\/\/)?([a-z\d-]+\.)+[a-z]{2,}(\:[0-9]{1,5})?(\/[-a-zA-Z\d%_.~+&=]*)*(\?[;&a-zA-Z\d%_.~+=-]*)?(#\S*)?$/;
+/** @deprecated
+ * URL detection in a message text will be handled in utils/tokens/tokenize.ts
+ */
 var isUrl = function (text) { return URL_REG.test(text); };
 var truncateString = function (fullStr, strLen) {
     if (!strLen)
@@ -558,28 +562,26 @@ var filterChannelListParams = function (params, channel, currentUserId) {
     }
     return true;
 };
-var binarySearch = function (list, number) {
-    var pivot = Math.floor(list.length / 2);
-    if (list[pivot] === number) {
-        return pivot;
-    }
-    var leftList = list.slice(0, pivot);
-    var rightList = list.slice(pivot + 1, list.length);
-    if (list[pivot] > number) {
-        return pivot + 1 + (rightList.length === 0 ? 0 : binarySearch(rightList, number));
+var sortChannelList = function (channels, order) {
+    var compareFunc = K(order)
+        .with(GroupChannelListOrder.CHANNEL_NAME_ALPHABETICAL, function () { return (function (a, b) { return a.name.localeCompare(b.name); }); })
+        .with(GroupChannelListOrder.CHRONOLOGICAL, function () { return (function (a, b) { return b.createdAt - a.createdAt; }); })
+        .otherwise(function () { return (function (a, b) { var _a, _b, _c, _d; return ((_b = (_a = b.lastMessage) === null || _a === void 0 ? void 0 : _a.createdAt) !== null && _b !== void 0 ? _b : Number.MIN_SAFE_INTEGER) - ((_d = (_c = a.lastMessage) === null || _c === void 0 ? void 0 : _c.createdAt) !== null && _d !== void 0 ? _d : Number.MIN_SAFE_INTEGER); }); });
+    return channels.sort(compareFunc);
+};
+/**
+ * Upserts given channel to the channel list and then returns the sorted channel list.
+ */
+var getChannelsWithUpsertedChannel = function (_channels, channel, order) {
+    var channels = __spreadArray([], _channels, true);
+    var findingIndex = channels.findIndex(function (ch) { return ch.url === channel.url; });
+    if (findingIndex !== -1) {
+        channels[findingIndex] = channel;
     }
     else {
-        return (leftList.length === 0) ? pivot : binarySearch(leftList, number);
-    }
-};
-// This is required when channel is displayed on channel list by filter
-var getChannelsWithUpsertedChannel = function (channels, channel) {
-    var _a;
-    if (channels.some(function (ch) { return ch.url === (channel === null || channel === void 0 ? void 0 : channel.url); })) {
-        return channels.map(function (ch) { return (ch.url === (channel === null || channel === void 0 ? void 0 : channel.url) ? channel : ch); });
+        channels.push(channel);
     }
-    var targetIndex = binarySearch(channels.map(function (channel) { var _a; return ((_a = channel === null || channel === void 0 ? void 0 : channel.lastMessage) === null || _a === void 0 ? void 0 : _a.createdAt) || (channel === null || channel === void 0 ? void 0 : channel.createdAt); }), ((_a = channel === null || channel === void 0 ? void 0 : channel.lastMessage) === null || _a === void 0 ? void 0 : _a.createdAt) || (channel === null || channel === void 0 ? void 0 : channel.createdAt));
-    return __spreadArray(__spreadArray(__spreadArray([], channels.slice(0, targetIndex), true), [channel], false), channels.slice(targetIndex, channels.length), true);
+    return sortChannelList(channels, order);
 };
 var StringObjType;
 (function (StringObjType) {
@@ -653,5 +655,5 @@ var isSendableMessage = function (message) {
     return Boolean(message) && 'sender' in message;
 };
 
-export { isAudio as A, isVoiceMessageMimeType as B, isSentStatus as C, arrayEqual as D, getMimeTypesUIKitAccepts as E, isImageMessage as F, isImageFileInfo as G, isAudioMessage as H, isOGMessage as I, isTextMessage as J, isUrl as K, isThreadMessage as L, getSuggestedReplies as M, getEmojiUrl as N, isReactedBy as O, getEmojiTooltipString as P, getEmojiMapAll as Q, isSendableMessage as R, StringObjType as S, filterChannelListParams as T, UIKitMessageTypes as U, getChannelsWithUpsertedChannel as V, filterMessageListParams as W, isTextuallyNull as X, isReadMessage as a, isMultipleFilesMessage as b, isImage as c, isFileMessage as d, isSupportedFileView as e, isVideo as f, isEditedMessage as g, getSenderName as h, isVoiceMessage as i, isUserMessage as j, isSentMessage as k, isFailedMessage as l, isPendingMessage as m, getClassName as n, copyToClipboard as o, getEmojiListAll as p, getUIKitFileTypes as q, isThumbnailMessage as r, isGif as s, getUIKitMessageType as t, getUIKitFileType as u, truncateString as v, getUIKitMessageTypes as w, isVideoMessage as x, isGifMessage as y, convertWordToStringObj as z };
-//# sourceMappingURL=bundle-aD4V4aI8.js.map
+export { isVoiceMessageMimeType as A, isSentStatus as B, arrayEqual as C, getMimeTypesUIKitAccepts as D, isSupportedFileView as E, isImageMessage as F, isImageFileInfo as G, isAudioMessage as H, isOGMessage as I, isTextMessage as J, isThreadMessage as K, getSuggestedReplies as L, getEmojiUrl as M, isReactedBy as N, getEmojiTooltipString as O, getEmojiMapAll as P, isSendableMessage as Q, filterChannelListParams as R, StringObjType as S, getChannelsWithUpsertedChannel as T, UIKitMessageTypes as U, filterMessageListParams as V, isTextuallyNull as W, isMultipleFilesMessage as a, isReadMessage as b, isFileMessage as c, isEditedMessage as d, isUserMessage as e, getUIKitMessageType as f, getSenderName as g, getUIKitMessageTypes as h, isVoiceMessage as i, getUIKitFileType as j, isThumbnailMessage as k, isSentMessage as l, isVideoMessage as m, isGifMessage as n, isFailedMessage as o, isPendingMessage as p, getClassName as q, copyToClipboard as r, getEmojiListAll as s, truncateString as t, isImage as u, getUIKitFileTypes as v, isVideo as w, isGif as x, convertWordToStringObj as y, isAudio as z };
+//# sourceMappingURL=bundle-N9hMnIRl.js.map

package/chunks/{bundle-aD4V4aI8.js.map → bundle-N9hMnIRl.js.map}

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

package/chunks/bundle-NjNqsDXb.js

@@ -0,0 +1,11 @@
+/**
+ * This function helps consider the every condition
+ * related to enabling emoji reaction feature.
+ */
+function getIsReactionEnabled(_a) {
+    var _b = _a.isBroadcast, isBroadcast = _b === void 0 ? false : _b, _c = _a.isSuper, isSuper = _c === void 0 ? false : _c, _d = _a.globalLevel, globalLevel = _d === void 0 ? true : _d, moduleLevel = _a.moduleLevel;
+    return !(isBroadcast || isSuper) && (moduleLevel !== null && moduleLevel !== void 0 ? moduleLevel : globalLevel);
+}
+
+export { getIsReactionEnabled as g };
+//# sourceMappingURL=bundle-NjNqsDXb.js.map

package/chunks/bundle-NjNqsDXb.js.map

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

package/chunks/{bundle-1pnUZsGs.js → bundle-NwZvowyL.js}

@@ -11,4 +11,4 @@ function compareIds(a, b) {
 }
 
 export { compareIds as c };
-//# sourceMappingURL=bundle-1pnUZsGs.js.map
+//# sourceMappingURL=bundle-NwZvowyL.js.map

package/chunks/bundle-NwZvowyL.js.map

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

package/chunks/bundle-OAJaPWYb.js

@@ -0,0 +1,27 @@
+import React__default, { useState } from 'react';
+import { u as useChannelListContext } from './bundle-otzUyFE_.js';
+import IconButton from '../ui/IconButton.js';
+import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
+import CreateChannel from '../CreateChannel.js';
+import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
+
+var AddGroupChannelView = function (_a) {
+    var createChannelVisible = _a.createChannelVisible, onChangeCreateChannelVisible = _a.onChangeCreateChannelVisible, onBeforeCreateChannel = _a.onBeforeCreateChannel, onCreateChannelClick = _a.onCreateChannelClick, onChannelCreated = _a.onChannelCreated;
+    var config = useSendbirdStateContext().config;
+    return (React__default.createElement(React__default.Fragment, null,
+        React__default.createElement(IconButton, { height: '32px', width: '32px', disabled: !config.isOnline, onClick: function () { return onChangeCreateChannelVisible(true); } },
+            React__default.createElement(Icon, { type: IconTypes.CREATE, fillColor: IconColors.PRIMARY, width: '24px', height: '24px' })),
+        createChannelVisible && (React__default.createElement(CreateChannel, { onCancel: function () { return onChangeCreateChannelVisible(false); }, onChannelCreated: function (channel) {
+                onChannelCreated === null || onChannelCreated === void 0 ? void 0 : onChannelCreated(channel);
+                onChangeCreateChannelVisible(false);
+            }, onBeforeCreateChannel: onBeforeCreateChannel, onCreateChannelClick: onCreateChannelClick }))));
+};
+
+var AddChannel = function () {
+    var _a = useState(false), showModal = _a[0], setShowModal = _a[1];
+    var _b = useChannelListContext(), overrideInviteUser = _b.overrideInviteUser, onBeforeCreateChannel = _b.onBeforeCreateChannel, onChannelSelect = _b.onChannelSelect;
+    return (React__default.createElement(AddGroupChannelView, { createChannelVisible: showModal, onChangeCreateChannelVisible: setShowModal, onCreateChannelClick: overrideInviteUser, onBeforeCreateChannel: onBeforeCreateChannel, onChannelCreated: onChannelSelect }));
+};
+
+export { AddChannel as A, AddGroupChannelView as a };
+//# sourceMappingURL=bundle-OAJaPWYb.js.map

package/chunks/bundle-OAJaPWYb.js.map

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

package/chunks/{bundle-Lxhlm_wG.js → bundle-OFH4qWaN.js}

@@ -3,9 +3,9 @@ import { PlaybackTime } from '../ui/PlaybackTime.js';
 import { ProgressBar } from '../ui/ProgressBar.js';
 import TextButton from '../ui/TextButton.js';
 import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
-import { b as LabelColors, L as Label, a as LabelTypography } from './bundle-cYhstyoi.js';
-import { u as useLocalization } from './bundle-AilPIINY.js';
-import { f as VOICE_RECORDER_CLICK_BUFFER_TIME, c as VOICE_RECORDER_DEFAULT_MIN } from './bundle-QjcHKpDK.js';
+import { b as LabelColors, L as Label, a as LabelTypography } from './bundle-I8JFwttJ.js';
+import { u as useLocalization } from './bundle-BBjosDA0.js';
+import { e as VOICE_RECORDER_CLICK_BUFFER_TIME, f as VOICE_RECORDER_DEFAULT_MIN } from './bundle-MBrlu_LK.js';
 
 /* eslint-disable no-redeclare */
 var VoiceMessageInputStatus = {
@@ -93,4 +93,4 @@ var VoiceMessageInput = function (_a) {
 };
 
 export { VoiceMessageInputStatus as V, VoiceMessageInput as a };
-//# sourceMappingURL=bundle-Lxhlm_wG.js.map
+//# sourceMappingURL=bundle-OFH4qWaN.js.map

package/chunks/{bundle-Lxhlm_wG.js.map → bundle-OFH4qWaN.js.map}

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

package/chunks/{bundle-XkweI7LG.js → bundle-OJ-0ytxX.js}

@@ -5,4 +5,4 @@ var USER_ACTIONS = {
 };
 
 export { USER_ACTIONS as U };
-//# sourceMappingURL=bundle-XkweI7LG.js.map
+//# sourceMappingURL=bundle-OJ-0ytxX.js.map

package/chunks/bundle-OJ-0ytxX.js.map

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

package/chunks/bundle-Q8kUKu5l.js

@@ -0,0 +1,34 @@
+import { useCallback } from 'react';
+
+var LOG_PRESET = 'useToggleReactionCallback:';
+function useToggleReactionCallback(currentChannel, logger) {
+    return useCallback(function (message, key, isReacted) {
+        if (!currentChannel) {
+            logger.warning("".concat(LOG_PRESET, " currentChannel doesn't exist"), currentChannel);
+            return;
+        }
+        if (isReacted) {
+            currentChannel
+                .deleteReaction(message, key)
+                .then(function (res) {
+                logger.info("".concat(LOG_PRESET, " Delete reaction success"), res);
+            })
+                .catch(function (err) {
+                logger.warning("".concat(LOG_PRESET, " Delete reaction failed"), err);
+            });
+        }
+        else {
+            currentChannel
+                .addReaction(message, key)
+                .then(function (res) {
+                logger.info("".concat(LOG_PRESET, " Add reaction success"), res);
+            })
+                .catch(function (err) {
+                logger.warning("".concat(LOG_PRESET, " Add reaction failed"), err);
+            });
+        }
+    }, [currentChannel]);
+}
+
+export { useToggleReactionCallback as u };
+//# sourceMappingURL=bundle-Q8kUKu5l.js.map

package/chunks/bundle-Q8kUKu5l.js.map

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