@sendbird/uikit-react 3.18.4 → 3.19.0

package/cjs/chunks/{bundle-CYSJJmTZ.js → bundle-BUvZj7cQ.js}

@@ -1,21 +1,21 @@
 'use strict';
 
-var _tslib = require('./bundle-Bd2CeRt-.js');
+var _tslib = require('./bundle-Cy2hoAU0.js');
 var React = require('react');
 var message = require('@sendbird/chat/message');
-var utils = require('./bundle--7hPuXVE.js');
-var UserProfileContext = require('./bundle-Bdq9hoDy.js');
-var SendbirdContext = require('./bundle-DiOxeQAO.js');
+var utils = require('./bundle-BXkr0YUW.js');
+var UserProfileContext = require('./bundle-CBsIaz1F.js');
+var SendbirdContext = require('./bundle-1o4tJ2ll.js');
 var SendbirdChat = require('@sendbird/chat');
 var groupChannel = require('@sendbird/chat/groupChannel');
-var uuid = require('./bundle-DhODbqF3.js');
-var compareIds = require('./bundle-kCEJbgLb.js');
+var uuid = require('./bundle-Bb8Gf8D6.js');
+var compareIds = require('./bundle-D8Sq196Q.js');
 var uikitTools = require('@sendbird/uikit-tools');
 var Thread_context_types = require('../Thread/context/types.js');
