@sendbird/uikit-react 3.17.12 → 3.18.1

package/chunks/{bundle-LuCErKTs.js → bundle-B9O57ngP.js}

@@ -1,25 +1,26 @@
-import { a as __awaiter, b as __generator, c as __spreadArray } from './bundle-Rf2YUo_V.js';
+import { a as __awaiter, c as __generator, e as __spreadArray } from './bundle-ybWGQIGZ.js';
 import React__default, { useRef, useState, useEffect, useCallback } from 'react';
-import { i as isDisabledBecauseFrozen, a as isDisabledBecauseMuted, b as isDisabledBecauseSuggestedReplies, c as isDisabledBecauseMessageForm } from './bundle-BGZ1wO7_.js';
-import { u as useLocalization } from './bundle-D-RwYEMS.js';
+import { u as useTypingLifecycle } from './bundle-BmPBPfxJ.js';
+import { b as isDisabledBecauseFrozen, d as isDisabledBecauseMuted, e as isDisabledBecauseSuggestedReplies, c as isDisabledBecauseMessageForm } from './bundle--W1OIcEL.js';
+import { u as useLocalization } from './bundle-BRfCkqhH.js';
+import { useGlobalModalContext } from '../hooks/useModal.js';
 import { SuggestedMentionList } from '../GroupChannel/components/SuggestedMentionList.js';
 import { useDirtyGetMentions } from '../Message/hooks/useDirtyGetMentions.js';
 import QuoteMessageInput from '../ui/QuoteMessageInput.js';
 import { useVoicePlayer } from '../VoicePlayer/useVoicePlayer.js';
 import { useVoiceRecorder, VoiceRecorderStatus } from '../VoiceRecorder/useVoiceRecorder.js';
-import { V as VoiceMessageInputStatus, a as VoiceMessageInput } from './bundle-B7jxtQGu.js';
-import { M as Modal, c as ModalFooter } from './bundle-7U4PQody.js';
-import Button, { ButtonTypes, ButtonSizes } from '../ui/Button.js';
-import { V as VOICE_PLAYER_STATUS } from './bundle-CqBJPXqm.js';
-import { u as uuidv4 } from './bundle-B9eInLCQ.js';
-import { u as useSendbird } from './bundle-N4pYliV4.js';
-import MessageInput from '../ui/MessageInput.js';
-import { u as useMediaQueryContext } from './bundle-CA3QA8D9.js';
-import { M as MessageInputKeys } from './bundle-5uYh-Xyr.js';
-import { l as isImage } from './bundle-DGClPDDG.js';
-import { useGlobalModalContext } from '../hooks/useModal.js';
-import './bundle-C0kbt3jK.js';
-import { c as compressImages } from './bundle-CRL04AgG.js';
+import { a as VoiceMessageInputStatus, V as VoiceMessageInput } from './bundle-BnCmgARn.js';
+import { a as Modal } from './bundle-CPv8kS7Z.js';
+import Button, { ButtonSizes, ButtonTypes } from '../ui/Button.js';
+import { V as VOICE_PLAYER_STATUS } from './bundle-DJSKRkgz.js';
+import { u as uuidv4 } from './bundle-DnjdXo2G.js';
+import { u as useSendbird } from './bundle-CsMoZtyW.js';
+import { c as checkIfFileUploadEnabled, M as MessageInput } from './bundle-Bt_opDHG.js';
+import { a as usePendingFiles, u as useDragAndDrop } from './bundle-vBSUAWgP.js';
+import { i as isChannelTypeSupportsMultipleFilesMessage } from './bundle-DHlxTlun.js';
+import { u as useMediaQueryContext } from './bundle-BRgACRFj.js';
+import { M as MessageInputKeys } from './bundle-COe8BPAs.js';
+import { c as compressImages } from './bundle-Bx2EAp0W.js';
 
 var VoiceMessageInputWrapper = function (_a) {
     var channel = _a.channel, onCancelClick = _a.onCancelClick, onSubmitClick = _a.onSubmitClick;
@@ -139,112 +140,6 @@ var VoiceMessageInputWrapper = function (_a) {
                     } }, stringSet.BUTTON__OK))))));
 };
 
