@sendbird/uikit-react 3.17.12 → 3.18.0

package/chunks/{bundle-LuCErKTs.js → bundle-CwMNZmx9.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-Bpofr334.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-AsQ1wnFm.js';
+import { b as isDisabledBecauseFrozen, d as isDisabledBecauseMuted, e as isDisabledBecauseSuggestedReplies, c as isDisabledBecauseMessageForm } from './bundle-DiO7lolz.js';
+import { u as useLocalization } from './bundle-Cdqsdoa8.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-DzB_38co.js';
+import { a as Modal } from './bundle-C4anRHWY.js';
+import Button, { ButtonSizes, ButtonTypes } from '../ui/Button.js';
+import { V as VOICE_PLAYER_STATUS } from './bundle-DWURNKdQ.js';
+import { u as uuidv4 } from './bundle-LLA95Pqf.js';
+import { u as useSendbird } from './bundle-4clodtJA.js';
+import { c as checkIfFileUploadEnabled, M as MessageInput } from './bundle-BCjR1Qiq.js';
+import { a as usePendingFiles, u as useDragAndDrop } from './bundle-ExNQo0Ly.js';
+import { i as isChannelTypeSupportsMultipleFilesMessage } from './bundle-C5-D2BAP.js';
+import { u as useMediaQueryContext } from './bundle-C2ARCMSL.js';
+import { M as MessageInputKeys } from './bundle-BEPoP7sp.js';
+import { c as compressImages } from './bundle-BfgSx7DM.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-CwMNZmx9.js.map

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

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

package/chunks/{bundle-BG86HGdS.js → bundle-Cyocqt10.js}

@@ -1,13 +1,11 @@
 import React__default from 'react';
-import { C as ContextMenu, b as MenuItems, c as MenuItem } from './bundle-BC1qEtzM.js';
-import { u as useLocalization } from './bundle-D-RwYEMS.js';
-import { u as useSendbird } from './bundle-N4pYliV4.js';
+import { C as ContextMenu, f as MenuItems, e as MenuItem } from './bundle-zNUBt0Cg.js';
+import { u as useLocalization } from './bundle-Cdqsdoa8.js';
+import { u as useSendbird } from './bundle-4clodtJA.js';
 
 var OpenChannelMessageStatusTypes = {
-    NONE: 'none',
     PENDING: 'pending',
     FAILED: 'failed',
-    CANCELED: 'canceled',
     SUCCEEDED: 'succeeded',
 };
 var getSenderFromMessage = function (message) {
@@ -51,14 +49,14 @@ var showMenuTrigger = function (props) {
     var message = props.message, status = props.status, userId = props.userId;
     // @ts-ignore
     if (message.messageType === 'user') {
-        return (isFineDelete({ message: message, status: status, userId: userId })
+        return (isFineDelete({ message: message, userId: userId })
             || isFineEdit({ message: message, status: status, userId: userId })
             // @ts-ignore
-            || isFineCopy({ message: message, status: status, userId: userId })
+            || isFineCopy({ message: message})
             || isFineResend({ message: message, status: status, userId: userId }));
     }
     else {
-        return (isFineDelete({ message: message, status: status, userId: userId })
+        return (isFineDelete({ message: message, userId: userId })
             || isFineResend({ message: message, status: status, userId: userId }));
     }
 };
@@ -71,7 +69,7 @@ var OpenChannelMobileMenu = function (props) {
     var userId = useSendbird().state.config.userId;
     var fileMessage = message;
     return (React__default.createElement(ContextMenu, { isOpen: true, menuItems: function () { return (React__default.createElement(MenuItems, { className: "sendbird-openchannel__mobile-menu", parentRef: parentRef, parentContainRef: parentRef, closeDropdown: hideMenu },
-            isFineCopy({ message: userMessage, userId: userId, status: status }) && (React__default.createElement(MenuItem, { className: "sendbird-openchannel-og-message__top__context-menu__copy", onClick: function () {
+            isFineCopy({ message: userMessage}) && (React__default.createElement(MenuItem, { className: "sendbird-openchannel-og-message__top__context-menu__copy", onClick: function () {
                     copyToClipboard === null || copyToClipboard === void 0 ? void 0 : copyToClipboard();
                 }, testID: "open_channel_mobile_context_menu_copy" },
                 React__default.createElement(React__default.Fragment, null, stringSet.CONTEXT_MENU_DROPDOWN__COPY))),
@@ -83,7 +81,7 @@ var OpenChannelMobileMenu = function (props) {
                     resendMessage === null || resendMessage === void 0 ? void 0 : resendMessage();
                 }, testID: "open_channel_mobile_context_menu_resend" },
                 React__default.createElement(React__default.Fragment, null, stringSet.CONTEXT_MENU_DROPDOWN__RESEND))),
-            (!isEphemeral && isFineDelete({ message: message, userId: userId, status: status })) && (React__default.createElement(MenuItem, { onClick: function () {
+            (!isEphemeral && isFineDelete({ message: message, userId: userId})) && (React__default.createElement(MenuItem, { onClick: function () {
                     showRemove === null || showRemove === void 0 ? void 0 : showRemove();
                 }, testID: "open_channel_mobile_context_menu_delete" },
                 React__default.createElement(React__default.Fragment, null, stringSet.CONTEXT_MENU_DROPDOWN__DELETE))),
@@ -93,5 +91,5 @@ var OpenChannelMobileMenu = function (props) {
                 React__default.createElement("a", { className: "sendbird-openchannel__mobile-menu-hyperlink", rel: "noopener noreferrer", href: fileMessage === null || fileMessage === void 0 ? void 0 : fileMessage.url, target: "_blank" }, stringSet.CONTEXT_MENU_DROPDOWN__SAVE))))); } }));
 };
 
-export { OpenChannelMobileMenu as O, isFineEdit as a, isFineResend as b, isFineDelete as c, checkIsPending as d, checkIsFailed as e, checkIsSent as f, getSenderFromMessage as g, isFineCopy as i, showMenuTrigger as s };
-//# sourceMappingURL=bundle-BG86HGdS.js.map
+export { OpenChannelMobileMenu as O, checkIsPending as a, checkIsSent as b, checkIsFailed as c, isFineDelete as d, isFineEdit as e, isFineResend as f, getSenderFromMessage as g, isFineCopy as i, showMenuTrigger as s };
+//# sourceMappingURL=bundle-Cyocqt10.js.map

package/{cjs/chunks/bundle-BbAqlLCc.js.map → chunks/bundle-Cyocqt10.js.map}

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

package/chunks/{bundle-DUcF-Ysh.js → bundle-D-L9ZslG.js}

@@ -1,9 +1,9 @@
-import React__default, { useCallback, useEffect, useContext, useReducer } from 'react';
+import React__default, { useCallback, useEffect, useReducer, useContext } from 'react';
 import { OpenChannelHandler } from '@sendbird/chat/openChannel';
-import { p as pubSubTopics } from './bundle-CeNQpnlq.js';
-import { u as uuidv4 } from './bundle-B9eInLCQ.js';
-import { _ as __assign, c as __spreadArray } from './bundle-Rf2YUo_V.js';
-import { u as useSendbird } from './bundle-N4pYliV4.js';
+import { p as pubSubTopics } from './bundle-YDriVB8K.js';
+import { u as uuidv4 } from './bundle-LLA95Pqf.js';
+import { _ as __assign, e as __spreadArray } from './bundle-Bpofr334.js';
+import { u as useSendbird } from './bundle-4clodtJA.js';
 
 var OpenChannelListFetchingStatus;
 (function (OpenChannelListFetchingStatus) {
@@ -358,10 +358,10 @@ var OpenChannelListProvider = function (_a) {
         } },
         React__default.createElement("div", { className: "sendbird-open-channel-list ".concat(className) }, children)));
 };
-var OpenChannelListProvider$1 = {
+var OpenChannelListProvider_default = {
     OpenChannelListProvider: OpenChannelListProvider,
     useOpenChannelListContext: useOpenChannelListContext,
 };
 
-export { OpenChannelListProvider as O, OpenChannelListFetchingStatus as a, OpenChannelListActionTypes$1 as b, OpenChannelListProvider$1 as c, useOpenChannelListContext as u };
-//# sourceMappingURL=bundle-DUcF-Ysh.js.map
+export { OpenChannelListActionTypes$1 as O, OpenChannelListFetchingStatus as a, OpenChannelListProvider as b, OpenChannelListProvider_default as c, useOpenChannelListContext as u };
+//# sourceMappingURL=bundle-D-L9ZslG.js.map

package/chunks/{bundle-DUcF-Ysh.js.map → bundle-D-L9ZslG.js.map}

@@ -1 +1 @@
-{"version":3,"file":"bundle-DUcF-Ysh.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"bundle-D-L9ZslG.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/chunks/{bundle-DGQWH-cy.js → bundle-D0WVu0lN.js}

@@ -5,4 +5,4 @@ var TypingIndicatorType;
 })(TypingIndicatorType || (TypingIndicatorType = {}));
 
 export { TypingIndicatorType as T };
-//# sourceMappingURL=bundle-DGQWH-cy.js.map
+//# sourceMappingURL=bundle-D0WVu0lN.js.map

package/chunks/bundle-D0WVu0lN.js.map

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

package/chunks/{bundle-gwjSH2mW.js → bundle-D3zdGXmK.js}

@@ -1,7 +1,7 @@
 import { ConnectionHandler } from '@sendbird/chat';
 import { useRef, useLayoutEffect, useState, useEffect, useMemo } from 'react';
-import { u as uuidv4 } from './bundle-B9eInLCQ.js';
-import { a as __awaiter, b as __generator } from './bundle-Rf2YUo_V.js';
+import { u as uuidv4 } from './bundle-LLA95Pqf.js';
+import { a as __awaiter, c as __generator } from './bundle-Bpofr334.js';
 
 // this hook accepts a callback to run component is unmounted
 function useUnmount(callback) {
@@ -194,5 +194,5 @@ function useMarkAsDeliveredScheduler(_a, _b) {
     return markAsDeliveredScheduler;
 }
 
-export { useMarkAsDeliveredScheduler as a, useUnmount as b, schedulerFactory as s, useOnlineStatus as u };
-//# sourceMappingURL=bundle-gwjSH2mW.js.map
+export { useOnlineStatus as a, useUnmount as b, schedulerFactory as s, useMarkAsDeliveredScheduler as u };
+//# sourceMappingURL=bundle-D3zdGXmK.js.map

package/chunks/{bundle-gwjSH2mW.js.map → bundle-D3zdGXmK.js.map}

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