-var useSendbird = require('./bundle-QhRhypRr.js');
-var useDeepCompareEffect = require('./bundle-CsAon8YT.js');
-var pubSub_topics = require('./bundle-BmMGEkJA.js');
-var consts = require('./bundle-CrpqUlR3.js');
+var useSendbird = require('./bundle-4i_6rq-O.js');
+var useDeepCompareEffect = require('./bundle-DBejULtB.js');
+var pubSub_topics = require('./bundle-DuVexw6o.js');
+var consts = require('./bundle-DET4Uytg.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -45,16 +45,18 @@ function useToggleReactionCallback(_a, _b) {
 var scrollToLastAfterSend = function () {
     setTimeout(function () { return utils.scrollIntoLast(); }, consts.SCROLL_BOTTOM_DELAY_FOR_SEND);
 };
-var attachLocalFilePreview = function (pendingMessage, file) {
+var attachLocalFilePreview = function (pendingMessage, file, localFilePreviews) {
     var localUrl = URL.createObjectURL(file);
     var localFileMessage = pendingMessage;
     localFileMessage.localUrl = localUrl;
     localFileMessage.file = file;
+    if (pendingMessage.reqId)
+        localFilePreviews.set(pendingMessage.reqId, { localUrl: localUrl, file: file });
     return localUrl;
 };
 function useThreadMessageActions(state, _a) {
     var logger = _a.logger, pubSub = _a.pubSub, isMentionEnabled = _a.isMentionEnabled;
-    var currentChannel = state.currentChannel, onBeforeSendUserMessage = state.onBeforeSendUserMessage, onBeforeSendFileMessage = state.onBeforeSendFileMessage, onBeforeSendVoiceMessage = state.onBeforeSendVoiceMessage, onBeforeSendMultipleFilesMessage = state.onBeforeSendMultipleFilesMessage, dsSendUserMessage = state.dsSendUserMessage, dsSendFileMessage = state.dsSendFileMessage, dsSendMultipleFilesMessage = state.dsSendMultipleFilesMessage, dsUpdateUserMessage = state.dsUpdateUserMessage, dsResendMessage = state.dsResendMessage, dsDeleteMessage = state.dsDeleteMessage;
+    var currentChannel = state.currentChannel, onBeforeSendUserMessage = state.onBeforeSendUserMessage, onBeforeSendFileMessage = state.onBeforeSendFileMessage, onBeforeSendVoiceMessage = state.onBeforeSendVoiceMessage, onBeforeSendMultipleFilesMessage = state.onBeforeSendMultipleFilesMessage, dsSendUserMessage = state.dsSendUserMessage, dsSendFileMessage = state.dsSendFileMessage, dsSendMultipleFilesMessage = state.dsSendMultipleFilesMessage, dsUpdateUserMessage = state.dsUpdateUserMessage, dsResendMessage = state.dsResendMessage, dsDeleteMessage = state.dsDeleteMessage, localFilePreviews = state.localFilePreviews;
     var sendMessage = React.useCallback(function (props) {
         var _a;
         var message = props.message, quoteMessage = props.quoteMessage, mentionTemplate = props.mentionTemplate, mentionedUsers = props.mentionedUsers;
@@ -92,6 +94,15 @@ function useThreadMessageActions(state, _a) {
     }, [dsSendUserMessage, onBeforeSendUserMessage, currentChannel, isMentionEnabled]);
     var sendFileMessage = React.useCallback(function (file, quoteMessage) {
         var _a;
+        if (!dsSendFileMessage || !currentChannel) {
+            var error = new Error('Thread | useThreadMessageActions: Sending file message cannot be sent because current channel or data source is unavailable.');
+            logger.warning('Thread | useThreadMessageActions: Sending file message failed, because current channel or data source is unavailable.', {
+                currentChannel: currentChannel,
+                dsSendFileMessage: dsSendFileMessage,
+                error: error,
+            });
+            return Promise.reject(error);
+        }
         var createParamsDefault = function () {
             var params = {};
             params.file = file;
@@ -102,17 +113,23 @@ function useThreadMessageActions(state, _a) {
             return params;
         };
         var params = (_a = onBeforeSendFileMessage === null || onBeforeSendFileMessage === void 0 ? void 0 : onBeforeSendFileMessage(file, quoteMessage)) !== null && _a !== void 0 ? _a : createParamsDefault();
-        if (!dsSendFileMessage || !currentChannel)
-            return Promise.resolve(null);
         logger.info('Thread | useThreadMessageActions: Sending file message start.', params);
         var localPreviewUrl;
+        var pendingReqId;
         return dsSendFileMessage(params, function (pendingMessage) {
-            localPreviewUrl = attachLocalFilePreview(pendingMessage, file);
+            pendingReqId = pendingMessage.reqId;
+            localPreviewUrl = attachLocalFilePreview(pendingMessage, file, localFilePreviews);
             scrollToLastAfterSend();
         })
             .then(function (sentMessage) {
-            if (localPreviewUrl)
+            var preview = pendingReqId && localFilePreviews.get(pendingReqId);
+            if (preview) {
+                URL.revokeObjectURL(preview.localUrl);
+                localFilePreviews.delete(pendingReqId);
+            }
+            else if (localPreviewUrl) {
                 URL.revokeObjectURL(localPreviewUrl);
+            }
             pubSub.publish(pubSub_topics.pubSubTopics.SEND_FILE_MESSAGE, {
                 channel: currentChannel,
                 message: sentMessage,
@@ -120,7 +137,7 @@ function useThreadMessageActions(state, _a) {
             });
             return sentMessage;
         });
-    }, [dsSendFileMessage, onBeforeSendFileMessage, currentChannel]);
+    }, [dsSendFileMessage, onBeforeSendFileMessage, currentChannel, localFilePreviews]);
     var sendVoiceMessage = React.useCallback(function (file, duration, quoteMessage) {
         var params = (onBeforeSendVoiceMessage && typeof onBeforeSendVoiceMessage === 'function')
             ? onBeforeSendVoiceMessage(file, quoteMessage)
@@ -141,13 +158,21 @@ function useThreadMessageActions(state, _a) {
             return;
         logger.info('Thread | useThreadMessageActions: Sending voice message start.', params);
         var localPreviewUrl;
+        var pendingReqId;
         dsSendFileMessage(params, function (pendingMessage) {
-            localPreviewUrl = attachLocalFilePreview(pendingMessage, file);
+            pendingReqId = pendingMessage.reqId;
+            localPreviewUrl = attachLocalFilePreview(pendingMessage, file, localFilePreviews);
             scrollToLastAfterSend();
         })
             .then(function (sentMessage) {
-            if (localPreviewUrl)
+            var preview = pendingReqId && localFilePreviews.get(pendingReqId);
+            if (preview) {
+                URL.revokeObjectURL(preview.localUrl);
+                localFilePreviews.delete(pendingReqId);
+            }
+            else if (localPreviewUrl) {
                 URL.revokeObjectURL(localPreviewUrl);
+            }
             pubSub.publish(pubSub_topics.pubSubTopics.SEND_FILE_MESSAGE, {
                 channel: currentChannel,
                 message: sentMessage,
@@ -157,9 +182,23 @@ function useThreadMessageActions(state, _a) {
             .catch(function (error) {
             logger.info('Thread | useThreadMessageActions: Sending voice message failed.', error);
         });
-    }, [dsSendFileMessage, onBeforeSendVoiceMessage, currentChannel]);
+    }, [dsSendFileMessage, onBeforeSendVoiceMessage, currentChannel, localFilePreviews]);
     var sendMultipleFilesMessage = React.useCallback(function (files, quoteMessage) {
         var _a;
+        if (files.length <= 1) {
+            var error = new Error('Thread | useThreadMessageActions: Sending multiple files message requires at least two files.');
+            logger.warning('Thread | useThreadMessageActions: Sending multiple files message failed, because there are no multiple files.', { files: files, error: error });
+            return Promise.reject(error);
+        }
+        if (!dsSendMultipleFilesMessage || !currentChannel) {
+            var error = new Error('Thread | useThreadMessageActions: Sending multiple files message cannot be sent because current channel or data source is unavailable.');
+            logger.warning('Thread | useThreadMessageActions: Sending multiple files message failed, because current channel or data source is unavailable.', {
+                currentChannel: currentChannel,
+                dsSendMultipleFilesMessage: dsSendMultipleFilesMessage,
+                error: error,
+            });
+            return Promise.reject(error);
+        }
         var createParamsDefault = function () {
             var params = {
                 fileInfoList: files.map(function (file) { return ({
@@ -176,8 +215,6 @@ function useThreadMessageActions(state, _a) {
             return params;
         };
         var params = (_a = onBeforeSendMultipleFilesMessage === null || onBeforeSendMultipleFilesMessage === void 0 ? void 0 : onBeforeSendMultipleFilesMessage(files, quoteMessage)) !== null && _a !== void 0 ? _a : createParamsDefault();
-        if (!dsSendMultipleFilesMessage || !currentChannel)
-            return Promise.resolve(null);
         logger.info('Thread | useThreadMessageActions: Sending multiple files message start.', params);
         return dsSendMultipleFilesMessage(params, function () { return scrollToLastAfterSend(); })
             .then(function (sentMessage) {
@@ -221,12 +258,29 @@ function useThreadMessageActions(state, _a) {
             logger.warning('Thread | useThreadMessageActions: Message update failed.', error);
         });
     }, [dsUpdateUserMessage, currentChannel, isMentionEnabled]);
-    var deleteMessage = React.useCallback(function (message) {
+    var deleteMessage = React.useCallback(function (message$1) {
         if (!dsDeleteMessage)
             return Promise.resolve();
-        logger.info('Thread | useThreadMessageActions: Deleting message.', message);
-        return dsDeleteMessage(message);
-    }, [dsDeleteMessage]);
+        logger.info('Thread | useThreadMessageActions: Deleting message.', message$1);
+        return dsDeleteMessage(message$1)
+            .then(function () {
+            var preview = message$1.reqId && localFilePreviews.get(message$1.reqId);
+            if (preview) {
+                URL.revokeObjectURL(preview.localUrl);
+                localFilePreviews.delete(message$1.reqId);
+            }
+        })
+            .catch(function (error) {
+            if (message$1.sendingStatus !== message.SendingStatus.SUCCEEDED && currentChannel) {
+                var preview = message$1.reqId && localFilePreviews.get(message$1.reqId);
+                if (preview) {
+                    URL.revokeObjectURL(preview.localUrl);
+                    localFilePreviews.delete(message$1.reqId);
+                }
+            }
+            throw error;
+        });
+    }, [dsDeleteMessage, localFilePreviews, currentChannel]);
     var resendMessage = React.useCallback(function (failedMessage) {
         if (!(failedMessage === null || failedMessage === void 0 ? void 0 : failedMessage.isResendable) || !dsResendMessage || !currentChannel) {
             logger.warning('Thread | useThreadMessageActions: Message is not resendable.', failedMessage);
@@ -277,36 +331,117 @@ var useThread = function () {
     var state = SendbirdContext.shimExports.useSyncExternalStore(store.subscribe, store.getState);
     var currentChannel = state.currentChannel;
     var toggleReaction = useToggleReactionCallback({ currentChannel: currentChannel }, { logger: logger });
-    var initializeThreadFetcher = React.useCallback(function (callback) {
-        var _a = store.getState(), resetWithStartingPoint = _a.resetWithStartingPoint, anchorMessage = _a.message, parentMessage = _a.parentMessage;
-        if (!resetWithStartingPoint)
-            return;
-        // Mirror ThreadProvider's initial startingPoint: anchor at the specific reply when entering from
-        // one, otherwise open at the latest edge (MAX). parentMessage.createdAt would anchor at the oldest
-        // edge (replies are created after the parent), hiding the latest replies behind hasMoreNext.
-        var startingPoint = (anchorMessage && parentMessage && anchorMessage.messageId !== parentMessage.messageId)
-            ? anchorMessage.createdAt
-            : Number.MAX_SAFE_INTEGER;
-        resetWithStartingPoint(startingPoint).then(function () {
-            setTimeout(function () { return callback === null || callback === void 0 ? void 0 : callback(store.getState().allThreadMessages); });
+    var initializeThreadFetcher = React.useCallback(function (callback) { return _tslib.__awaiter(void 0, void 0, void 0, function () {
+        var _a, resetWithStartingPoint, anchorMessage, parentMessage, startingPoint, page, error_1;
+        return _tslib.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = store.getState(), resetWithStartingPoint = _a.resetWithStartingPoint, anchorMessage = _a.message, parentMessage = _a.parentMessage;
+                    if (!resetWithStartingPoint)
+                        return [2 /*return*/];
+                    startingPoint = (anchorMessage && parentMessage && anchorMessage.messageId !== parentMessage.messageId)
+                        ? anchorMessage.createdAt
+                        : Number.MAX_SAFE_INTEGER;
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, resetWithStartingPoint(startingPoint, function (messages) {
+                            page = messages;
+                        })];
+                case 2:
+                    _b.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_1 = _b.sent();
+                    logger.warning('Thread resetWithStartingPoint failed', error_1);
+                    return [2 /*return*/];
+                case 4:
+                    // onFetched fires only when the fetch succeeded (an empty page arrives as []), so `undefined`
+                    // means the load failed or was guarded upstream — settle without the callback (pre-v3.18.3 behavior).
+                    if (page === undefined)
+                        return [2 /*return*/];
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    return [4 /*yield*/, new Promise(function (resolve) {
+                            setTimeout(resolve);
+                        })];
+                case 5:
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    _b.sent();
+                    callback === null || callback === void 0 ? void 0 : callback(page);
+                    return [2 /*return*/];
+            }
         });
-    }, [store]);
-    var fetchPrevThreads = React.useCallback(function (callback) {
-        var loadPrevious = store.getState().loadPrevious;
-        if (!loadPrevious)
-            return;
-        loadPrevious().then(function () {
-            setTimeout(function () { return callback === null || callback === void 0 ? void 0 : callback(store.getState().allThreadMessages); });
+    }); }, [store, logger]);
+    var fetchPrevThreads = React.useCallback(function (callback) { return _tslib.__awaiter(void 0, void 0, void 0, function () {
+        var loadPrevious, page;
+        return _tslib.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    loadPrevious = store.getState().loadPrevious;
+                    if (!loadPrevious)
+                        return [2 /*return*/];
+                    return [4 /*yield*/, loadPrevious(function (messages) {
+                            page = messages;
+                        })];
+                case 1:
+                    _a.sent();
+                    // onFetched fires only when the fetch succeeded (an empty page arrives as []), so `undefined`
+                    // means the load failed or was guarded upstream — settle without the callback (pre-v3.18.3 behavior).
+                    if (page === undefined)
+                        return [2 /*return*/];
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    return [4 /*yield*/, new Promise(function (resolve) {
+                            setTimeout(resolve);
+                        })];
+                case 2:
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    _a.sent();
+                    callback === null || callback === void 0 ? void 0 : callback(page);
+                    return [2 /*return*/];
+            }
         });
-    }, [store]);
-    var fetchNextThreads = React.useCallback(function (callback) {
-        var loadNext = store.getState().loadNext;
-        if (!loadNext)
-            return;
-        loadNext().then(function () {
-            setTimeout(function () { return callback === null || callback === void 0 ? void 0 : callback(store.getState().allThreadMessages); });
+    }); }, [store]);
+    var fetchNextThreads = React.useCallback(function (callback) { return _tslib.__awaiter(void 0, void 0, void 0, function () {
+        var loadNext, page;
+        return _tslib.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    loadNext = store.getState().loadNext;
+                    if (!loadNext)
+                        return [2 /*return*/];
+                    return [4 /*yield*/, loadNext(function (messages) {
+                            page = messages;
+                        })];
+                case 1:
+                    _a.sent();
+                    // onFetched fires only when the fetch succeeded (an empty page arrives as []), so `undefined`
+                    // means the load failed or was guarded upstream — settle without the callback (pre-v3.18.3 behavior).
+                    if (page === undefined)
+                        return [2 /*return*/];
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    return [4 /*yield*/, new Promise(function (resolve) {
+                            setTimeout(resolve);
+                        })];
+                case 2:
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    _a.sent();
+                    callback === null || callback === void 0 ? void 0 : callback(page);
+                    return [2 /*return*/];
+            }
         });
-    }, [store]);
+    }); }, [store]);
     var messageActions = useThreadMessageActions(state, { logger: logger, pubSub: pubSub, isMentionEnabled: isMentionEnabled });
     var simpleActions = {
         setCurrentUserId: React.useCallback(function (currentUserId) { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { currentUserId: currentUserId })); }); }, [store]),
@@ -619,6 +754,7 @@ var initialState = function () { return ({
     currentUserId: '',
     typingMembers: [],
     nicknamesMap: null,
+    localFilePreviews: new Map(),
 }); };
 var ThreadContext = React__default.default.createContext(null);
 var createThreadStore = function (props) { return SendbirdContext.createStore(_tslib.__assign(_tslib.__assign({}, initialState()), props)); };
@@ -642,7 +778,7 @@ var InternalThreadProvider = function (props) {
 };
 var ThreadManager = function (props) {
     var message$1 = props.message, channelUrl = props.channelUrl, onHeaderActionClick = props.onHeaderActionClick, onMoveToParentMessage = props.onMoveToParentMessage, onBeforeSendUserMessage = props.onBeforeSendUserMessage, onBeforeSendFileMessage = props.onBeforeSendFileMessage, onBeforeSendVoiceMessage = props.onBeforeSendVoiceMessage, onBeforeSendMultipleFilesMessage = props.onBeforeSendMultipleFilesMessage, onBeforeDownloadFileMessage = props.onBeforeDownloadFileMessage, isMultipleFilesMessageEnabled = props.isMultipleFilesMessageEnabled, filterEmojiCategoryIds = props.filterEmojiCategoryIds;
-    var _a = useThread().state, currentChannel = _a.currentChannel, parentMessage = _a.parentMessage, parentMessageState = _a.parentMessageState;
+    var _a = useThread().state, currentChannel = _a.currentChannel, parentMessage = _a.parentMessage, parentMessageState = _a.parentMessageState, localFilePreviews = _a.localFilePreviews;
     var updateState = useThreadStore().updateState;
     var propsParentMessage = utils.getParentMessageFrom(message$1);
     // Context from SendbirdProvider
@@ -738,6 +874,13 @@ var ThreadManager = function (props) {
     var hasMorePrev = threadDataSource.hasPrevious();
     var hasMoreNext = threadDataSource.hasNext();
     var store = React.useContext(ThreadContext);
+    React.useEffect(function () {
+        return function () {
+            var previews = store === null || store === void 0 ? void 0 : store.getState().localFilePreviews;
+            previews === null || previews === void 0 ? void 0 : previews.forEach(function (preview) { return URL.revokeObjectURL(preview.localUrl); });
+            previews === null || previews === void 0 ? void 0 : previews.clear();
+        };
+    }, [store]);
     var messagesSyncKey = threadDataSource.messages
         .map(function (message) {
         var uploadParams = message.messageParams;
@@ -748,12 +891,30 @@ var ThreadManager = function (props) {
     })
         .join('~');
     React.useEffect(function () {
-        if (!parentMessage)
+        if (!parentMessage) {
+            localFilePreviews.forEach(function (preview) { return URL.revokeObjectURL(preview.localUrl); });
+            localFilePreviews.clear();
             return;
+        }
+        var scopedMessages = threadDataSource.messages;
+        scopedMessages.forEach(function (message$1) {
+            var _a, _b;
+            var sendableMessage = message$1;
+            var preview = localFilePreviews.get(sendableMessage.reqId);
+            if (!preview)
+                return;
+            if (sendableMessage.sendingStatus === message.SendingStatus.SUCCEEDED) {
+                URL.revokeObjectURL(preview.localUrl);
+                localFilePreviews.delete(sendableMessage.reqId);
+                return;
+            }
+            var localFileMessage = message$1;
+            (_a = localFileMessage.localUrl) !== null && _a !== void 0 ? _a : (localFileMessage.localUrl = preview.localUrl);
+            (_b = localFileMessage.file) !== null && _b !== void 0 ? _b : (localFileMessage.file = preview.file);
+        });
         // core-ts scopes the collection to this thread's replies (belongsToThread on the event/fetch and
         // send/resend paths), so mirror them as-is. Split into the legacy public shape: allThreadMessages =
         // succeeded (server) messages, localThreadMessages = pending/failed; threadMessages = all of them.
-        var scopedMessages = threadDataSource.messages;
         var localThreadMessages = scopedMessages.filter(function (m) {
             var sendingStatus = m.sendingStatus;
             return sendingStatus === message.SendingStatus.PENDING || sendingStatus === message.SendingStatus.FAILED;
@@ -820,4 +981,4 @@ exports.ThreadManager = ThreadManager;
 exports.ThreadProvider = ThreadProvider;
 exports.useThread = useThread;
 exports.useThreadContext = useThreadContext;
-//# sourceMappingURL=bundle-CYSJJmTZ.js.map
+//# sourceMappingURL=bundle-BUvZj7cQ.js.map

package/cjs/chunks/bundle-BUvZj7cQ.js.map

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

package/cjs/chunks/{bundle-D_5YLGdQ.js → bundle-BWiJUwnR.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var ui_Label = require('./bundle-DaHh2cJb.js');
-var index = require('./bundle-ChU3wShD.js');
+var ui_Label = require('./bundle-DE8Y9-kK.js');
+var index = require('./bundle-IiaDOxN6.js');
 
 var getChannelTitle = function (channel, currentUserId, stringSet) {
     var _a;
@@ -25,4 +25,4 @@ var getChannelTitle = function (channel, currentUserId, stringSet) {
 };
 
 exports.getChannelTitle = getChannelTitle;
-//# sourceMappingURL=bundle-D_5YLGdQ.js.map
+//# sourceMappingURL=bundle-BWiJUwnR.js.map

package/cjs/chunks/bundle-BWiJUwnR.js.map

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

package/cjs/chunks/{bundle--7hPuXVE.js → bundle-BXkr0YUW.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 require('../utils/message/getOutgoingMessageState.js');
-require('./bundle-DC_iv7UY.js');
+require('./bundle-DJ-JijOD.js');
 
 var getNicknamesMapFromMembers = function (members) {
     if (members === void 0) { members = []; }
@@ -73,4 +73,4 @@ exports.getNicknamesMapFromMembers = getNicknamesMapFromMembers;
 exports.getParentMessageFrom = getParentMessageFrom;
 exports.isAboutSame = isAboutSame;
 exports.scrollIntoLast = scrollIntoLast;
-//# sourceMappingURL=bundle--7hPuXVE.js.map
+//# sourceMappingURL=bundle-BXkr0YUW.js.map

package/cjs/chunks/bundle-BXkr0YUW.js.map

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

package/cjs/chunks/{bundle-DGXoUR22.js → bundle-BaJ-XDQm.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var index$1 = require('./bundle-ChU3wShD.js');
-var index = require('./bundle-DHiRY4iN.js');
+var index$1 = require('./bundle-IiaDOxN6.js');
+var index = require('./bundle-D0OvVO0x.js');
 
 function getMessageFirstFileType(message) {
     return index.K(message)
@@ -71,4 +71,4 @@ exports.getMessageFirstFileName = getMessageFirstFileName;
 exports.getMessageFirstFileThumbnailUrl = getMessageFirstFileThumbnailUrl;
 exports.getMessageFirstFileType = getMessageFirstFileType;
 exports.getMessageFirstFileUrl = getMessageFirstFileUrl;
-//# sourceMappingURL=bundle-DGXoUR22.js.map
+//# sourceMappingURL=bundle-BaJ-XDQm.js.map

package/cjs/chunks/bundle-BaJ-XDQm.js.map

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

package/cjs/chunks/{bundle-B5VSJxvK.js → bundle-BasyRNED.js}

@@ -14,4 +14,4 @@ exports.MAX_USER_MENTION_COUNT = MAX_USER_MENTION_COUNT;
 exports.MAX_USER_SUGGESTION_COUNT = MAX_USER_SUGGESTION_COUNT;
 exports.UIKIT_COMPATIBLE_FORM_VERSION = UIKIT_COMPATIBLE_FORM_VERSION;
 exports.USER_MENTION_TEMP_CHAR = USER_MENTION_TEMP_CHAR;
-//# sourceMappingURL=bundle-B5VSJxvK.js.map
+//# sourceMappingURL=bundle-BasyRNED.js.map

package/cjs/chunks/bundle-BasyRNED.js.map

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

package/cjs/chunks/{bundle-DhODbqF3.js → bundle-Bb8Gf8D6.js}

@@ -12,4 +12,4 @@ var uuidv4 = function () { return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace
 }); };
 
 exports.uuidv4 = uuidv4;
-//# sourceMappingURL=bundle-DhODbqF3.js.map
+//# sourceMappingURL=bundle-Bb8Gf8D6.js.map

package/cjs/chunks/bundle-Bb8Gf8D6.js.map

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

package/cjs/chunks/{bundle-DamUsc0x.js → bundle-Bg44GO5k.js}

@@ -1,16 +1,16 @@
 'use strict';
 
-var _tslib = require('./bundle-Bd2CeRt-.js');
+var _tslib = require('./bundle-Cy2hoAU0.js');
 var React = require('react');
-var index$1 = require('./bundle-aa_brO8M.js');
+var index$1 = require('./bundle-D2NdV2-5.js');
 var ui_Icon = require('../ui/Icon.js');
-var ui_Label = require('./bundle-DaHh2cJb.js');
+var ui_Label = require('./bundle-DE8Y9-kK.js');
 var ui_Loader = require('../ui/Loader.js');
-var index$2 = require('./bundle-ChU3wShD.js');
+var index$2 = require('./bundle-IiaDOxN6.js');
 var utils_message_getOutgoingMessageState = require('../utils/message/getOutgoingMessageState.js');
-var index = require('./bundle-Dbz2Ubg9.js');
-var LocalizationContext = require('./bundle-DC_iv7UY.js');
-var utils = require('./bundle-DWY7_S-1.js');
+var index = require('./bundle-DQwJ8EZ0.js');
+var LocalizationContext = require('./bundle-DJ-JijOD.js');
+var utils = require('./bundle-Dl83958K.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -152,4 +152,4 @@ exports.getChannelUnreadMessageCount = getChannelUnreadMessageCount;
 exports.getLastMessageCreatedAt = getLastMessageCreatedAt;
 exports.getLastMessageText = getLastMessageText;
 exports.getTotalMembers = getTotalMembers;
-//# sourceMappingURL=bundle-DamUsc0x.js.map
+//# sourceMappingURL=bundle-Bg44GO5k.js.map

package/cjs/chunks/bundle-Bg44GO5k.js.map

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

package/cjs/chunks/{bundle-CW9L2JCZ.js → bundle-BgV93sCm.js}

@@ -1,9 +1,9 @@
 'use strict';
 
-var _tslib = require('./bundle-Bd2CeRt-.js');
+var _tslib = require('./bundle-Cy2hoAU0.js');
 var React = require('react');
-var SuggestedMentionListView = require('./bundle-LSzjfLJ2.js');
-var ThreadProvider = require('./bundle-CYSJJmTZ.js');
+var SuggestedMentionListView = require('./bundle-BTygW3-K.js');
+var ThreadProvider = require('./bundle-BUvZj7cQ.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -15,4 +15,4 @@ var SuggestedMentionList = function (props) {
 };
 
 exports.SuggestedMentionList = SuggestedMentionList;
-//# sourceMappingURL=bundle-CW9L2JCZ.js.map
+//# sourceMappingURL=bundle-BgV93sCm.js.map

package/cjs/chunks/bundle-BgV93sCm.js.map

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

package/cjs/chunks/{bundle-nrgz3P_F.js → bundle-BmTqH53r.js}

@@ -19,4 +19,4 @@ var NodeNames = {
 exports.MessageInputKeys = MessageInputKeys;
 exports.NodeNames = NodeNames;
 exports.NodeTypes = NodeTypes;
-//# sourceMappingURL=bundle-nrgz3P_F.js.map
+//# sourceMappingURL=bundle-BmTqH53r.js.map

package/cjs/chunks/bundle-BmTqH53r.js.map

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

package/cjs/chunks/{bundle-xWe8b62h.js → bundle-BtEpJHeW.js}

@@ -1,11 +1,11 @@
 'use strict';
 
-var _tslib = require('./bundle-Bd2CeRt-.js');
+var _tslib = require('./bundle-Cy2hoAU0.js');
 var React = require('react');
 var ui_ImageRenderer = require('../ui/ImageRenderer.js');
-var pxToNumber = require('./bundle-BNwlB2IO.js');
+var pxToNumber = require('./bundle-DNNJJIuz.js');
 var ui_Icon = require('../ui/Icon.js');
-var utils = require('./bundle-DWY7_S-1.js');
+var utils = require('./bundle-Dl83958K.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -76,4 +76,4 @@ var Avatar = React__default.default.forwardRef(Avatar$1);
 exports.Avatar = Avatar;
 exports.AvatarDefault = AvatarDefault;
 exports.AvatarInner = AvatarInner;
-//# sourceMappingURL=bundle-xWe8b62h.js.map
+//# sourceMappingURL=bundle-BtEpJHeW.js.map

package/cjs/chunks/bundle-BtEpJHeW.js.map

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

package/cjs/chunks/{bundle-Dmwc7dn-.js → bundle-Bu9kk9V4.js}

@@ -49,4 +49,4 @@ function useThrottleCallback(callback, delay, options) {
 }
 
 exports.useThrottleCallback = useThrottleCallback;
-//# sourceMappingURL=bundle-Dmwc7dn-.js.map
+//# sourceMappingURL=bundle-Bu9kk9V4.js.map

package/cjs/chunks/bundle-Bu9kk9V4.js.map

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

package/cjs/chunks/{bundle-D8e2K1a6.js → bundle-By1D1W1P.js}

@@ -1,17 +1,17 @@
 'use strict';
 
-var _tslib = require('./bundle-Bd2CeRt-.js');
+var _tslib = require('./bundle-Cy2hoAU0.js');
 var React = require('react');
-var useChannelSettings = require('./bundle-D8XWa4V7.js');
-var LocalizationContext = require('./bundle-DC_iv7UY.js');
-var UserListItemMenu = require('./bundle-I0GUkoRI.js');
+var useChannelSettings = require('./bundle-ClrkzepM.js');
+var LocalizationContext = require('./bundle-DJ-JijOD.js');
+var UserListItemMenu = require('./bundle-CN6TJubV.js');
 var ui_Button = require('../ui/Button.js');
 var ui_UserListItem = require('../ui/UserListItem.js');
-var ui_Modal = require('./bundle-BED5_NT-.js');
-var index = require('./bundle-C-Y7haxN.js');
-var ui_Label = require('./bundle-DaHh2cJb.js');
+var ui_Modal = require('./bundle-CLX5eMdj.js');
+var index = require('./bundle-5_FBmAmW.js');
+var ui_Label = require('./bundle-DE8Y9-kK.js');
 var groupChannel = require('@sendbird/chat/groupChannel');
-var utils = require('./bundle-DWY7_S-1.js');
+var utils = require('./bundle-Dl83958K.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -365,4 +365,4 @@ var MutedMemberList = function (_a) {
 exports.BannedUserList = BannedUserList;
 exports.MutedMemberList = MutedMemberList;
 exports.OperatorList = OperatorList;
-//# sourceMappingURL=bundle-D8e2K1a6.js.map
+//# sourceMappingURL=bundle-By1D1W1P.js.map