@sendbird/uikit-react 3.18.4 → 3.19.1

package/chunks/{bundle-DcY3XClN.js → bundle-OP5BxSl-.js}

@@ -1,19 +1,19 @@
-import { _ as __assign } from './bundle-hebhB-lR.js';
+import { a as __awaiter, c as __generator, _ as __assign } from './bundle-CcUR6MGu.js';
 import React__default, { useCallback, useMemo, useContext, useEffect, useRef } from 'react';
 import { MessageMetaArray, SendingStatus } from '@sendbird/chat/message';
-import { s as scrollIntoLast, c as compareIds, g as getNicknamesMapFromMembers, a as getParentMessageFrom } from './bundle-ma_Oj1DB.js';
-import { U as UserProfileProvider } from './bundle-AgXwAoAz.js';
-import { s as shimExports, a as createStore, b as useStore } from './bundle-BJVFYe-E.js';
+import { s as scrollIntoLast, c as compareIds, g as getNicknamesMapFromMembers, a as getParentMessageFrom } from './bundle-ByAnC7NP.js';
+import { U as UserProfileProvider } from './bundle-DFhBiUdl.js';
+import { s as shimExports, a as createStore, b as useStore } from './bundle-DnFVJzke.js';
 import { ChannelType } from '@sendbird/chat';
 import { GroupChannelHandler } from '@sendbird/chat/groupChannel';
-import { u as uuidv4 } from './bundle-lPT-nUNk.js';
-import { c as compareIds$1 } from './bundle-C4-sXsFT.js';
+import { u as uuidv4 } from './bundle-Chyem8qP.js';
+import { c as compareIds$1 } from './bundle-jJN29iP7.js';
 import { useGroupChannelThreadMessages } from '@sendbird/uikit-tools';
 import { ParentMessageStateTypes, ThreadListStateTypes, ChannelStateTypes } from '../Thread/context/types.js';