-var useHandleUploadFiles = function (_a, _b) {
-    var sendFileMessage = _a.sendFileMessage, sendMultipleFilesMessage = _a.sendMultipleFilesMessage, quoteMessage = _a.quoteMessage;
-    var logger = _b.logger;
-    var stringSet = useLocalization().stringSet;
-    var state = useSendbird().state;
-    var config = state.config;
-    var imageCompression = config.imageCompression;
-    var uikitUploadSizeLimit = config === null || config === void 0 ? void 0 : config.uikitUploadSizeLimit;
-    var uikitMultipleFilesMessageLimit = config === null || config === void 0 ? void 0 : config.uikitMultipleFilesMessageLimit;
-    var openModal = useGlobalModalContext().openModal;
-    return useCallback(function (files) { return __awaiter(void 0, void 0, void 0, function () {
-        var ONE_MiB, compressedFiles, sendingFiles, file, imageFiles_1, otherFiles_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (files.length === 0) {
-                        logger.warning('Channel|useHandleUploadFiles: given file list is empty.', { files: files });
-                        return [2 /*return*/];
-                    }
-                    if (files.length > uikitMultipleFilesMessageLimit) {
-                        logger.info("Channel|useHandleUploadFiles: Cannot upload files more than ".concat(uikitMultipleFilesMessageLimit));
-                        openModal({
-                            modalProps: {
-                                titleText: stringSet.FILE_UPLOAD_NOTIFICATION__COUNT_LIMIT.replace('%d', "".concat(uikitUploadSizeLimit)),
-                                hideFooter: true,
-                            },
-                            childElement: function (_a) {
-                                var closeModal = _a.closeModal;
-                                return (React__default.createElement(ModalFooter, { type: ButtonTypes.PRIMARY, submitText: stringSet.BUTTON__OK, hideCancelButton: true, onCancel: closeModal, onSubmit: closeModal }));
-                            },
-                        });
-                        return [2 /*return*/];
-                    }
-                    // Validate file sizes
-                    if (files.some(function (file) { return file.size > uikitUploadSizeLimit; })) {
-                        // The default value of uikitUploadSizeLimit is 26MB
-                        logger.info("Channel|useHandleUploadFiles: Cannot upload file size exceeding ".concat(uikitUploadSizeLimit));
-                        ONE_MiB = 1024 * 1024;
-                        openModal({
-                            modalProps: {
-                                titleText: stringSet.FILE_UPLOAD_NOTIFICATION__SIZE_LIMIT.replace('%d', "".concat(Math.floor(uikitUploadSizeLimit / ONE_MiB))),
-                                hideFooter: true,
-                            },
-                            childElement: function (_a) {
-                                var closeModal = _a.closeModal;
-                                return (React__default.createElement(ModalFooter, { type: ButtonTypes.PRIMARY, submitText: stringSet.BUTTON__OK, hideCancelButton: true, onCancel: closeModal, onSubmit: closeModal }));
-                            },
-                        });
-                        return [2 /*return*/];
-                    }
-                    return [4 /*yield*/, compressImages({
-                            files: files,
-                            imageCompression: imageCompression,
-                            logger: logger,
-                        })];
-                case 1:
-                    compressedFiles = (_a.sent()).compressedFiles;
-                    sendingFiles = compressedFiles;
-                    // Send File Message
-                    if (sendingFiles.length === 1) {
-                        logger.info('Channel|useHandleUploadFiles: sending one file.');
-                        file = sendingFiles[0];
-                        return [2 /*return*/, sendFileMessage({ file: file, parentMessageId: quoteMessage === null || quoteMessage === void 0 ? void 0 : quoteMessage.messageId })];
-                    }
-                    else if (sendingFiles.length > 1) {
-                        logger.info('Channel|useHandleUploadFiles: sending multiple files.');
-                        imageFiles_1 = [];
-                        otherFiles_1 = [];
-                        sendingFiles.forEach(function (file) {
-                            if (isImage(file.type)) {
-                                imageFiles_1.push(file);
-                            }
-                            else {
-                                otherFiles_1.push(file);
-                            }
-                        });
-                        return [2 /*return*/, otherFiles_1.reduce(function (previousPromise, item) {
-                                return previousPromise.then(function () {
-                                    return sendFileMessage({ file: item, parentMessageId: quoteMessage === null || quoteMessage === void 0 ? void 0 : quoteMessage.messageId });
-                                });
-                            }, (function () {
-                                if (imageFiles_1.length === 0) {
-                                    return Promise.resolve();
-                                }
-                                else if (imageFiles_1.length === 1) {
-                                    return sendFileMessage({ file: imageFiles_1[0] });
-                                }
-                                else {
-                                    return sendMultipleFilesMessage({
-                                        fileInfoList: imageFiles_1.map(function (file) { return ({
-                                            file: file,
-                                            fileName: file.name,
-                                            fileSize: file.size,
-                                            mimeType: file.type,
-                                        }); }),
-                                        parentMessageId: quoteMessage === null || quoteMessage === void 0 ? void 0 : quoteMessage.messageId,
-                                    });
-                                }
-                            })())];
-                    }
-                    return [2 /*return*/];
-            }
-        });
-    }); }, [sendFileMessage, sendMultipleFilesMessage, quoteMessage]);
-};
-
 var MessageInputWrapperView = React__default.forwardRef(function (props, ref) {
     var _a;
     // Props
@@ -253,11 +148,13 @@ var MessageInputWrapperView = React__default.forwardRef(function (props, ref) {
     renderUserMentionItem = props.renderUserMentionItem, renderFileUploadIcon = props.renderFileUploadIcon, renderVoiceMessageIcon = props.renderVoiceMessageIcon, renderSendMessageIcon = props.renderSendMessageIcon, acceptableMimeTypes = props.acceptableMimeTypes, disabled = props.disabled;
     var stringSet = useLocalization().stringSet;
     var isMobile = useMediaQueryContext().isMobile;
+    var openModal = useGlobalModalContext().openModal;
     var state = useSendbird().state;
     var stores = state.stores, config = state.config;
-    var isOnline = config.isOnline, userMention = config.userMention, logger = config.logger, groupChannel = config.groupChannel;
+    var isOnline = config.isOnline, userMention = config.userMention, logger = config.logger, groupChannel = config.groupChannel, imageCompression = config.imageCompression;
     var sdk = stores.sdkStore.sdk;
     var maxMentionCount = userMention.maxMentionCount, maxSuggestionCount = userMention.maxSuggestionCount;
+    var uikitUploadSizeLimit = config.uikitUploadSizeLimit, uikitMultipleFilesMessageLimit = config.uikitMultipleFilesMessageLimit;
     var isBroadcast = currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.isBroadcast;
     var isOperator = (currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.myRole) === 'operator';
     var isMultipleFilesMessageEnabled = (_a = props.isMultipleFilesMessageEnabled) !== null && _a !== void 0 ? _a : config.isMultipleFilesMessageEnabled;
@@ -286,6 +183,62 @@ var MessageInputWrapperView = React__default.forwardRef(function (props, ref) {
         && !isBroadcast;
     var mentionNodes = useDirtyGetMentions({ ref: (ref || messageInputRef) }, { logger: logger });
     var ableMention = (mentionNodes === null || mentionNodes === void 0 ? void 0 : mentionNodes.length) < maxMentionCount;
+    // Composer staging — file picker, drag-drop, and clipboard paste all feed
+    // into pendingFiles. The submit handler drains them along with any text body.
+    var allowMultipleFiles = Boolean(isMultipleFilesMessageEnabled)
+        && Boolean(currentChannel)
+        && isChannelTypeSupportsMultipleFilesMessage(currentChannel);
+    var effectiveMultiLimit = allowMultipleFiles ? uikitMultipleFilesMessageLimit : 1;
+    var _j = usePendingFiles({
+        uikitUploadSizeLimit: uikitUploadSizeLimit,
+        uikitMultipleFilesMessageLimit: effectiveMultiLimit,
+        acceptableMimeTypes: acceptableMimeTypes,
+        openModal: openModal,
+        stringSet: stringSet,
+        logger: logger,
+    }), pendingFiles = _j.pendingFiles, addFiles = _j.addFiles, removeFile = _j.removeFile, clearPendingFiles = _j.clear;
+    // Window-level drop target — files dropped anywhere in the viewport route
+    // into this channel's composer EXCEPT when the drop lands inside an open
+    // thread panel, which has its own composer. Disabled on mobile and when
+    // the input itself is not accepting new files (voice recording, channel
+    // disabled).
+    var isFileUploadEnabled = checkIfFileUploadEnabled({ channel: currentChannel !== null && currentChannel !== void 0 ? currentChannel : undefined, config: config });
+    useDragAndDrop({
+        onAddFiles: addFiles,
+        disabled: isMobile || isMessageInputDisabled || showVoiceMessageInput || !isFileUploadEnabled,
+        shouldAccept: function (event) {
+            var target = event.target;
+            if (!(target instanceof Element))
+                return true;
+            return !target.closest('.sendbird-thread-ui');
+        },
+    });
+    var stashedMentionedUsersRef = useRef(null);
+    var stashedQuoteMessageRef = useRef(null);
+    var prevHasPendingFilesRef = useRef(false);
+    var hasPendingFilesInWrapper = pendingFiles.length > 0;
+    useEffect(function () {
+        if (hasPendingFilesInWrapper && !prevHasPendingFilesRef.current) {
+            if (mentionedUsers.length > 0) {
+                stashedMentionedUsersRef.current = mentionedUsers;
+            }
+            if (quoteMessage) {
+                stashedQuoteMessageRef.current = quoteMessage;
+            }
+            setMentionNickname('');
+        }
+        else if (!hasPendingFilesInWrapper && prevHasPendingFilesRef.current) {
+            if (stashedMentionedUsersRef.current) {
+                setMentionedUsers(stashedMentionedUsersRef.current);
+                stashedMentionedUsersRef.current = null;
+            }
+            if (stashedQuoteMessageRef.current) {
+                setQuoteMessage(stashedQuoteMessageRef.current);
+                stashedQuoteMessageRef.current = null;
+            }
+        }
+        prevHasPendingFilesRef.current = hasPendingFilesInWrapper;
+    }, [hasPendingFilesInWrapper]);
     // Operate states
     useEffect(function () {
         setMentionNickname('');
@@ -295,7 +248,11 @@ var MessageInputWrapperView = React__default.forwardRef(function (props, ref) {
         setMentionSuggestedUsers([]);
         setMessageInputEvent(null);
         setShowVoiceMessageInput(false);
+        clearPendingFiles();
+        stashedMentionedUsersRef.current = null;
+        stashedQuoteMessageRef.current = null;
     }, [currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.url]);
+    var _k = useTypingLifecycle(currentChannel), startTyping = _k.startTyping, stopTyping = _k.stopTyping;
     useEffect(function () {
         setMentionedUsers(mentionedUsers.filter(function (_a) {
             var userId = _a.userId;
@@ -309,12 +266,145 @@ var MessageInputWrapperView = React__default.forwardRef(function (props, ref) {
             }
         }));
     }, [mentionedUserIds]);
-    // Callbacks
-    var handleUploadFiles = useHandleUploadFiles({
-        sendFileMessage: sendFileMessage,
-        sendMultipleFilesMessage: sendMultipleFilesMessage,
-        quoteMessage: quoteMessage !== null && quoteMessage !== void 0 ? quoteMessage : undefined,
-    }, { logger: logger });
+    var isSubmittingFilesRef = useRef(false);
+    // Submit handler: drains pendingFiles XOR text body. Files and body do not
+    // coexist in a single send anymore — when files are present, text from the
+    // composer is suppressed at the UI level (textarea locked) and again here
+    // for defense in depth. The caption read path remains in MessageBody to
+    // render historical file messages that still carry a body.
+    var handleSubmit = useCallback(function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+        var trimmed, parentMessageId, rawImageFiles, otherFiles, compressedImageFiles_1, tasks_1, useMFMBatch, file_1;
+        var message = _b.message, mentionTemplate = _b.mentionTemplate, files = _b.files;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    trimmed = message.trim();
+                    parentMessageId = quoteMessage === null || quoteMessage === void 0 ? void 0 : quoteMessage.messageId;
+                    if (files.length === 0) {
+                        if (trimmed.length === 0)
+                            return [2 /*return*/];
+                        sendUserMessage({
+                            message: message,
+                            mentionedUsers: mentionedUsers,
+                            mentionedMessageTemplate: mentionTemplate,
+                            parentMessageId: parentMessageId,
+                        });
+                        setMentionNickname('');
+                        setMentionedUsers([]);
+                        setQuoteMessage(null);
+                        stopTyping();
+                        return [2 /*return*/];
+                    }
+                    if (isSubmittingFilesRef.current)
+                        return [2 /*return*/];
+                    isSubmittingFilesRef.current = true;
+                    // Clear pending state and other composer state immediately so a rapid
+                    // second send (within the compression window) finds an empty queue and
+                    // bails out at MessageInput's sendMessage gate.
+                    setMentionNickname('');
+                    setMentionedUsers([]);
+                    setQuoteMessage(null);
+                    stashedQuoteMessageRef.current = null;
+                    stopTyping();
+                    clearPendingFiles();
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, , 3, 4]);
+                    rawImageFiles = files.filter(function (entry) { return entry.isImage; }).map(function (entry) { return entry.file; });
+                    otherFiles = files.filter(function (entry) { return !entry.isImage; }).map(function (entry) { return entry.file; });
+                    return [4 /*yield*/, compressImages({
+                            files: rawImageFiles,
+                            imageCompression: imageCompression,
+                            logger: logger,
+                        })];
+                case 2:
+                    compressedImageFiles_1 = (_c.sent()).compressedFiles;
+                    tasks_1 = [];
+                    useMFMBatch = isMultipleFilesMessageEnabled && compressedImageFiles_1.length > 1;
+                    if (useMFMBatch) {
+                        tasks_1.push(function () { return sendMultipleFilesMessage({
+                            fileInfoList: compressedImageFiles_1.map(function (file) { return ({
+                                file: file,
+                                fileName: file.name,
+                                fileSize: file.size,
+                                mimeType: file.type,
+                            }); }),
+                            parentMessageId: parentMessageId,
+                        }); });
+                    }
+                    else if (compressedImageFiles_1.length === 1) {
+                        file_1 = compressedImageFiles_1[0];
+                        tasks_1.push(function () { return sendFileMessage({
+                            file: file_1,
+                            parentMessageId: parentMessageId,
+                        }); });
+                    }
+                    else if (compressedImageFiles_1.length > 1) {
+                        compressedImageFiles_1.forEach(function (file) {
+                            tasks_1.push(function () { return sendFileMessage({
+                                file: file,
+                                parentMessageId: parentMessageId,
+                            }); });
+                        });
+                    }
+                    otherFiles.forEach(function (file) {
+                        tasks_1.push(function () { return sendFileMessage({
+                            file: file,
+                            parentMessageId: parentMessageId,
+                        }); });
+                    });
+                    // Sequential dispatch with per-task error isolation: one failure must not
+                    // break the rest of the batch. Fire-and-forget so UI cleanup runs now.
+                    (function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var _i, tasks_2, task, error_1;
+                        var _a;
+                        return __generator(this, function (_b) {
+                            switch (_b.label) {
+                                case 0:
+                                    _i = 0, tasks_2 = tasks_1;
+                                    _b.label = 1;
+                                case 1:
+                                    if (!(_i < tasks_2.length)) return [3 /*break*/, 6];
+                                    task = tasks_2[_i];
+                                    _b.label = 2;
+                                case 2:
+                                    _b.trys.push([2, 4, , 5]);
+                                    return [4 /*yield*/, task()];
+                                case 3:
+                                    _b.sent();
+                                    return [3 /*break*/, 5];
+                                case 4:
+                                    error_1 = _b.sent();
+                                    (_a = logger.warning) === null || _a === void 0 ? void 0 : _a.call(logger, 'GroupChannel|composer: file send failed', error_1);
+                                    return [3 /*break*/, 5];
+                                case 5:
+                                    _i++;
+                                    return [3 /*break*/, 1];
+                                case 6: return [2 /*return*/];
+                            }
+                        });
+                    }); })();
+                    return [3 /*break*/, 4];
+                case 3:
+                    isSubmittingFilesRef.current = false;
+                    return [7 /*endfinally*/];
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); }, [
+        sendUserMessage,
+        sendFileMessage,
+        sendMultipleFilesMessage,
+        mentionedUsers,
+        quoteMessage,
+        setQuoteMessage,
+        currentChannel,
+        stopTyping,
+        clearPendingFiles,
+        isMultipleFilesMessageEnabled,
+        imageCompression,
+        logger,
+    ]);
     if (isBroadcast && !isOperator) {
         /* Only `Operator` can send messages in the Broadcast channel */
         return null;
@@ -336,6 +426,7 @@ var MessageInputWrapperView = React__default.forwardRef(function (props, ref) {
         quoteMessage && (React__default.createElement("div", { className: "sendbird-message-input-wrapper__quote-message-input" },
             React__default.createElement(QuoteMessageInput, { replyingMessage: quoteMessage, onClose: function () {
                     setQuoteMessage(null);
+                    stashedQuoteMessageRef.current = null;
                 } }))),
         showVoiceMessageInput ? (React__default.createElement(VoiceMessageInputWrapper, { channel: currentChannel !== null && currentChannel !== void 0 ? currentChannel : undefined, onSubmitClick: function (recordedFile, duration) {
                 sendVoiceMessage({ file: recordedFile, parentMessageId: quoteMessage === null || quoteMessage === void 0 ? void 0 : quoteMessage.messageId }, duration);
@@ -356,25 +447,7 @@ var MessageInputWrapperView = React__default.forwardRef(function (props, ref) {
                 || (isDisabledBecauseMessageForm(messages, config.groupChannel.enableFormTypeMessage)
                     && stringSet.MESSAGE_INPUT__PLACE_HOLDER__MESSAGE_FORM)
                 || (disabled && stringSet.MESSAGE_INPUT__PLACE_HOLDER__DISABLED)
-                || undefined, ref: (ref || messageInputRef), disabled: isMessageInputDisabled, renderFileUploadIcon: renderFileUploadIcon, renderSendMessageIcon: renderSendMessageIcon, renderVoiceMessageIcon: renderVoiceMessageIcon, onStartTyping: function () {
-                currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.startTyping();
-            }, onSendMessage: function (_a) {
-                var _b;
-                var message = _a.message, mentionTemplate = _a.mentionTemplate;
-                sendUserMessage({
-                    message: message,
-                    mentionedUsers: mentionedUsers,
-                    mentionedMessageTemplate: mentionTemplate,
-                    parentMessageId: quoteMessage === null || quoteMessage === void 0 ? void 0 : quoteMessage.messageId,
-                });
-                setMentionNickname('');
-                setMentionedUsers([]);
-                setQuoteMessage(null);
-                (_b = currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.endTyping) === null || _b === void 0 ? void 0 : _b.call(currentChannel);
-            }, onFileUpload: function (fileList) {
-                handleUploadFiles(fileList);
-                setQuoteMessage(null);
-            }, onUserMentioned: function (user) {
+                || undefined, ref: (ref || messageInputRef), disabled: isMessageInputDisabled, renderFileUploadIcon: renderFileUploadIcon, renderSendMessageIcon: renderSendMessageIcon, renderVoiceMessageIcon: renderVoiceMessageIcon, onStartTyping: startTyping, onStopTyping: stopTyping, pendingFiles: pendingFiles, onAddFiles: addFiles, onRemoveFile: removeFile, onSubmit: handleSubmit, onUserMentioned: function (user) {
                 if ((selectedUser === null || selectedUser === void 0 ? void 0 : selectedUser.userId) === (user === null || user === void 0 ? void 0 : user.userId)) {
                     setSelectedUser(null);
                     setMentionNickname('');
@@ -397,4 +470,4 @@ var MessageInputWrapperView = React__default.forwardRef(function (props, ref) {
 });
 
 export { MessageInputWrapperView as M, VoiceMessageInputWrapper as V };
-//# sourceMappingURL=bundle-LuCErKTs.js.map
+//# sourceMappingURL=bundle-B9O57ngP.js.map

package/chunks/{bundle-LuCErKTs.js.map → bundle-B9O57ngP.js.map}

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

package/chunks/{bundle-D_pOeelV.js → bundle-BCkp7Oqg.js}

@@ -1,9 +1,7 @@
 // src/lib/Sendbird/types.ts
 // Roles for a user in a channel
 var Role = {
-    OPERATOR: 'operator',
-    NONE: 'none',
-};
+    OPERATOR: 'operator'};
 
 export { Role as R };
-//# sourceMappingURL=bundle-D_pOeelV.js.map
+//# sourceMappingURL=bundle-BCkp7Oqg.js.map

package/chunks/bundle-BCkp7Oqg.js.map

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

package/chunks/{bundle-DbVYTOyC.js → bundle-BESkqMH6.js}

@@ -8,5 +8,5 @@ var ThreadReplySelectType;
     ThreadReplySelectType["THREAD"] = "THREAD";
 })(ThreadReplySelectType || (ThreadReplySelectType = {}));
 
-export { MAX_USER_MENTION_COUNT as M, ThreadReplySelectType as T, UIKIT_COMPATIBLE_FORM_VERSION as U, USER_MENTION_TEMP_CHAR as a, MAX_USER_SUGGESTION_COUNT as b };
-//# sourceMappingURL=bundle-DbVYTOyC.js.map
+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-BESkqMH6.js.map

package/chunks/bundle-BESkqMH6.js.map

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

package/chunks/{bundle-Dr0wIN5F.js → bundle-BEoJjyra.js}

@@ -1,4 +1,4 @@
 var OG_MESSAGE_BODY_CLASSNAME = 'sendbird-og-message-item-body__text-bubble';
 
 export { OG_MESSAGE_BODY_CLASSNAME as O };
-//# sourceMappingURL=bundle-Dr0wIN5F.js.map
+//# sourceMappingURL=bundle-BEoJjyra.js.map

package/chunks/bundle-BEoJjyra.js.map

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

package/chunks/{bundle-H2vPT1yo.js → bundle-BFHb2a4N.js}

@@ -7,4 +7,4 @@ var isMobileIOS = function (userAgent) {
 };
 
 export { isSafari as a, isMobileIOS as i };
-//# sourceMappingURL=bundle-H2vPT1yo.js.map
+//# sourceMappingURL=bundle-BFHb2a4N.js.map

package/chunks/bundle-BFHb2a4N.js.map

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

package/chunks/{bundle-D7HOrOoM.js → bundle-BHlB_i0L.js}

@@ -33,4 +33,4 @@ function classnames() {
 }
 
 export { classnames as c, deleteNullish as d, noop as n, openURL as o };
-//# sourceMappingURL=bundle-D7HOrOoM.js.map
+//# sourceMappingURL=bundle-BHlB_i0L.js.map

package/chunks/bundle-BHlB_i0L.js.map

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

package/chunks/{bundle-WkoNLiDg.js → bundle-BMYq1Zh-.js}

@@ -1,11 +1,11 @@
 import React__default, { useContext } from 'react';
-import { M as Modal } from './bundle-7U4PQody.js';
-import './bundle-Rf2YUo_V.js';
-import './bundle-C0kbt3jK.js';
+import { a as Modal } from './bundle-CPv8kS7Z.js';
+import './bundle-ybWGQIGZ.js';
+import './bundle-BPmYBX7K.js';
 import { ButtonTypes } from '../ui/Button.js';
-import { L as LocalizationContext } from './bundle-D-RwYEMS.js';
-import { g as getModalDeleteMessageTitle } from './bundle-Czj8Brwx.js';
-import { u as useThread } from './bundle-BCVCTP-D.js';
+import { L as LocalizationContext } from './bundle-BRfCkqhH.js';
+import { g as getModalDeleteMessageTitle } from './bundle-ChFCXvmT.js';
+import { u as useThread } from './bundle-D-GR_iCk.js';
 
 var RemoveMessage = function (props) {
     var _a, _b;
@@ -21,4 +21,4 @@ var RemoveMessage = function (props) {
 };
 
 export { RemoveMessage as R };
-//# sourceMappingURL=bundle-WkoNLiDg.js.map
+//# sourceMappingURL=bundle-BMYq1Zh-.js.map

package/chunks/bundle-BMYq1Zh-.js.map

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

package/chunks/{bundle-oemCj6em.js → bundle-BMZLZn9T.js}

@@ -1,14 +1,14 @@
 import React__default, { useRef, useContext, useEffect, useMemo, useState } from 'react';
-import { L as Label, a as LabelTypography, b as LabelColors } from './bundle-C0kbt3jK.js';
-import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
-import { A as Avatar } from './bundle-TVnsbl6m.js';
-import { L as LocalizationContext, u as useLocalization } from './bundle-D-RwYEMS.js';
-import { u as uuidv4 } from './bundle-B9eInLCQ.js';
-import { c as classnames } from './bundle-D7HOrOoM.js';
-import { a as USER_MENTION_TEMP_CHAR, M as MAX_USER_MENTION_COUNT, b as MAX_USER_SUGGESTION_COUNT } from './bundle-DbVYTOyC.js';
-import { M as MessageInputKeys } from './bundle-5uYh-Xyr.js';
-import { a as __awaiter, b as __generator } from './bundle-Rf2YUo_V.js';
-import { u as useSendbird } from './bundle-N4pYliV4.js';
+import { L as Label, a as LabelColors, c as LabelTypography } from './bundle-BPmYBX7K.js';
+import Icon, { IconColors, IconTypes } from '../ui/Icon.js';
+import { A as Avatar } from './bundle-BcuhBdVJ.js';
+import { L as LocalizationContext, u as useLocalization } from './bundle-BRfCkqhH.js';
+import { u as uuidv4 } from './bundle-DnjdXo2G.js';
+import { c as classnames } from './bundle-BHlB_i0L.js';
+import { b as USER_MENTION_TEMP_CHAR, a as MAX_USER_SUGGESTION_COUNT, M as MAX_USER_MENTION_COUNT } from './bundle-BESkqMH6.js';
+import { M as MessageInputKeys } from './bundle-COe8BPAs.js';
+import { a as __awaiter, c as __generator } from './bundle-ybWGQIGZ.js';
+import { u as useSendbird } from './bundle-CsMoZtyW.js';
 
 function SuggestedUserMentionItem(props) {
     var member = props.member, _a = props.isFocused, isFocused = _a === void 0 ? false : _a, parentScrollRef = props.parentScrollRef, onClick = props.onClick, onMouseOver = props.onMouseOver, onMouseMove = props.onMouseMove, renderUserMentionItem = props.renderUserMentionItem;
@@ -69,21 +69,21 @@ function fetchMembersFromQuery(currentUserId, channel, maxSuggestionCount, searc
 
 var DEBOUNCING_TIME = 300;
 var SuggestedMentionListView = function (props) {
-    var _a, _b, _c;
-    var className = props.className, currentChannel = props.currentChannel, _d = props.targetNickname, targetNickname = _d === void 0 ? '' : _d, 
+    var _a, _b, _c, _d;
+    var className = props.className, currentChannel = props.currentChannel, _e = props.targetNickname, targetNickname = _e === void 0 ? '' : _e, 
     // memberListQuery,
-    onUserItemClick = props.onUserItemClick, onFocusItemChange = props.onFocusItemChange, onFetchUsers = props.onFetchUsers, renderUserMentionItem = props.renderUserMentionItem, inputEvent = props.inputEvent, _e = props.ableAddMention, ableAddMention = _e === void 0 ? true : _e, _f = props.maxMentionCount, maxMentionCount = _f === void 0 ? MAX_USER_MENTION_COUNT : _f, _g = props.maxSuggestionCount, maxSuggestionCount = _g === void 0 ? MAX_USER_SUGGESTION_COUNT : _g;
+    onUserItemClick = props.onUserItemClick, onFocusItemChange = props.onFocusItemChange, onFetchUsers = props.onFetchUsers, renderUserMentionItem = props.renderUserMentionItem, inputEvent = props.inputEvent, _f = props.ableAddMention, ableAddMention = _f === void 0 ? true : _f, _g = props.maxMentionCount, maxMentionCount = _g === void 0 ? MAX_USER_MENTION_COUNT : _g, _h = props.maxSuggestionCount, maxSuggestionCount = _h === void 0 ? MAX_USER_SUGGESTION_COUNT : _h;
     var state = useSendbird().state;
     var config = state.config, stores = state.stores;
     var logger = config.logger;
     var currentUserId = ((_c = (_b = (_a = stores === null || stores === void 0 ? void 0 : stores.sdkStore) === null || _a === void 0 ? void 0 : _a.sdk) === null || _b === void 0 ? void 0 : _b.currentUser) === null || _c === void 0 ? void 0 : _c.userId) || '';
     var scrollRef = useRef(null);
     var stringSet = useLocalization().stringSet;
-    var _h = useState(null), timer = _h[0], setTimer = _h[1];
-    var _j = useState(''), searchString = _j[0], setSearchString = _j[1];
-    var _k = useState(''), lastSearchString = _k[0], setLastSearchString = _k[1];
-    var _l = useState(null), currentFocusedMember = _l[0], setCurrentFocusedMember = _l[1];
-    var _m = useState([]), currentMemberList = _m[0], setCurrentMemberList = _m[1];
+    var _j = useState(null), timer = _j[0], setTimer = _j[1];
+    var _k = useState(''), searchString = _k[0], setSearchString = _k[1];
+    var _l = useState(''), lastSearchString = _l[0], setLastSearchString = _l[1];
+    var _m = useState(null), currentFocusedMember = _m[0], setCurrentFocusedMember = _m[1];
+    var _o = useState([]), currentMemberList = _o[0], setCurrentMemberList = _o[1];
     useEffect(function () {
         clearTimeout(timer !== null && timer !== void 0 ? timer : undefined);
         setTimer(setTimeout(function () {
@@ -144,6 +144,8 @@ var SuggestedMentionListView = function (props) {
     }, [
         currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.url,
         // We have to be specific like this or React would not recognize the changes in instances.
+        (_d = currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.members) === null || _d === void 0 ? void 0 : _d.length,
+        currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.members.map(function (member) { return member.userId; }).join(),
         currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.members.map(function (member) { return member.nickname; }).join(),
         currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.members.map(function (member) { return member.isActive; }).join(),
         searchString,
@@ -170,4 +172,4 @@ var SuggestedMentionListView = function (props) {
 };
 
 export { SuggestedMentionListView as S };
-//# sourceMappingURL=bundle-oemCj6em.js.map
+//# sourceMappingURL=bundle-BMZLZn9T.js.map

package/{cjs/chunks/bundle-BEC0Joom.js.map → chunks/bundle-BMZLZn9T.js.map}

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