@sendbird/uikit-react 3.10.1 → 3.11.0

package/cjs/chunks/bundle-W1vXanLo.js

@@ -0,0 +1,392 @@
+'use strict';
+
+var _tslib = require('./bundle-RVs527mS.js');
+var React = require('react');
+var utils = require('./bundle-C42WLw1z.js');
+var useSendbirdStateContext = require('../useSendbirdStateContext.js');
+var LocalizationContext = require('./bundle-WLD9KKbn.js');
+var SuggestedMentionListView = require('./bundle-WuJcM_O3.js');
+var Message_hooks_useDirtyGetMentions = require('../Message/hooks/useDirtyGetMentions.js');
+var ui_QuoteMessageInput = require('../ui/QuoteMessageInput.js');
+var VoicePlayer_useVoicePlayer = require('../VoicePlayer/useVoicePlayer.js');
+var VoiceRecorder_useVoiceRecorder = require('../VoiceRecorder/useVoiceRecorder.js');
+var ui_VoiceMessageInput = require('./bundle-Z-IXQ2N3.js');
+var ui_Modal = require('./bundle-lnLwvZ7H.js');
+var ui_Button = require('../ui/Button.js');
+var consts = require('./bundle-SggLEV_z.js');
+var VoicePlayer_context = require('./bundle-_apVcG-_.js');
+var uuid = require('./bundle-sW6CpN9W.js');
+var ui_MessageInput = require('../ui/MessageInput.js');
+var MediaQueryContext = require('./bundle-2ToiwW-_.js');
+var _const = require('./bundle-L5q_NWiq.js');
+var index = require('./bundle-fnv2bNo-.js');
+var hooks_useModal = require('../hooks/useModal.js');
+require('./bundle-JaD2Ao-u.js');
+var compressImages = require('./bundle-aAOHT0Qv.js');
+
+var SuggestedMentionList = function (props) {
+    return (React.createElement(SuggestedMentionListView.SuggestedMentionListView, _tslib.__assign({}, props)));
+};
+
+var VoiceMessageInputWrapper = function (_a) {
+    var _b;
+    var channel = _a.channel, onCancelClick = _a.onCancelClick, onSubmitClick = _a.onSubmitClick;
+    var uuid$1 = React.useRef(uuid.uuidv4()).current;
+    var _c = React.useState(null), audioFile = _c[0], setAudioFile = _c[1];
+    var _d = React.useState(ui_VoiceMessageInput.VoiceMessageInputStatus.READY_TO_RECORD), voiceInputState = _d[0], setVoiceInputState = _d[1];
+    var _e = React.useState(false), isSubmitted = _e[0], setSubmit = _e[1];
+    var _f = React.useState(false), isDisabled = _f[0], setDisabled = _f[1];
+    var _g = React.useState(false), showModal = _g[0], setShowModal = _g[1];
+    var stringSet = LocalizationContext.useLocalization().stringSet;
+    var config = useSendbirdStateContext.useSendbirdStateContext().config;
+    var minRecordingTime = ((_b = config === null || config === void 0 ? void 0 : config.voiceRecord) === null || _b === void 0 ? void 0 : _b.minRecordingTime) || consts.VOICE_RECORDER_DEFAULT_MIN;
+    var _h = VoiceRecorder_useVoiceRecorder.useVoiceRecorder({
+        onRecordingStarted: function () {
+            setVoiceInputState(ui_VoiceMessageInput.VoiceMessageInputStatus.RECORDING);
+        },
+        onRecordingEnded: function (audioFile) {
+            setAudioFile(audioFile);
+        },
+    }), start = _h.start, stop = _h.stop, cancel = _h.cancel, recordingTime = _h.recordingTime, recordingStatus = _h.recordingStatus, recordingLimit = _h.recordingLimit;
+    var voicePlayer = VoicePlayer_useVoicePlayer.useVoicePlayer({
+        channelUrl: channel === null || channel === void 0 ? void 0 : channel.url,
+        key: uuid$1,
+        audioFile: audioFile,
+    });
+    var play = voicePlayer.play, pause = voicePlayer.pause, playbackTime = voicePlayer.playbackTime, playingStatus = voicePlayer.playingStatus;
+    var stopVoicePlayer = voicePlayer.stop;
+    // disabled state: muted & frozen
+    React.useEffect(function () {
+        if (utils.isDisabledBecauseFrozen(channel) || utils.isDisabledBecauseMuted(channel)) {
+            setDisabled(true);
+        }
+        else {
+            setDisabled(false);
+        }
+    }, [channel === null || channel === void 0 ? void 0 : channel.myRole, channel === null || channel === void 0 ? void 0 : channel.isFrozen, channel === null || channel === void 0 ? void 0 : channel.myMutedState]);
+    // call onSubmitClick when submit button is clicked and recorded audio file is created
+    React.useEffect(function () {
+        if (isSubmitted && audioFile) {
+            onSubmitClick(audioFile, recordingTime);
+            setSubmit(false);
+            setAudioFile(null);
+        }
+    }, [isSubmitted, audioFile, recordingTime]);
+    // operate which control button should be displayed
+    React.useEffect(function () {
+        if (audioFile) {
+            if (recordingTime < minRecordingTime) {
+                setVoiceInputState(ui_VoiceMessageInput.VoiceMessageInputStatus.READY_TO_RECORD);
+                setAudioFile(null);
+            }
+            else if (playingStatus === VoicePlayer_context.VOICE_PLAYER_STATUS.PLAYING) {
+                setVoiceInputState(ui_VoiceMessageInput.VoiceMessageInputStatus.PLAYING);
+            }
+            else {
+                setVoiceInputState(ui_VoiceMessageInput.VoiceMessageInputStatus.READY_TO_PLAY);
+            }
+        }
+    }, [audioFile, recordingTime, playingStatus]);
+    return (React.createElement("div", { className: "sendbird-voice-message-input-wrapper" },
+        React.createElement(ui_VoiceMessageInput.VoiceMessageInput, { currentValue: recordingStatus === VoiceRecorder_useVoiceRecorder.VoiceRecorderStatus.COMPLETED ? playbackTime : recordingTime, maximumValue: recordingStatus === VoiceRecorder_useVoiceRecorder.VoiceRecorderStatus.COMPLETED ? recordingTime : recordingLimit, currentType: voiceInputState, onCancelClick: function () {
+                onCancelClick();
+                cancel();
+                stopVoicePlayer();
+            }, onSubmitClick: function () {
+                if (isDisabled) {
+                    setShowModal(true);
+                    setVoiceInputState(ui_VoiceMessageInput.VoiceMessageInputStatus.READY_TO_RECORD);
+                }
+                else {
+                    stop();
+                    pause();
+                    setSubmit(true);
+                }
+            }, onControlClick: function (type) {
+                switch (type) {
+                    case ui_VoiceMessageInput.VoiceMessageInputStatus.READY_TO_RECORD: {
+                        stopVoicePlayer();
+                        start();
+                        break;
+                    }
+                    case ui_VoiceMessageInput.VoiceMessageInputStatus.RECORDING: {
+                        if (recordingTime >= minRecordingTime && !isDisabled) {
+                            stop();
+                        }
+                        else if (isDisabled) {
+                            cancel();
+                            setShowModal(true);
+                            setVoiceInputState(ui_VoiceMessageInput.VoiceMessageInputStatus.READY_TO_RECORD);
+                        }
+                        else {
+                            cancel();
+                            setVoiceInputState(ui_VoiceMessageInput.VoiceMessageInputStatus.READY_TO_RECORD);
+                        }
+                        break;
+                    }
+                    case ui_VoiceMessageInput.VoiceMessageInputStatus.READY_TO_PLAY: {
+                        play();
+                        break;
+                    }
+                    case ui_VoiceMessageInput.VoiceMessageInputStatus.PLAYING: {
+                        pause();
+                        break;
+                    }
+                }
+            } }),
+        showModal && (React.createElement(ui_Modal.Modal, { className: "sendbird-voice-message-input-wrapper-alert", titleText: utils.isDisabledBecauseMuted(channel)
+                ? stringSet.MODAL__VOICE_MESSAGE_INPUT_DISABLED__TITLE_MUTED
+                : stringSet.MODAL__VOICE_MESSAGE_INPUT_DISABLED__TITLE_FROZEN, hideFooter: true, isCloseOnClickOutside: true, onCancel: function () {
+                setShowModal(false);
+                onCancelClick();
+            } },
+            React.createElement("div", { className: "sendbird-voice-message-input-wrapper-alert__body" },
+                React.createElement(ui_Button.default, { className: "sendbird-voice-message-input-wrapper-alert__body__ok-button", type: ui_Button.ButtonTypes.PRIMARY, size: ui_Button.ButtonSizes.BIG, onClick: function () {
+                        setShowModal(false);
+                        onCancelClick();
+                    } }, stringSet.BUTTON__OK))))));
+};
+
+var useHandleUploadFiles = function (_a, _b) {
+    var sendFileMessage = _a.sendFileMessage, sendMultipleFilesMessage = _a.sendMultipleFilesMessage, quoteMessage = _a.quoteMessage;
+    var logger = _b.logger;
+    var stringSet = LocalizationContext.useLocalization().stringSet;
+    var config = useSendbirdStateContext.useSendbirdStateContext().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 = hooks_useModal.useGlobalModalContext().openModal;
+    return React.useCallback(function (files) { return _tslib.__awaiter(void 0, void 0, void 0, function () {
+        var ONE_MiB, compressedFiles, sendingFiles, file, imageFiles_1, otherFiles_1;
+        return _tslib.__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: "Up to ".concat(uikitMultipleFilesMessageLimit, " files can be attached."),
+                                hideFooter: true,
+                            },
+                            childElement: function (_a) {
+                                var closeModal = _a.closeModal;
+                                return (React.createElement(ui_Modal.ModalFooter, { type: ui_Button.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: "The maximum size per file is ".concat(Math.floor(uikitUploadSizeLimit / ONE_MiB), " MB."),
+                                hideFooter: true,
+                            },
+                            childElement: function (_a) {
+                                var closeModal = _a.closeModal;
+                                return (React.createElement(ui_Modal.ModalFooter, { type: ui_Button.ButtonTypes.PRIMARY, submitText: stringSet.BUTTON__OK, hideCancelButton: true, onCancel: closeModal, onSubmit: closeModal }));
+                            },
+                        });
+                        return [2 /*return*/];
+                    }
+                    return [4 /*yield*/, compressImages.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 (index.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.forwardRef(function (props, ref) {
+    // Props
+    var currentChannel = props.currentChannel, localIsMFMEnabled = props.isMultipleFilesMessageEnabled, loading = props.loading, quoteMessage = props.quoteMessage, setQuoteMessage = props.setQuoteMessage, messageInputRef = props.messageInputRef, sendUserMessage = props.sendUserMessage, sendFileMessage = props.sendFileMessage, sendVoiceMessage = props.sendVoiceMessage, sendMultipleFilesMessage = props.sendMultipleFilesMessage, 
+    // render
+    renderUserMentionItem = props.renderUserMentionItem, renderFileUploadIcon = props.renderFileUploadIcon, renderVoiceMessageIcon = props.renderVoiceMessageIcon, renderSendMessageIcon = props.renderSendMessageIcon, acceptableMimeTypes = props.acceptableMimeTypes, disabled = props.disabled;
+    var stringSet = LocalizationContext.useLocalization().stringSet;
+    var isMobile = MediaQueryContext.useMediaQueryContext().isMobile;
+    var _a = useSendbirdStateContext.useSendbirdStateContext(), stores = _a.stores, config = _a.config;
+    var isOnline = config.isOnline, isMentionEnabled = config.isMentionEnabled, isVoiceMessageEnabled = config.isVoiceMessageEnabled, globalIsMFMenabled = config.isMultipleFilesMessageEnabled, userMention = config.userMention, logger = config.logger;
+    var sdk = stores.sdkStore.sdk;
+    var maxMentionCount = userMention.maxMentionCount, maxSuggestionCount = userMention.maxSuggestionCount;
+    var isBroadcast = currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.isBroadcast;
+    var isOperator = (currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.myRole) === 'operator';
+    // States
+    var _b = React.useState(''), mentionNickname = _b[0], setMentionNickname = _b[1];
+    var _c = React.useState([]), mentionedUsers = _c[0], setMentionedUsers = _c[1];
+    var _d = React.useState([]), mentionedUserIds = _d[0], setMentionedUserIds = _d[1];
+    var _e = React.useState(null), selectedUser = _e[0], setSelectedUser = _e[1];
+    var _f = React.useState([]), mentionSuggestedUsers = _f[0], setMentionSuggestedUsers = _f[1];
+    var _g = React.useState(null), messageInputEvent = _g[0], setMessageInputEvent = _g[1];
+    var _h = React.useState(false), showVoiceMessageInput = _h[0], setShowVoiceMessageInput = _h[1];
+    // Conditions
+    var isMessageInputDisabled = loading
+        || !currentChannel
+        || utils.isDisabledBecauseFrozen(currentChannel)
+        || utils.isDisabledBecauseMuted(currentChannel)
+        || (!isOnline && !(sdk === null || sdk === void 0 ? void 0 : sdk.isCacheEnabled))
+        || disabled;
+    var showSuggestedMentionList = !isMessageInputDisabled
+        && isMentionEnabled
+        && mentionNickname.length > 0
+        && !isBroadcast;
+    var isMultipleFilesMessageEnabled = localIsMFMEnabled !== null && localIsMFMEnabled !== void 0 ? localIsMFMEnabled : globalIsMFMenabled;
+    var mentionNodes = Message_hooks_useDirtyGetMentions.useDirtyGetMentions({ ref: ref || messageInputRef }, { logger: logger });
+    var ableMention = (mentionNodes === null || mentionNodes === void 0 ? void 0 : mentionNodes.length) < maxMentionCount;
+    // Operate states
+    React.useEffect(function () {
+        setMentionNickname('');
+        setMentionedUsers([]);
+        setMentionedUserIds([]);
+        setSelectedUser(null);
+        setMentionSuggestedUsers([]);
+        setMessageInputEvent(null);
+        setShowVoiceMessageInput(false);
+    }, [currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.url]);
+    React.useEffect(function () {
+        setMentionedUsers(mentionedUsers.filter(function (_a) {
+            var userId = _a.userId;
+            var i = mentionedUserIds.indexOf(userId);
+            if (i < 0) {
+                return false;
+            }
+            else {
+                mentionedUserIds.splice(i, 1);
+                return true;
+            }
+        }));
+    }, [mentionedUserIds]);
+    // Callbacks
+    var handleUploadFiles = useHandleUploadFiles({
+        sendFileMessage: sendFileMessage,
+        sendMultipleFilesMessage: sendMultipleFilesMessage,
+        quoteMessage: quoteMessage,
+    }, { logger: logger });
+    if (isBroadcast && !isOperator) {
+        /* Only `Operator` can send messages in the Broadcast channel */
+        return null;
+    }
+    // other conditions
+    return (React.createElement("div", { className: "sendbird-message-input-wrapper".concat(showVoiceMessageInput ? '--voice-message' : '') },
+        showSuggestedMentionList && (React.createElement(SuggestedMentionList, { currentChannel: currentChannel, targetNickname: mentionNickname, inputEvent: messageInputEvent, renderUserMentionItem: renderUserMentionItem, onUserItemClick: function (user) {
+                if (user) {
+                    setMentionedUsers(_tslib.__spreadArray(_tslib.__spreadArray([], mentionedUsers, true), [user], false));
+                }
+                setMentionNickname('');
+                setSelectedUser(user);
+                setMessageInputEvent(null);
+            }, onFocusItemChange: function () {
+                setMessageInputEvent(null);
+            }, onFetchUsers: function (users) {
+                setMentionSuggestedUsers(users);
+            }, ableAddMention: ableMention, maxMentionCount: maxMentionCount, maxSuggestionCount: maxSuggestionCount })),
+        quoteMessage && (React.createElement("div", { className: "sendbird-message-input-wrapper__quote-message-input" },
+            React.createElement(ui_QuoteMessageInput, { replyingMessage: quoteMessage, onClose: function () { return setQuoteMessage(null); } }))),
+        showVoiceMessageInput ? (React.createElement(VoiceMessageInputWrapper, { channel: currentChannel, onSubmitClick: function (recordedFile, duration) {
+                sendVoiceMessage({ file: recordedFile, parentMessageId: quoteMessage === null || quoteMessage === void 0 ? void 0 : quoteMessage.messageId }, duration);
+                setQuoteMessage(null);
+                setShowVoiceMessageInput(false);
+            }, onCancelClick: function () {
+                setShowVoiceMessageInput(false);
+            } })) : (React.createElement(ui_MessageInput, { className: "sendbird-message-input-wrapper__message-input", channel: currentChannel, channelUrl: currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.url, acceptableMimeTypes: acceptableMimeTypes, mentionSelectedUser: selectedUser, isMentionEnabled: isMentionEnabled, isVoiceMessageEnabled: isVoiceMessageEnabled, isSelectingMultipleFilesEnabled: isMultipleFilesMessageEnabled, onVoiceMessageIconClick: function () {
+                setShowVoiceMessageInput(true);
+            }, setMentionedUsers: setMentionedUsers, placeholder: (quoteMessage && stringSet.MESSAGE_INPUT__QUOTE_REPLY__PLACE_HOLDER)
+                || ((disabled || utils.isDisabledBecauseFrozen(currentChannel)) && stringSet.MESSAGE_INPUT__PLACE_HOLDER__DISABLED)
+                || (utils.isDisabledBecauseMuted(currentChannel)
+                    && (isMobile ? stringSet.MESSAGE_INPUT__PLACE_HOLDER__MUTED_SHORT : stringSet.MESSAGE_INPUT__PLACE_HOLDER__MUTED)), 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) {
+                if ((selectedUser === null || selectedUser === void 0 ? void 0 : selectedUser.userId) === (user === null || user === void 0 ? void 0 : user.userId)) {
+                    setSelectedUser(null);
+                    setMentionNickname('');
+                }
+            }, onMentionStringChange: function (mentionText) {
+                setMentionNickname(mentionText);
+            }, onMentionedUserIdsUpdated: function (userIds) {
+                setMentionedUserIds(userIds);
+            }, onKeyDown: function (e) {
+                if (showSuggestedMentionList
+                    && (mentionSuggestedUsers === null || mentionSuggestedUsers === void 0 ? void 0 : mentionSuggestedUsers.length) > 0
+                    && ((e.key === _const.MessageInputKeys.Enter && ableMention)
+                        || e.key === _const.MessageInputKeys.ArrowUp
+                        || e.key === _const.MessageInputKeys.ArrowDown)) {
+                    setMessageInputEvent(e);
+                    return true;
+                }
+                return false;
+            } }))));
+});
+
+exports.MessageInputWrapperView = MessageInputWrapperView;
+exports.VoiceMessageInputWrapper = VoiceMessageInputWrapper;
+//# sourceMappingURL=bundle-W1vXanLo.js.map

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

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

package/cjs/chunks/{bundle-qtXdbPNE.js → bundle-WLD9KKbn.js}

@@ -1,8 +1,8 @@
 'use strict';
 
 var React = require('react');
-var stringSet = require('./bundle-kSScygqj.js');
-var index = require('./bundle-RSklGv-u.js');
+var stringSet = require('./bundle-OBj337Le.js');
+var index = require('./bundle-ZL4COF6I.js');
 
 var LocalizationContext = React.createContext({
     stringSet: stringSet.getStringSet('en'),
@@ -17,4 +17,4 @@ var useLocalization = function () { return React.useContext(LocalizationContext)
 exports.LocalizationContext = LocalizationContext;
 exports.LocalizationProvider = LocalizationProvider;
 exports.useLocalization = useLocalization;
-//# sourceMappingURL=bundle-qtXdbPNE.js.map
+//# sourceMappingURL=bundle-WLD9KKbn.js.map

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

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

package/cjs/chunks/bundle-WuJcM_O3.js

@@ -0,0 +1,183 @@
+'use strict';
+
+var React = require('react');
+var ui_Label = require('./bundle-JaD2Ao-u.js');
+var ui_Icon = require('../ui/Icon.js');
+var ui_Avatar = require('./bundle-rUpy0DGt.js');
+var LocalizationContext = require('./bundle-WLD9KKbn.js');
+var uuid = require('./bundle-sW6CpN9W.js');
+var useSendbirdStateContext = require('../useSendbirdStateContext.js');
+var _const = require('./bundle-L5q_NWiq.js');
+var _tslib = require('./bundle-RVs527mS.js');
+
+var MAX_USER_MENTION_COUNT = 10;
+var MAX_USER_SUGGESTION_COUNT = 15;
+var USER_MENTION_TEMP_CHAR = '@';
+var ThreadReplySelectType;
+(function (ThreadReplySelectType) {
+    ThreadReplySelectType["PARENT"] = "PARENT";
+    ThreadReplySelectType["THREAD"] = "THREAD";
+})(ThreadReplySelectType || (ThreadReplySelectType = {}));
+
+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;
+    var scrollRef = React.useRef(null);
+    var stringSet = React.useContext(LocalizationContext.LocalizationContext).stringSet;
+    React.useEffect(function () {
+        if (isFocused && (parentScrollRef === null || parentScrollRef === void 0 ? void 0 : parentScrollRef.current) != null && (scrollRef === null || scrollRef === void 0 ? void 0 : scrollRef.current) != null
+            && (parentScrollRef.current.scrollTop >= scrollRef.current.offsetTop
+                || parentScrollRef.current.scrollTop + parentScrollRef.current.clientHeight <= scrollRef.current.offsetTop)) {
+            scrollRef.current.scrollIntoView({ block: 'nearest', inline: 'nearest' });
+        }
+    }, [isFocused]);
+    var customMentionItem = React.useMemo(function () {
+        if (renderUserMentionItem) {
+            return (React.createElement("div", { className: "sendbird-mention-suggest-list__user-item", onClick: function (event) { return onClick === null || onClick === void 0 ? void 0 : onClick({ event: event, member: member, itemRef: scrollRef }); }, onMouseOver: function (event) { return onMouseOver === null || onMouseOver === void 0 ? void 0 : onMouseOver({ event: event, member: member, itemRef: scrollRef }); }, onMouseMove: function (event) { return onMouseMove === null || onMouseMove === void 0 ? void 0 : onMouseMove({ event: event, member: member, itemRef: scrollRef }); }, key: (member === null || member === void 0 ? void 0 : member.userId) || uuid.uuidv4(), ref: scrollRef }, renderUserMentionItem({ user: member })));
+        }
+    }, [renderUserMentionItem]);
+    if (customMentionItem) {
+        return customMentionItem;
+    }
+    return (React.createElement("div", { className: "sendbird-mention-suggest-list__user-item ".concat(isFocused ? 'focused' : ''), onClick: function (event) { return onClick === null || onClick === void 0 ? void 0 : onClick({ event: event, member: member, itemRef: scrollRef }); }, onMouseOver: function (event) { return onMouseOver === null || onMouseOver === void 0 ? void 0 : onMouseOver({ event: event, member: member, itemRef: scrollRef }); }, onMouseMove: function (event) { return onMouseMove === null || onMouseMove === void 0 ? void 0 : onMouseMove({ event: event, member: member, itemRef: scrollRef }); }, key: (member === null || member === void 0 ? void 0 : member.userId) || uuid.uuidv4(), ref: scrollRef },
+        React.createElement(ui_Avatar.Avatar, { className: "sendbird-mention-suggest-list__user-item__avatar", src: member === null || member === void 0 ? void 0 : member.profileUrl, alt: "user-profile", width: "24px", height: "24px" }),
+        React.createElement(ui_Label.Label, { className: "sendbird-mention-suggest-list__user-item__nickname", type: ui_Label.LabelTypography.SUBTITLE_2, color: (member === null || member === void 0 ? void 0 : member.nickname) ? ui_Label.LabelColors.ONBACKGROUND_1 : ui_Label.LabelColors.ONBACKGROUND_3 }, (member === null || member === void 0 ? void 0 : member.nickname) || (stringSet === null || stringSet === void 0 ? void 0 : stringSet.MENTION_NAME__NO_NAME)),
+        React.createElement(ui_Label.Label, { className: "sendbird-mention-suggest-list__user-item__user-id", type: ui_Label.LabelTypography.SUBTITLE_2, color: ui_Label.LabelColors.ONBACKGROUND_2 }, member === null || member === void 0 ? void 0 : member.userId)));
+}
+
+function fetchMembersFromChannel(currentUserId, channel, maxSuggestionCount, searchString) {
+    return _tslib.__awaiter(this, void 0, void 0, function () {
+        return _tslib.__generator(this, function (_a) {
+            return [2 /*return*/, channel.members
+                    .sort(function (a, b) { var _a; return (_a = a.nickname) === null || _a === void 0 ? void 0 : _a.localeCompare(b.nickname); })
+                    .filter(function (member) {
+                    var _a;
+                    return ((_a = member.nickname) === null || _a === void 0 ? void 0 : _a.toLowerCase().startsWith(searchString.toLowerCase()))
+                        && member.userId !== currentUserId
+                        && member.isActive;
+                }).slice(0, maxSuggestionCount)];
+        });
+    });
+}
+function fetchMembersFromQuery(currentUserId, channel, maxSuggestionCount, searchString) {
+    return _tslib.__awaiter(this, void 0, void 0, function () {
+        var query;
+        return _tslib.__generator(this, function (_a) {
+            query = channel.createMemberListQuery({
+                limit: maxSuggestionCount + 1,
+                nicknameStartsWithFilter: searchString,
+            });
+            return [2 /*return*/, query.next()
+                    .then(function (memberList) {
+                    return memberList
+                        .filter(function (member) { return currentUserId !== (member === null || member === void 0 ? void 0 : member.userId); })
+                        .slice(0, maxSuggestionCount);
+                })];
+        });
+    });
+}
+
+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, 
+    // 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;
+    var _h = useSendbirdStateContext.useSendbirdStateContext(), config = _h.config, stores = _h.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 = React.useRef(null);
+    var stringSet = LocalizationContext.useLocalization().stringSet;
+    var _j = React.useState(null), timer = _j[0], setTimer = _j[1];
+    var _k = React.useState(''), searchString = _k[0], setSearchString = _k[1];
+    var _l = React.useState(''), lastSearchString = _l[0], setLastSearchString = _l[1];
+    var _m = React.useState(null), currentFocusedMember = _m[0], setCurrentFocusedMember = _m[1];
+    var _o = React.useState([]), currentMemberList = _o[0], setCurrentMemberList = _o[1];
+    React.useEffect(function () {
+        clearTimeout(timer);
+        setTimer(setTimeout(function () {
+            setSearchString(targetNickname);
+        }, DEBOUNCING_TIME));
+    }, [targetNickname]);
+    React.useEffect(function () {
+        if ((inputEvent === null || inputEvent === void 0 ? void 0 : inputEvent.key) === _const.MessageInputKeys.Enter) {
+            if (currentMemberList.length > 0) {
+                onUserItemClick(currentFocusedMember);
+            }
+        }
+        if ((inputEvent === null || inputEvent === void 0 ? void 0 : inputEvent.key) === _const.MessageInputKeys.ArrowUp) {
+            var currentUserIndex = currentMemberList.findIndex(function (member) { return (member === null || member === void 0 ? void 0 : member.userId) === (currentFocusedMember === null || currentFocusedMember === void 0 ? void 0 : currentFocusedMember.userId); });
+            if (0 < currentUserIndex) {
+                setCurrentFocusedMember(currentMemberList[currentUserIndex - 1]);
+                onFocusItemChange(currentMemberList[currentUserIndex - 1]);
+            }
+        }
+        if ((inputEvent === null || inputEvent === void 0 ? void 0 : inputEvent.key) === _const.MessageInputKeys.ArrowDown) {
+            var currentUserIndex = currentMemberList.findIndex(function (member) { return (member === null || member === void 0 ? void 0 : member.userId) === (currentFocusedMember === null || currentFocusedMember === void 0 ? void 0 : currentFocusedMember.userId); });
+            if (currentUserIndex < currentMemberList.length - 1) {
+                setCurrentFocusedMember(currentMemberList[currentUserIndex + 1]);
+                onFocusItemChange(currentMemberList[currentUserIndex + 1]);
+            }
+        }
+    }, [inputEvent]);
+    React.useEffect(function () {
+        if (lastSearchString && searchString.indexOf(lastSearchString) === 0 && currentMemberList.length === 0) {
+            // Don't need to request query again
+            return;
+        }
+        if (currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.isSuper) {
+            if (!(currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.createMemberListQuery)) {
+                logger.warning('SuggestedMentionList: Creating member list query failed');
+                return;
+            }
+        }
+        var fetcher = (currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.isSuper) ? fetchMembersFromQuery : fetchMembersFromChannel;
+        fetcher(currentUserId, currentChannel, maxSuggestionCount, searchString.slice(USER_MENTION_TEMP_CHAR.length))
+            .then(function (suggestingMembers) {
+            if (suggestingMembers.length < 1) {
+                logger.info('SuggestedMentionList: Fetched member list is empty');
+            }
+            else {
+                logger.info('SuggestedMentionList: Fetching member list succeeded', { memberList: suggestingMembers });
+                setCurrentFocusedMember(suggestingMembers[0]);
+            }
+            setLastSearchString(searchString);
+            onFetchUsers(suggestingMembers);
+            setCurrentMemberList(suggestingMembers);
+        })
+            .catch(function (error) {
+            if (error) {
+                logger.error('SuggestedMentionList: Fetching member list failed', error);
+            }
+        });
+    }, [
+        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.
+        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,
+        maxSuggestionCount,
+        currentUserId,
+        currentMemberList.length,
+        lastSearchString,
+    ]);
+    if (!ableAddMention && currentMemberList.length === 0) {
+        return null;
+    }
+    return (React.createElement("div", { className: "sendbird-mention-suggest-list ".concat(className), key: "sendbird-mention-suggest-list", ref: scrollRef },
+        ableAddMention
+            && (currentMemberList === null || currentMemberList === void 0 ? void 0 : currentMemberList.map(function (member) { return (React.createElement(SuggestedUserMentionItem, { key: (member === null || member === void 0 ? void 0 : member.userId) || uuid.uuidv4(), member: member, isFocused: (member === null || member === void 0 ? void 0 : member.userId) === (currentFocusedMember === null || currentFocusedMember === void 0 ? void 0 : currentFocusedMember.userId), parentScrollRef: scrollRef, onClick: function (_a) {
+                    var member = _a.member;
+                    onUserItemClick(member);
+                }, onMouseOver: function (_a) {
+                    var member = _a.member;
+                    setCurrentFocusedMember(member);
+                }, renderUserMentionItem: renderUserMentionItem })); })),
+        !ableAddMention && (React.createElement("div", { className: "sendbird-mention-suggest-list__notice-item" },
+            React.createElement(ui_Icon.default, { className: "sendbird-mention-suggest-list__notice-item__icon", type: ui_Icon.IconTypes.INFO, fillColor: ui_Icon.IconColors.ON_BACKGROUND_2, width: "20px", height: "20px" }),
+            React.createElement(ui_Label.Label, { className: "sendbird-mention-suggest-list__notice-item__text", type: ui_Label.LabelTypography.SUBTITLE_2, color: ui_Label.LabelColors.ONBACKGROUND_2 }, stringSet.MENTION_COUNT__OVER_LIMIT.replace('%d', String(maxMentionCount)))))));
+};
+
+exports.MAX_USER_MENTION_COUNT = MAX_USER_MENTION_COUNT;
+exports.MAX_USER_SUGGESTION_COUNT = MAX_USER_SUGGESTION_COUNT;
+exports.SuggestedMentionListView = SuggestedMentionListView;
+//# sourceMappingURL=bundle-WuJcM_O3.js.map

package/{chunks/bundle-ucXG1Py7.js.map → cjs/chunks/bundle-WuJcM_O3.js.map}

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