-import { u as useSendbird } from './bundle-5TPniY9G.js';
-import { u as useDeepCompareEffect } from './bundle-BNP3q1UD.js';
-import { p as pubSubTopics, a as PublishingModuleType } from './bundle-BOLGCL_I.js';
-import { f as META_ARRAY_VOICE_DURATION_KEY, e as META_ARRAY_MESSAGE_TYPE_VALUE__VOICE, d as META_ARRAY_MESSAGE_TYPE_KEY, l as VOICE_MESSAGE_MIME_TYPE, V as VOICE_MESSAGE_FILE_NAME, g as SCROLL_BOTTOM_DELAY_FOR_SEND } from './bundle-wPF3Cnz3.js';
+import { u as useSendbird } from './bundle-C2G7GxX3.js';
+import { u as useDeepCompareEffect } from './bundle-DCnF5PZW.js';
+import { p as pubSubTopics, a as PublishingModuleType } from './bundle-Dc8WJsdV.js';
+import { f as META_ARRAY_VOICE_DURATION_KEY, e as META_ARRAY_MESSAGE_TYPE_VALUE__VOICE, d as META_ARRAY_MESSAGE_TYPE_KEY, l as VOICE_MESSAGE_MIME_TYPE, V as VOICE_MESSAGE_FILE_NAME, g as SCROLL_BOTTOM_DELAY_FOR_SEND } from './bundle-C21v6uBu.js';
 
 function useToggleReactionCallback(_a, _b) {
     var currentChannel = _a.currentChannel;
@@ -39,16 +39,18 @@ function useToggleReactionCallback(_a, _b) {
 var scrollToLastAfterSend = function () {
     setTimeout(function () { return scrollIntoLast(); }, 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 = useCallback(function (props) {
         var _a;
         var message = props.message, quoteMessage = props.quoteMessage, mentionTemplate = props.mentionTemplate, mentionedUsers = props.mentionedUsers;
@@ -86,6 +88,15 @@ function useThreadMessageActions(state, _a) {
     }, [dsSendUserMessage, onBeforeSendUserMessage, currentChannel, isMentionEnabled]);
     var sendFileMessage = 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;
@@ -96,17 +107,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(pubSubTopics.SEND_FILE_MESSAGE, {
                 channel: currentChannel,
                 message: sentMessage,
@@ -114,7 +131,7 @@ function useThreadMessageActions(state, _a) {
             });
             return sentMessage;
         });
-    }, [dsSendFileMessage, onBeforeSendFileMessage, currentChannel]);
+    }, [dsSendFileMessage, onBeforeSendFileMessage, currentChannel, localFilePreviews]);
     var sendVoiceMessage = useCallback(function (file, duration, quoteMessage) {
         var params = (onBeforeSendVoiceMessage && typeof onBeforeSendVoiceMessage === 'function')
             ? onBeforeSendVoiceMessage(file, quoteMessage)
@@ -135,13 +152,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(pubSubTopics.SEND_FILE_MESSAGE, {
                 channel: currentChannel,
                 message: sentMessage,
@@ -151,9 +176,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 = 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 ({
@@ -170,8 +209,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) {
@@ -219,8 +256,25 @@ function useThreadMessageActions(state, _a) {
         if (!dsDeleteMessage)
             return Promise.resolve();
         logger.info('Thread | useThreadMessageActions: Deleting message.', message);
-        return dsDeleteMessage(message);
-    }, [dsDeleteMessage]);
+        return dsDeleteMessage(message)
+            .then(function () {
+            var preview = message.reqId && localFilePreviews.get(message.reqId);
+            if (preview) {
+                URL.revokeObjectURL(preview.localUrl);
+                localFilePreviews.delete(message.reqId);
+            }
+        })
+            .catch(function (error) {
+            if (message.sendingStatus !== SendingStatus.SUCCEEDED && currentChannel) {
+                var preview = message.reqId && localFilePreviews.get(message.reqId);
+                if (preview) {
+                    URL.revokeObjectURL(preview.localUrl);
+                    localFilePreviews.delete(message.reqId);
+                }
+            }
+            throw error;
+        });
+    }, [dsDeleteMessage, localFilePreviews, currentChannel]);
     var resendMessage = useCallback(function (failedMessage) {
         if (!(failedMessage === null || failedMessage === void 0 ? void 0 : failedMessage.isResendable) || !dsResendMessage || !currentChannel) {
             logger.warning('Thread | useThreadMessageActions: Message is not resendable.', failedMessage);
@@ -271,36 +325,117 @@ var useThread = function () {
     var state = shimExports.useSyncExternalStore(store.subscribe, store.getState);
     var currentChannel = state.currentChannel;
     var toggleReaction = useToggleReactionCallback({ currentChannel: currentChannel }, { logger: logger });
-    var initializeThreadFetcher = 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 = useCallback(function (callback) { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, resetWithStartingPoint, anchorMessage, parentMessage, startingPoint, page, error_1;
+        return __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 = 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 = useCallback(function (callback) { return __awaiter(void 0, void 0, void 0, function () {
+        var loadPrevious, page;
+        return __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 = 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 = useCallback(function (callback) { return __awaiter(void 0, void 0, void 0, function () {
+        var loadNext, page;
+        return __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: useCallback(function (currentUserId) { return store.setState(function (state) { return (__assign(__assign({}, state), { currentUserId: currentUserId })); }); }, [store]),
@@ -613,6 +748,7 @@ var initialState = function () { return ({
     currentUserId: '',
     typingMembers: [],
     nicknamesMap: null,
+    localFilePreviews: new Map(),
 }); };
 var ThreadContext = React__default.createContext(null);
 var createThreadStore = function (props) { return createStore(__assign(__assign({}, initialState()), props)); };
@@ -636,7 +772,7 @@ var InternalThreadProvider = function (props) {
 };
 var ThreadManager = function (props) {
     var message = 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 = getParentMessageFrom(message);
     // Context from SendbirdProvider
@@ -732,6 +868,13 @@ var ThreadManager = function (props) {
     var hasMorePrev = threadDataSource.hasPrevious();
     var hasMoreNext = threadDataSource.hasNext();
     var store = useContext(ThreadContext);
+    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;
@@ -742,12 +885,30 @@ var ThreadManager = function (props) {
     })
         .join('~');
     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) {
+            var _a, _b;
+            var sendableMessage = message;
+            var preview = localFilePreviews.get(sendableMessage.reqId);
+            if (!preview)
+                return;
+            if (sendableMessage.sendingStatus === SendingStatus.SUCCEEDED) {
+                URL.revokeObjectURL(preview.localUrl);
+                localFilePreviews.delete(sendableMessage.reqId);
+                return;
+            }
+            var localFileMessage = message;
+            (_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 === SendingStatus.PENDING || sendingStatus === SendingStatus.FAILED;
@@ -809,4 +970,4 @@ var useThreadStore = function () {
 };
 
 export { InternalThreadProvider as I, ThreadContext as T, ThreadManager as a, ThreadProvider as b, useThreadContext as c, useThread as u };
-//# sourceMappingURL=bundle-DcY3XClN.js.map
+//# sourceMappingURL=bundle-OP5BxSl-.js.map

package/chunks/{bundle-DBi1PUnk.js.map → bundle-OP5BxSl-.js.map}

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

package/chunks/{bundle-BjXb7ZAk.js → bundle-R7kuIrhM.js}

@@ -1,10 +1,10 @@
-import { e as __spreadArray, _ as __assign } from './bundle-hebhB-lR.js';
+import { e as __spreadArray, _ as __assign } from './bundle-CcUR6MGu.js';
 import { GroupChannelListOrder } from '@sendbird/chat/groupChannel';
 import { getOutgoingMessageState, OutgoingMessageStates } from '../utils/message/getOutgoingMessageState.js';
-import { a as isSafari } from './bundle-icCbC4nd.js';
-import { K } from './bundle-C_b0cyNh.js';
-import { r as requiredArgs, t as toDate } from './bundle-rx5te-gG.js';
-import { M as MESSAGE_TEMPLATE_KEY } from './bundle-wPF3Cnz3.js';
+import { a as isSafari } from './bundle-BwapOLfM.js';
+import { K } from './bundle-BHSztodR.js';
+import { r as requiredArgs, t as toDate } from './bundle-By-L-4c_.js';
+import { M as MESSAGE_TEMPLATE_KEY } from './bundle-C21v6uBu.js';
 
 /**
  * @name startOfSecond
@@ -849,4 +849,4 @@ var isDefaultChannelName = function (channel) {
 };
 
 export { isVideoMessage as $, isFailedMessage as A, isFileAllowedByAccept as B, isFileMessage as C, isFormMessage as D, isGif as E, isGifMessage as F, isImage as G, isImageFileInfo as H, isImageMessage as I, isMultipleFilesMessage as J, isOGMessage as K, isPendingMessage as L, isReactedBy as M, isReadMessage as N, isSendableMessage as O, isSentMessage as P, isSentStatus as Q, isSupportedFileView as R, StringObjType as S, isTemplateMessage as T, UIKitMessageTypes as U, isTextMessage as V, isThreadMessage as W, isThumbnailMessage as X, isUserMessage as Y, isValidTemplateMessageType as Z, isVideo as _, arrayEqual as a, isVoiceMessage as a0, isVoiceMessageMimeType as a1, truncateString as a2, uiContainerType as a3, copyToClipboard as b, convertWordToStringObj as c, filterMessageListParams as d, getClassName as e, filterChannelListParams as f, getChannelsWithUpsertedChannel as g, getEmojiListAll as h, getEmojiListByCategoryIds as i, getEmojiMapAll as j, getEmojiTooltipString as k, getEmojiUrl as l, getHTMLTextDirection as m, getMimeTypesUIKitAccepts as n, getSenderName as o, getSuggestedReplies as p, getUIKitFileType as q, getUIKitFileTypes as r, getUIKitMessageType as s, getUIKitMessageTypes as t, isAdminMessage as u, isAudio as v, isAudioMessage as w, isChannelJustCreated as x, isDefaultChannelName as y, isEditedMessage as z };
-//# sourceMappingURL=bundle-BjXb7ZAk.js.map
+//# sourceMappingURL=bundle-R7kuIrhM.js.map

package/chunks/{bundle-BjXb7ZAk.js.map → bundle-R7kuIrhM.js.map}

@@ -1 +1 @@
-{"version":3,"file":"bundle-BjXb7ZAk.js","sources":["../../node_modules/date-fns/esm/startOfSecond/index.js","../../node_modules/date-fns/esm/isSameSecond/index.js"],"sourcesContent":["import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name startOfSecond\n * @category Second Helpers\n * @summary Return the start of a second for the given date.\n *\n * @description\n * Return the start of a second for the given date.\n * The result will be in the local timezone.\n *\n * @param {Date|Number} date - the original date\n * @returns {Date} the start of a second\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // The start of a second for 1 December 2014 22:15:45.400:\n * const result = startOfSecond(new Date(2014, 11, 1, 22, 15, 45, 400))\n * //=> Mon Dec 01 2014 22:15:45.000\n */\nexport default function startOfSecond(dirtyDate) {\n  requiredArgs(1, arguments);\n  var date = toDate(dirtyDate);\n  date.setMilliseconds(0);\n  return date;\n}","import startOfSecond from \"../startOfSecond/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isSameSecond\n * @category Second Helpers\n * @summary Are the given dates in the same second (and hour and day)?\n *\n * @description\n * Are the given dates in the same second (and hour and day)?\n *\n * @param {Date|Number} dateLeft - the first date to check\n * @param {Date|Number} dateRight - the second date to check\n * @returns {Boolean} the dates are in the same second (and hour and day)\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Are 4 September 2014 06:30:15.000 and 4 September 2014 06:30.15.500 in the same second?\n * const result = isSameSecond(\n *   new Date(2014, 8, 4, 6, 30, 15),\n *   new Date(2014, 8, 4, 6, 30, 15, 500)\n * )\n * //=> true\n *\n * @example\n * // Are 4 September 2014 06:00:15.000 and 4 September 2014 06:01.15.000 in the same second?\n * const result = isSameSecond(\n *   new Date(2014, 8, 4, 6, 0, 15),\n *   new Date(2014, 8, 4, 6, 1, 15)\n * )\n * //=> false\n *\n * @example\n * // Are 4 September 2014 06:00:15.000 and 5 September 2014 06:00.15.000 in the same second?\n * const result = isSameSecond(\n *   new Date(2014, 8, 4, 6, 0, 15),\n *   new Date(2014, 8, 5, 6, 0, 15)\n * )\n * //=> false\n */\nexport default function isSameSecond(dirtyDateLeft, dirtyDateRight) {\n  requiredArgs(2, arguments);\n  var dateLeftStartOfSecond = startOfSecond(dirtyDateLeft);\n  var dateRightStartOfSecond = startOfSecond(dirtyDateRight);\n  return dateLeftStartOfSecond.getTime() === dateRightStartOfSecond.getTime();\n}"],"names":[],"mappings":";;;;;;;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAAS,aAAa,CAAC,SAAS,EAAE;AACjD,EAAE,YAAY,CAAC,CAAC,EAAE,SAAS,CAAC;AAC5B,EAAE,IAAI,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC;AAC9B,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC;AACzB,EAAE,OAAO,IAAI;AACb;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAAS,YAAY,CAAC,aAAa,EAAE,cAAc,EAAE;AACpE,EAAE,YAAY,CAAC,CAAC,EAAE,SAAS,CAAC;AAC5B,EAAE,IAAI,qBAAqB,GAAG,aAAa,CAAC,aAAa,CAAC;AAC1D,EAAE,IAAI,sBAAsB,GAAG,aAAa,CAAC,cAAc,CAAC;AAC5D,EAAE,OAAO,qBAAqB,CAAC,OAAO,EAAE,KAAK,sBAAsB,CAAC,OAAO,EAAE;AAC7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","x_google_ignoreList":[0,1]}
+{"version":3,"file":"bundle-R7kuIrhM.js","sources":["../../node_modules/date-fns/esm/startOfSecond/index.js","../../node_modules/date-fns/esm/isSameSecond/index.js"],"sourcesContent":["import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name startOfSecond\n * @category Second Helpers\n * @summary Return the start of a second for the given date.\n *\n * @description\n * Return the start of a second for the given date.\n * The result will be in the local timezone.\n *\n * @param {Date|Number} date - the original date\n * @returns {Date} the start of a second\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // The start of a second for 1 December 2014 22:15:45.400:\n * const result = startOfSecond(new Date(2014, 11, 1, 22, 15, 45, 400))\n * //=> Mon Dec 01 2014 22:15:45.000\n */\nexport default function startOfSecond(dirtyDate) {\n  requiredArgs(1, arguments);\n  var date = toDate(dirtyDate);\n  date.setMilliseconds(0);\n  return date;\n}","import startOfSecond from \"../startOfSecond/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isSameSecond\n * @category Second Helpers\n * @summary Are the given dates in the same second (and hour and day)?\n *\n * @description\n * Are the given dates in the same second (and hour and day)?\n *\n * @param {Date|Number} dateLeft - the first date to check\n * @param {Date|Number} dateRight - the second date to check\n * @returns {Boolean} the dates are in the same second (and hour and day)\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Are 4 September 2014 06:30:15.000 and 4 September 2014 06:30.15.500 in the same second?\n * const result = isSameSecond(\n *   new Date(2014, 8, 4, 6, 30, 15),\n *   new Date(2014, 8, 4, 6, 30, 15, 500)\n * )\n * //=> true\n *\n * @example\n * // Are 4 September 2014 06:00:15.000 and 4 September 2014 06:01.15.000 in the same second?\n * const result = isSameSecond(\n *   new Date(2014, 8, 4, 6, 0, 15),\n *   new Date(2014, 8, 4, 6, 1, 15)\n * )\n * //=> false\n *\n * @example\n * // Are 4 September 2014 06:00:15.000 and 5 September 2014 06:00.15.000 in the same second?\n * const result = isSameSecond(\n *   new Date(2014, 8, 4, 6, 0, 15),\n *   new Date(2014, 8, 5, 6, 0, 15)\n * )\n * //=> false\n */\nexport default function isSameSecond(dirtyDateLeft, dirtyDateRight) {\n  requiredArgs(2, arguments);\n  var dateLeftStartOfSecond = startOfSecond(dirtyDateLeft);\n  var dateRightStartOfSecond = startOfSecond(dirtyDateRight);\n  return dateLeftStartOfSecond.getTime() === dateRightStartOfSecond.getTime();\n}"],"names":[],"mappings":";;;;;;;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAAS,aAAa,CAAC,SAAS,EAAE;AACjD,EAAE,YAAY,CAAC,CAAC,EAAE,SAAS,CAAC;AAC5B,EAAE,IAAI,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC;AAC9B,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC;AACzB,EAAE,OAAO,IAAI;AACb;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAAS,YAAY,CAAC,aAAa,EAAE,cAAc,EAAE;AACpE,EAAE,YAAY,CAAC,CAAC,EAAE,SAAS,CAAC;AAC5B,EAAE,IAAI,qBAAqB,GAAG,aAAa,CAAC,aAAa,CAAC;AAC1D,EAAE,IAAI,sBAAsB,GAAG,aAAa,CAAC,cAAc,CAAC;AAC5D,EAAE,OAAO,qBAAqB,CAAC,OAAO,EAAE,KAAK,sBAAsB,CAAC,OAAO,EAAE;AAC7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","x_google_ignoreList":[0,1]}

package/chunks/{bundle-CMnb1T14.js → bundle-TCcZsrMs.js}

@@ -1,11 +1,11 @@
-import { _ as __assign } from './bundle-hebhB-lR.js';
+import { _ as __assign } from './bundle-CcUR6MGu.js';
 import React__default from 'react';
 import { TypingIndicator } from '../GroupChannel/components/TypingIndicator.js';
-import { T as TypingIndicatorType } from './bundle-FjVDOMz7.js';
+import { T as TypingIndicatorType } from './bundle-Bus5HUZ7.js';
 import ConnectionStatus from '../ui/ConnectionStatus.js';
 import PlaceHolder, { PlaceHolderTypes } from '../ui/PlaceHolder.js';
-import { d as deleteNullish } from './bundle-DfatitzT.js';
-import { u as useSendbird } from './bundle-5TPniY9G.js';
+import { d as deleteNullish } from './bundle-BMGCcH4H.js';
+import { u as useSendbird } from './bundle-C2G7GxX3.js';
 
 var GroupChannelUIView = function (props) {
     var _a, _b, _c, _d;
@@ -44,4 +44,4 @@ var GroupChannelUIView = function (props) {
 };
 
 export { GroupChannelUIView as G };
-//# sourceMappingURL=bundle-CMnb1T14.js.map
+//# sourceMappingURL=bundle-TCcZsrMs.js.map

package/chunks/bundle-TCcZsrMs.js.map

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

package/chunks/{bundle-DrDNf2-f.js → bundle-Wz22RLmo.js}

@@ -29,4 +29,4 @@ var generateDefaultAvatar = function (channel) {
 };
 
 export { getChannelAvatarSource as a, getOpenChannelAvatar as b, generateDefaultAvatar as g };
-//# sourceMappingURL=bundle-DrDNf2-f.js.map
+//# sourceMappingURL=bundle-Wz22RLmo.js.map

package/chunks/bundle-Wz22RLmo.js.map

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

package/chunks/{bundle-CxJZxS1L.js → bundle-Z6yhUn_z.js}

@@ -1,21 +1,21 @@
-import { _ as __assign } from './bundle-hebhB-lR.js';
+import { _ as __assign } from './bundle-CcUR6MGu.js';
 import React__default, { useState } from 'react';
-import { u as useLongPress } from './bundle-CtfGvA3s.js';
-import { u as useLocalization } from './bundle-DmCR-5mz.js';
-import { u as useMediaQueryContext } from './bundle-BEJzu87W.js';
-import { n as noop } from './bundle-DfatitzT.js';
-import { a0 as isVoiceMessage } from './bundle-BjXb7ZAk.js';
-import { d as getLastMessageText, e as getTotalMembers, M as MessageStatus, c as getLastMessageCreatedAt, b as getChannelUnreadMessageCount } from './bundle-XrVJXU3U.js';
+import { u as useLongPress } from './bundle-BhVaZO7O.js';
+import { u as useLocalization } from './bundle-C9w2yVgG.js';
+import { u as useMediaQueryContext } from './bundle-CjWTH39Z.js';
+import { n as noop } from './bundle-BMGCcH4H.js';
+import { a0 as isVoiceMessage } from './bundle-R7kuIrhM.js';
+import { d as getLastMessageText, e as getTotalMembers, M as MessageStatus, c as getLastMessageCreatedAt, b as getChannelUnreadMessageCount } from './bundle-CslBpASe.js';
 import { TypingIndicatorText } from '../GroupChannel/components/TypingIndicator.js';
 import Badge from '../ui/Badge.js';
 import ChannelAvatar from '../ui/ChannelAvatar.js';
 import Icon, { IconColors, IconTypes } from '../ui/Icon.js';
-import { L as Label, a as LabelColors, c as LabelTypography } from './bundle-BfSYns3Q.js';
+import { L as Label, a as LabelColors, c as LabelTypography } from './bundle-6_GgtuoW.js';
 import MentionUserLabel from '../ui/MentionUserLabel.js';
-import { a as Modal } from './bundle-BlaB8_Vx.js';
+import { a as Modal } from './bundle-4E_l67ie.js';
 import TextButton from '../ui/TextButton.js';
-import { g as getChannelPreviewMessage } from './bundle-CbAyaMyR.js';
-import { u as useSendbird } from './bundle-5TPniY9G.js';
+import { g as getChannelPreviewMessage } from './bundle-Bj08_wYM.js';
+import { u as useSendbird } from './bundle-C2G7GxX3.js';
 
 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 ? function () { return Promise.resolve(); } : _d, renderChannelAction = _a.renderChannelAction;
@@ -90,4 +90,4 @@ var GroupChannelListItemView = function (_a) {
 };
 
 export { GroupChannelListItemView as G };
-//# sourceMappingURL=bundle-CxJZxS1L.js.map
+//# sourceMappingURL=bundle-Z6yhUn_z.js.map

package/chunks/{bundle-CxJZxS1L.js.map → bundle-Z6yhUn_z.js.map}

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

package/chunks/{bundle-BJ5VbsR3.js → bundle-dBwGruJn.js}

@@ -47,4 +47,4 @@ function useThrottleCallback(callback, delay, options) {
 }
 
 export { useThrottleCallback as u };
-//# sourceMappingURL=bundle-BJ5VbsR3.js.map
+//# sourceMappingURL=bundle-dBwGruJn.js.map

package/chunks/bundle-dBwGruJn.js.map

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

package/chunks/{bundle-CxYa-MOA.js → bundle-eYuQkSx8.js}

@@ -9,4 +9,4 @@ var ThreadReplySelectType;
 })(ThreadReplySelectType || (ThreadReplySelectType = {}));
 
 export { MAX_USER_MENTION_COUNT as M, ThreadReplySelectType as T, UIKIT_COMPATIBLE_FORM_VERSION as U, MAX_USER_SUGGESTION_COUNT as a, USER_MENTION_TEMP_CHAR as b };
-//# sourceMappingURL=bundle-CxYa-MOA.js.map
+//# sourceMappingURL=bundle-eYuQkSx8.js.map

package/chunks/bundle-eYuQkSx8.js.map

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

package/chunks/{bundle-BKG92dEV.js → bundle-ezgSy5Zs.js}

@@ -26,4 +26,4 @@ function getCaseResolvedThreadReplySelectType(threadReplySelectType) {
 }
 
 export { getCaseResolvedThreadReplySelectType as a, getCaseResolvedReplyType as g };
-//# sourceMappingURL=bundle-BKG92dEV.js.map
+//# sourceMappingURL=bundle-ezgSy5Zs.js.map

package/chunks/{bundle-BKG92dEV.js.map → bundle-ezgSy5Zs.js.map}

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

package/chunks/{bundle-Dm1aJDNG.js → bundle-gQLFy1cA.js}

@@ -13,4 +13,4 @@ function getIsReactionEnabled(_a) {
 }
 
 export { getIsReactionEnabled as g };
-//# sourceMappingURL=bundle-Dm1aJDNG.js.map
+//# sourceMappingURL=bundle-gQLFy1cA.js.map

package/chunks/bundle-gQLFy1cA.js.map

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

package/chunks/{bundle-BMDCtK3D.js → bundle-gcmwrAcS.js}

@@ -1,10 +1,10 @@
 import React__default, { useContext } from 'react';
-import { a as Modal } from './bundle-BlaB8_Vx.js';
-import './bundle-hebhB-lR.js';
-import './bundle-BfSYns3Q.js';
+import { a as Modal } from './bundle-4E_l67ie.js';
+import './bundle-CcUR6MGu.js';
+import './bundle-6_GgtuoW.js';
 import { ButtonTypes } from '../ui/Button.js';
-import { L as LocalizationContext } from './bundle-DmCR-5mz.js';
-import { g as getModalDeleteMessageTitle } from './bundle-C-R7XPOv.js';
+import { L as LocalizationContext } from './bundle-C9w2yVgG.js';
+import { g as getModalDeleteMessageTitle } from './bundle-CUQlrQ1E.js';
 
 var RemoveMessageModalView = function (props) {
     var _a;
@@ -25,4 +25,4 @@ var RemoveMessageModalView = function (props) {
 };
 
 export { RemoveMessageModalView as R };
-//# sourceMappingURL=bundle-BMDCtK3D.js.map
+//# sourceMappingURL=bundle-gcmwrAcS.js.map

package/chunks/bundle-gcmwrAcS.js.map

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

package/chunks/{bundle-C4-sXsFT.js → bundle-jJN29iP7.js}

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

package/chunks/bundle-jJN29iP7.js.map

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