@sendbird/uikit-react 3.14.5 → 3.14.6

package/cjs/chunks/{bundle-WETElB-o.js → bundle-Cd0cyqgA.js}

@@ -1,12 +1,12 @@
 'use strict';
 
 var React = require('react');
-var ui_Modal = require('./bundle-DJ9gapN2.js');
-require('./bundle-C-r9vRgc.js');
-require('./bundle-Deao1Upp.js');
+var ui_Modal = require('./bundle-DW8u-n3u.js');
+require('./bundle-eTYC1RPT.js');
+require('./bundle-DY5rfl6W.js');
 var ui_Button = require('../ui/Button.js');
-var LocalizationContext = require('./bundle-B7wJ4Hqk.js');
-var stringFormatterUtils = require('./bundle-Bw_LvbLk.js');
+var LocalizationContext = require('./bundle-OWb8eJt-.js');
+var stringFormatterUtils = require('./bundle-LO6QlzTz.js');
 
 var RemoveMessageModalView = function (props) {
     var _a;
@@ -14,7 +14,7 @@ var RemoveMessageModalView = function (props) {
         /* noop */
     } : _b, onCancel = props.onCancel, message = props.message, deleteMessage = props.deleteMessage;
     var stringSet = React.useContext(LocalizationContext.LocalizationContext).stringSet;
-    return (React.createElement(ui_Modal.Modal, { type: ui_Button.ButtonTypes.DANGER, disabled: ((_a = message === null || message === void 0 ? void 0 : message.threadInfo) === null || _a === void 0 ? void 0 : _a.replyCount) > 0, onCancel: onCancel, onSubmit: function () {
+    return (React.createElement(ui_Modal.Modal, { type: ui_Button.ButtonTypes.DANGER, disabled: ((_a = message === null || message === void 0 ? void 0 : message.threadInfo) === null || _a === void 0 ? void 0 : _a.replyCount) ? message.threadInfo.replyCount > 0 : undefined, onCancel: onCancel, onSubmit: function () {
             if (message.isUserMessage() || message.isFileMessage() || message.isMultipleFilesMessage()) {
                 deleteMessage(message).then(function () {
                     // For other status such as PENDING, SCHEDULED, and CANCELED,
@@ -27,4 +27,4 @@ var RemoveMessageModalView = function (props) {
 };
 
 exports.RemoveMessageModalView = RemoveMessageModalView;
-//# sourceMappingURL=bundle-WETElB-o.js.map
+//# sourceMappingURL=bundle-Cd0cyqgA.js.map

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

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

package/cjs/chunks/{bundle-BEtlTF8Q.js → bundle-CliI7H5v.js}

@@ -1,9 +1,9 @@
 'use strict';
 
 var React = require('react');
-var pubSub_topics = require('./bundle-DpK1fr1j.js');
+var pubSub_topics = require('./bundle-7CEyuoln.js');
 var useSendbirdStateContext = require('../useSendbirdStateContext.js');
-var _tslib = require('./bundle-C-r9vRgc.js');
+var _tslib = require('./bundle-eTYC1RPT.js');
 
 exports.OpenChannelListFetchingStatus = void 0;
 (function (OpenChannelListFetchingStatus) {
@@ -99,7 +99,7 @@ function useFetchNextCallback(_a, _b) {
             });
             openChannelListQuery.next()
                 .then(function (channelList) {
-                callback(channelList, null);
+                callback(channelList, undefined);
                 logger.info('OpenChannelList|useFetchNextCallback: Succeeded fetching channels', channelList);
                 openChannelListDispatcher({
                     type: OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_SUCCESS,
@@ -107,7 +107,7 @@ function useFetchNextCallback(_a, _b) {
                 });
             })
                 .catch(function (err) {
-                callback(null, err);
+                callback(undefined, err);
                 logger.error('OpenChannelList|useFetchNextCallback: Failed fetching channels', err);
                 openChannelListDispatcher({
                     type: OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_FAILURE,
@@ -129,6 +129,7 @@ function createChannelListQuery(_a) {
     params.includeFrozen = true;
     if (openChannelListQuery) {
         Object.keys(openChannelListQuery).forEach(function (key) {
+            // @ts-ignore
             params[key] = openChannelListQuery[key];
         });
     }
@@ -145,46 +146,40 @@ function useSetupOpenChannelList(_a, _b) {
     var sdk = _a.sdk, sdkInitialized = _a.sdkInitialized, openChannelListQuery = _a.openChannelListQuery;
     var logger = _b.logger, openChannelListDispatcher = _b.openChannelListDispatcher;
     React.useEffect(function () {
-        var _a;
         if (sdkInitialized) {
             if (sdk === null || sdk === void 0 ? void 0 : sdk.openChannel) {
-                if ((_a = sdk === null || sdk === void 0 ? void 0 : sdk.openChannel) === null || _a === void 0 ? void 0 : _a.createOpenChannelListQuery) {
-                    logger.info('OpenChannelList|useSetupOpenChannelList: Setup OpenChannelList', { sdkInitialized: sdkInitialized });
-                    var channelListQuery = createChannelListQuery({
-                        sdk: sdk,
-                        logger: logger,
-                        openChannelListQuery: openChannelListQuery,
-                        openChannelListDispatcher: openChannelListDispatcher,
-                        logMessage: 'OpenChannelList|useSetupOpenChannelList: Succeeded create channelListQuery',
+                logger.info('OpenChannelList|useSetupOpenChannelList: Setup OpenChannelList', { sdkInitialized: sdkInitialized });
+                var channelListQuery = createChannelListQuery({
+                    sdk: sdk,
+                    logger: logger,
+                    openChannelListQuery: openChannelListQuery,
+                    openChannelListDispatcher: openChannelListDispatcher,
+                    logMessage: 'OpenChannelList|useSetupOpenChannelList: Succeeded create channelListQuery',
+                });
+                if (channelListQuery === null || channelListQuery === void 0 ? void 0 : channelListQuery.hasNext) {
+                    logger.info('OpenChannelList|useSetupOpenChannelList: Fetch channels');
+                    openChannelListDispatcher({
+                        type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_START,
+                        payload: null,
                     });
-                    if (channelListQuery === null || channelListQuery === void 0 ? void 0 : channelListQuery.hasNext) {
-                        logger.info('OpenChannelList|useSetupOpenChannelList: Fetch channels');
+                    channelListQuery.next()
+                        .then(function (channelList) {
+                        logger.info('OpenChannelList|useSetupOpenChannelList: Succeeded fetching channels', channelList);
                         openChannelListDispatcher({
-                            type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_START,
-                            payload: null,
+                            type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_SUCCESS,
+                            payload: channelList,
                         });
-                        channelListQuery.next()
-                            .then(function (channelList) {
-                            logger.info('OpenChannelList|useSetupOpenChannelList: Succeeded fetching channels', channelList);
-                            openChannelListDispatcher({
-                                type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_SUCCESS,
-                                payload: channelList,
-                            });
-                        })
-                            .catch(function (err) {
-                            logger.error('OpenChannelList|useSetupOpenChannelList: Failed fetching channels', err);
-                            openChannelListDispatcher({
-                                type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_FAILURE,
-                                payload: null,
-                            });
+                    })
+                        .catch(function (err) {
+                        logger.error('OpenChannelList|useSetupOpenChannelList: Failed fetching channels', err);
+                        openChannelListDispatcher({
+                            type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_FAILURE,
+                            payload: null,
                         });
-                    }
-                    else {
-                        logger.info('OpenChannelList|useSetupOpenChannelList: There is no more channels');
-                    }
+                    });
                 }
                 else {
-                    logger.warning('OpenChannelList|useSetupOpenChannelList: createOpenChannelListQuery is not included in the openChannel', sdk.openChannel);
+                    logger.info('OpenChannelList|useSetupOpenChannelList: There is no more channels');
                 }
             }
             else {
@@ -258,19 +253,11 @@ function useRefreshOpenChannelList(_a, _b) {
     }, [sdkInitialized, openChannelListQuery]);
 }
 
-var OpenChannelListContext = React.createContext({
-    onChannelSelected: null,
-    currentChannel: null,
-    allChannels: [],
-    fetchingStatus: exports.OpenChannelListFetchingStatus.EMPTY,
-    customOpenChannelListQuery: {},
-    fetchNextChannels: null,
-    refreshOpenChannelList: null,
-    openChannelListDispatcher: null,
-    logger: null,
-});
+var OpenChannelListContext = React.createContext(null);
 function useOpenChannelListContext() {
     var context = React.useContext(OpenChannelListContext);
+    if (!context)
+        throw new Error('OpenChannelListContext not found. Use within the OpenChannelList module.');
     return context;
 }
 var OpenChannelListProvider = function (_a) {
@@ -281,9 +268,7 @@ var OpenChannelListProvider = function (_a) {
     var logger = config.logger, pubSub = config.pubSub;
     var sdk = ((_b = stores === null || stores === void 0 ? void 0 : stores.sdkStore) === null || _b === void 0 ? void 0 : _b.sdk) || null;
     var sdkInitialized = ((_c = stores === null || stores === void 0 ? void 0 : stores.sdkStore) === null || _c === void 0 ? void 0 : _c.initialized) || false;
-    var customOpenChannelListQuery = React.useMemo(function () {
-        return (queries === null || queries === void 0 ? void 0 : queries.openChannelListQuery) || null;
-    }, [queries === null || queries === void 0 ? void 0 : queries.openChannelListQuery]);
+    var customOpenChannelListQuery = queries === null || queries === void 0 ? void 0 : queries.openChannelListQuery;
     // dux
     var _e = React.useReducer(reducer, openChannelListInitialState), openChannelListStore = _e[0], openChannelListDispatcher = _e[1];
     var allChannels = openChannelListStore.allChannels, currentChannel = openChannelListStore.currentChannel, fetchingStatus = openChannelListStore.fetchingStatus, channelListQuery = openChannelListStore.channelListQuery;
@@ -298,22 +283,15 @@ var OpenChannelListProvider = function (_a) {
     });
     // Events & PubSub
     React.useEffect(function () {
-        var subscriber = (pubSub === null || pubSub === void 0 ? void 0 : pubSub.subscribe) ? new Map() : null;
-        subscriber === null || subscriber === void 0 ? void 0 : subscriber.set(pubSub_topics.pubSubTopics.UPDATE_OPEN_CHANNEL, pubSub === null || pubSub === void 0 ? void 0 : pubSub.subscribe(pubSub_topics.pubSubTopics.UPDATE_OPEN_CHANNEL, function (channel) {
+        var subscriber = new Map();
+        subscriber.set(pubSub_topics.pubSubTopics.UPDATE_OPEN_CHANNEL, pubSub.subscribe(pubSub_topics.pubSubTopics.UPDATE_OPEN_CHANNEL, function (channel) {
             openChannelListDispatcher({
                 type: OpenChannelListActionTypes$1.UPDATE_OPEN_CHANNEL,
                 payload: channel,
             });
         }));
         return function () {
-            subscriber === null || subscriber === void 0 ? void 0 : subscriber.forEach(function (s) {
-                try {
-                    s.remove();
-                }
-                catch (_a) {
-                    //
-                }
-            });
+            subscriber.forEach(function (it) { return it.remove(); });
         };
     }, [sdkInitialized, pubSub]);
     // Fetch next channels by scroll event
@@ -357,4 +335,4 @@ exports.OpenChannelListActionTypes = OpenChannelListActionTypes$1;
 exports.OpenChannelListProvider = OpenChannelListProvider;
 exports.OpenChannelListProvider$1 = OpenChannelListProvider$1;
 exports.useOpenChannelListContext = useOpenChannelListContext;
-//# sourceMappingURL=bundle-BEtlTF8Q.js.map
+//# sourceMappingURL=bundle-CliI7H5v.js.map

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

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

package/cjs/chunks/{bundle-BCt-Rzil.js → bundle-CoJbL3ob.js}

@@ -1,12 +1,12 @@
 'use strict';
 
 var React = require('react');
-var index = require('./bundle-Cw7xe6J1.js');
-var tokenize = require('./bundle-DFVUnSWq.js');
+var index = require('./bundle-DrYI_bNa.js');
+var tokenize = require('./bundle-B1Ql7yM0.js');
 var Message_context = require('../Message/context.js');
 var ui_MentionLabel = require('../ui/MentionLabel.js');
 var ui_LinkLabel = require('../ui/LinkLabel.js');
-var ui_Label = require('./bundle-Deao1Upp.js');
+var ui_Label = require('./bundle-DY5rfl6W.js');
 
 // this function is used to generate a unique key for token in message
 // it changes with updated time and index
@@ -35,4 +35,4 @@ function TextFragment(_a) {
 }
 
 exports.TextFragment = TextFragment;
-//# sourceMappingURL=bundle-BCt-Rzil.js.map
+//# sourceMappingURL=bundle-CoJbL3ob.js.map

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

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

package/cjs/chunks/{bundle-B2KKkvdj.js → bundle-CuOOXDK0.js}

@@ -12,4 +12,4 @@ exports.ThreadReplySelectType = void 0;
 exports.MAX_USER_MENTION_COUNT = MAX_USER_MENTION_COUNT;
 exports.MAX_USER_SUGGESTION_COUNT = MAX_USER_SUGGESTION_COUNT;
 exports.USER_MENTION_TEMP_CHAR = USER_MENTION_TEMP_CHAR;
-//# sourceMappingURL=bundle-B2KKkvdj.js.map
+//# sourceMappingURL=bundle-CuOOXDK0.js.map

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

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

package/cjs/chunks/{bundle-LLV3t4--.js → bundle-D1Ka8I9e.js}

@@ -2,8 +2,8 @@
 
 var SendbirdChat = require('@sendbird/chat');
 var React = require('react');
-var uuid = require('./bundle-Ub33KGva.js');
-var _tslib = require('./bundle-C-r9vRgc.js');
+var uuid = require('./bundle-YRiE_c63.js');
+var _tslib = require('./bundle-eTYC1RPT.js');
 
 function useOnlineStatus(sdk, logger) {
     var _a, _b;
@@ -77,7 +77,7 @@ function useOnlineStatus(sdk, logger) {
         var body = document.querySelector('body');
         if (!isOnline && !(sdk === null || sdk === void 0 ? void 0 : sdk.isCacheEnabled)) {
             try {
-                body.classList.add('sendbird__offline');
+                body === null || body === void 0 ? void 0 : body.classList.add('sendbird__offline');
                 logger.info('Added class sendbird__offline to body');
             }
             catch (e) {
@@ -86,7 +86,7 @@ function useOnlineStatus(sdk, logger) {
         }
         else {
             try {
-                body.classList.remove('sendbird__offline');
+                body === null || body === void 0 ? void 0 : body.classList.remove('sendbird__offline');
                 logger.info('Removed class sendbird__offline from body');
             }
             catch (e) {
@@ -199,4 +199,4 @@ exports.schedulerFactory = schedulerFactory;
 exports.useMarkAsDeliveredScheduler = useMarkAsDeliveredScheduler;
 exports.useOnlineStatus = useOnlineStatus;
 exports.useUnmount = useUnmount;
-//# sourceMappingURL=bundle-LLV3t4--.js.map
+//# sourceMappingURL=bundle-D1Ka8I9e.js.map

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

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

package/cjs/chunks/{bundle-DGJX80zy.js → bundle-D1mguvwi.js}

@@ -5,9 +5,10 @@ var ui_PlaybackTime = require('../ui/PlaybackTime.js');
 var ui_ProgressBar = require('../ui/ProgressBar.js');
 var ui_TextButton = require('../ui/TextButton.js');
 var ui_Icon = require('../ui/Icon.js');
-var ui_Label = require('./bundle-Deao1Upp.js');
-var LocalizationContext = require('./bundle-B7wJ4Hqk.js');
-var consts = require('./bundle-Ca7xeBTO.js');
+var ui_Label = require('./bundle-DY5rfl6W.js');
+var LocalizationContext = require('./bundle-OWb8eJt-.js');
+var consts = require('./bundle-BNzVVkzd.js');
+var utils = require('./bundle-DOoshvnj.js');
 
 /* eslint-disable no-redeclare */
 var VoiceMessageInputStatus = {
@@ -35,7 +36,7 @@ var ControlerIcon = function (_a) {
                 React.createElement("div", { className: "sendbird-controler-icon pause-icon-inner" })));
         }
         default:
-            return null;
+            return React.createElement(React.Fragment, null);
     }
 };
 
@@ -59,14 +60,14 @@ var VoiceMessageInput = function (_a) {
     var handleOnCancelClick = function () {
         var currentTime = Date.now();
         if (currentTime - lastClickTime > consts.VOICE_RECORDER_CLICK_BUFFER_TIME) {
-            onCancelClick();
+            onCancelClick === null || onCancelClick === void 0 ? void 0 : onCancelClick();
             setLastClickTime(currentTime);
         }
     };
     var handleOnControlClick = React.useCallback(function () {
         var currentTime = Date.now();
         if (currentTime - lastClickTime > consts.VOICE_RECORDER_CLICK_BUFFER_TIME) {
-            onControlClick(currentType);
+            onControlClick === null || onControlClick === void 0 ? void 0 : onControlClick(currentType);
             setLastClickTime(currentTime);
         }
     }, [currentType]);
@@ -74,7 +75,7 @@ var VoiceMessageInput = function (_a) {
         var currentTime = Date.now();
         if (currentTime - lastClickTime > consts.VOICE_RECORDER_CLICK_BUFFER_TIME) {
             if (!isSendButtonDisabled) {
-                onSubmitClick();
+                onSubmitClick === null || onSubmitClick === void 0 ? void 0 : onSubmitClick();
             }
             setLastClickTime(currentTime);
         }
@@ -90,10 +91,10 @@ var VoiceMessageInput = function (_a) {
                 React.createElement(ui_Label.Label, { type: ui_Label.LabelTypography.BUTTON_1, color: ui_Label.LabelColors.PRIMARY }, stringSet.BUTTON__CANCEL))),
             (renderControlButton === null || renderControlButton === void 0 ? void 0 : renderControlButton(currentType)) || (React.createElement("div", { className: "sendbird-voice-message-input__controler__main", onClick: handleOnControlClick },
                 React.createElement(ControlerIcon, { inputState: currentType }))),
-            (renderSubmitButton === null || renderSubmitButton === void 0 ? void 0 : renderSubmitButton()) || (React.createElement("div", { className: "sendbird-voice-message-input__controler__submit ".concat(isSendButtonDisabled ? 'voice-message--disabled' : ''), onClick: handleOnSubmitClick },
+            (renderSubmitButton === null || renderSubmitButton === void 0 ? void 0 : renderSubmitButton()) || (React.createElement("div", { className: utils.classnames('sendbird-voice-message-input__controler__submit', isSendButtonDisabled && 'voice-message--disabled'), onClick: handleOnSubmitClick },
                 React.createElement(ui_Icon.default, { width: "19px", height: "19px", type: ui_Icon.IconTypes.SEND, fillColor: isSendButtonDisabled ? ui_Icon.IconColors.ON_BACKGROUND_4 : ui_Icon.IconColors.CONTENT }))))));
 };
 
 exports.VoiceMessageInput = VoiceMessageInput;
 exports.VoiceMessageInputStatus = VoiceMessageInputStatus;
-//# sourceMappingURL=bundle-DGJX80zy.js.map
+//# sourceMappingURL=bundle-D1mguvwi.js.map

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

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

package/cjs/chunks/{bundle-SfusZfMJ.js → bundle-D3BhVTZt.js}

@@ -3,4 +3,4 @@
 var TEXT_MESSAGE_BODY_CLASSNAME = 'sendbird-text-message-item-body';
 
 exports.TEXT_MESSAGE_BODY_CLASSNAME = TEXT_MESSAGE_BODY_CLASSNAME;
-//# sourceMappingURL=bundle-SfusZfMJ.js.map
+//# sourceMappingURL=bundle-D3BhVTZt.js.map

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

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

package/cjs/chunks/{bundle-DPrTZ-1L.js → bundle-D7rSRN-8.js}

@@ -1,13 +1,13 @@
 'use strict';
 
-var _tslib = require('./bundle-C-r9vRgc.js');
+var _tslib = require('./bundle-eTYC1RPT.js');
 var React = require('react');
 var ui_Icon = require('../ui/Icon.js');
 var ui_ChannelAvatar = require('../ui/ChannelAvatar.js');
-var utils = require('./bundle-B2h5VMZ6.js');
-var MediaQueryContext = require('./bundle-CLNUkVC8.js');
+var utils = require('./bundle-B2WuxwoH.js');
+var MediaQueryContext = require('./bundle-OIKGVRus.js');
 var useSendbirdStateContext = require('../useSendbirdStateContext.js');
-var LocalizationContext = require('./bundle-B7wJ4Hqk.js');
+var LocalizationContext = require('./bundle-OWb8eJt-.js');
 var ui_Header = require('../ui/Header.js');
 
 var GroupChannelHeaderView = function (_a) {
@@ -29,4 +29,4 @@ var GroupChannelHeaderView = function (_a) {
 };
 
 exports.GroupChannelHeaderView = GroupChannelHeaderView;
-//# sourceMappingURL=bundle-DPrTZ-1L.js.map
+//# sourceMappingURL=bundle-D7rSRN-8.js.map

package/cjs/chunks/bundle-D7rSRN-8.js.map

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

package/cjs/chunks/{bundle-BNVygboA.js → bundle-DAEHB1AV.js}

@@ -5,7 +5,7 @@ var GroupChannelList_components_GroupChannelListHeader = require('../GroupChanne
 var useSendbirdStateContext = require('../useSendbirdStateContext.js');
 var EditUserProfile = require('../EditUserProfile.js');
 var ui_PlaceHolder = require('../ui/PlaceHolder.js');
-var index = require('./bundle-hXD0NDZt.js');
+var index = require('./bundle-DQu5RJ2y.js');
 
 var GroupChannelListUIView = function (_a) {
     var renderHeader = _a.renderHeader, renderPlaceHolderError = _a.renderPlaceHolderError, renderPlaceHolderLoading = _a.renderPlaceHolderLoading, renderPlaceHolderEmptyList = _a.renderPlaceHolderEmptyList, onChangeTheme = _a.onChangeTheme, onUserProfileUpdated = _a.onUserProfileUpdated, allowProfileEdit = _a.allowProfileEdit, channels = _a.channels, onLoadMore = _a.onLoadMore, initialized = _a.initialized, renderChannel = _a.renderChannel, renderAddChannel = _a.renderAddChannel;
@@ -56,7 +56,7 @@ var GroupChannelListUIView = function (_a) {
 var ChannelListComponent = function (props) {
     var data = props.data, renderItem = props.renderItem, onLoadMore = props.onLoadMore, placeholderLoading = props.placeholderLoading, placeholderError = props.placeholderError, placeholderEmpty = props.placeholderEmpty;
     var onScroll = index.useOnScrollPositionChangeDetector({
-        onReachedBottom: function () { return onLoadMore(); },
+        onReachedBottom: function () { return onLoadMore === null || onLoadMore === void 0 ? void 0 : onLoadMore(); },
     });
     return (React.createElement("div", { className: 'sendbird-channel-list__body', onScroll: onScroll },
         placeholderError,
@@ -66,4 +66,4 @@ var ChannelListComponent = function (props) {
 };
 
 exports.GroupChannelListUIView = GroupChannelListUIView;
-//# sourceMappingURL=bundle-BNVygboA.js.map
+//# sourceMappingURL=bundle-DAEHB1AV.js.map

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

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

package/cjs/chunks/{bundle-dr9zoU1D.js → bundle-DMUz-Xui.js}

@@ -1,15 +1,16 @@
 'use strict';
 
 var React = require('react');
-var ui_Label = require('./bundle-Deao1Upp.js');
+var ui_Label = require('./bundle-DY5rfl6W.js');
 var ui_Icon = require('../ui/Icon.js');
-var ui_Avatar = require('./bundle-C0ZNrrcl.js');
-var LocalizationContext = require('./bundle-B7wJ4Hqk.js');
-var uuid = require('./bundle-Ub33KGva.js');
+var ui_Avatar = require('./bundle-C_8UQBXr.js');
+var LocalizationContext = require('./bundle-OWb8eJt-.js');
+var uuid = require('./bundle-YRiE_c63.js');
+var utils = require('./bundle-DOoshvnj.js');
 var useSendbirdStateContext = require('../useSendbirdStateContext.js');
-var _const$1 = require('./bundle-B2KKkvdj.js');
-var _const = require('./bundle-C4UzGGy_.js');
-var _tslib = require('./bundle-C-r9vRgc.js');
+var _const$1 = require('./bundle-CuOOXDK0.js');
+var _const = require('./bundle-wz_O1vyk.js');
+var _tslib = require('./bundle-eTYC1RPT.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;
@@ -30,7 +31,7 @@ function SuggestedUserMentionItem(props) {
     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 },
+    return (React.createElement("div", { className: utils.classnames('sendbird-mention-suggest-list__user-item', 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)));
@@ -85,29 +86,29 @@ var SuggestedMentionListView = function (props) {
     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);
+        clearTimeout(timer !== null && timer !== void 0 ? timer : undefined);
         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 (currentFocusedMember && currentMemberList.length > 0) {
+                onUserItemClick === null || onUserItemClick === void 0 ? void 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]);
+                onFocusItemChange === null || onFocusItemChange === void 0 ? void 0 : 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]);
+                onFocusItemChange === null || onFocusItemChange === void 0 ? void 0 : onFocusItemChange(currentMemberList[currentUserIndex + 1]);
             }
         }
     }, [inputEvent]);
@@ -133,7 +134,7 @@ var SuggestedMentionListView = function (props) {
                 setCurrentFocusedMember(suggestingMembers[0]);
             }
             setLastSearchString(searchString);
-            onFetchUsers(suggestingMembers);
+            onFetchUsers === null || onFetchUsers === void 0 ? void 0 : onFetchUsers(suggestingMembers);
             setCurrentMemberList(suggestingMembers);
         })
             .catch(function (error) {
@@ -159,7 +160,7 @@ var SuggestedMentionListView = function (props) {
         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);
+                    onUserItemClick === null || onUserItemClick === void 0 ? void 0 : onUserItemClick(member);
                 }, onMouseOver: function (_a) {
                     var member = _a.member;
                     setCurrentFocusedMember(member);
@@ -170,4 +171,4 @@ var SuggestedMentionListView = function (props) {
 };
 
 exports.SuggestedMentionListView = SuggestedMentionListView;
-//# sourceMappingURL=bundle-dr9zoU1D.js.map
+//# sourceMappingURL=bundle-DMUz-Xui.js.map

package/cjs/chunks/{bundle-dr9zoU1D.js.map → bundle-DMUz-Xui.js.map}

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

package/cjs/chunks/{bundle-CLte647H.js → bundle-DOoshvnj.js}

@@ -41,4 +41,4 @@ exports.deleteNullish = deleteNullish;
 exports.isMobileIOS = isMobileIOS;
 exports.noop = noop;
 exports.openURL = openURL;
-//# sourceMappingURL=bundle-CLte647H.js.map
+//# sourceMappingURL=bundle-DOoshvnj.js.map

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

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

package/cjs/chunks/{bundle-hXD0NDZt.js → bundle-DQu5RJ2y.js}

@@ -1,10 +1,10 @@
 'use strict';
 
 var React = require('react');
-var consts = require('./bundle-Ca7xeBTO.js');
-var utils = require('./bundle-D1X4MKLh.js');
+var consts = require('./bundle-BNzVVkzd.js');
+var utils = require('./bundle-BBsKv3Vz.js');
 var uikitTools = require('@sendbird/uikit-tools');
-var useThrottleCallback = require('./bundle-BMN1aDia.js');
+var useThrottleCallback = require('./bundle-Bvsx1m1J.js');
 
 var BUFFER_DELAY = 100;
 function useOnScrollPositionChangeDetector(params) {
@@ -57,4 +57,4 @@ function useOnScrollPositionChangeDetectorWithRef(scrollRef, params) {
 
 exports.useOnScrollPositionChangeDetector = useOnScrollPositionChangeDetector;
 exports.useOnScrollPositionChangeDetectorWithRef = useOnScrollPositionChangeDetectorWithRef;
-//# sourceMappingURL=bundle-hXD0NDZt.js.map
+//# sourceMappingURL=bundle-DQu5RJ2y.js.map

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

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

package/cjs/chunks/{bundle-Cc89qdjT.js → bundle-DSLFcE0C.js}

@@ -1,10 +1,10 @@
 'use strict';
 
 var React = require('react');
-var pubSub_topics = require('./bundle-DpK1fr1j.js');
-var utils = require('./bundle-D1X4MKLh.js');
+var pubSub_topics = require('./bundle-7CEyuoln.js');
+var utils = require('./bundle-BBsKv3Vz.js');
 require('../utils/message/getOutgoingMessageState.js');
-var consts = require('./bundle-Ca7xeBTO.js');
+var consts = require('./bundle-BNzVVkzd.js');
 
 var getNicknamesMapFromMembers = function (members) {
     if (members === void 0) { members = []; }
@@ -60,7 +60,9 @@ var scrollIntoLast = function (intialTry) {
     try {
         var scrollDOM = document.querySelector('.sendbird-thread-ui--scroll');
         // eslint-disable-next-line no-multi-assign
-        scrollDOM.scrollTop = scrollDOM.scrollHeight;
+        if (scrollDOM) {
+            scrollDOM.scrollTop = scrollDOM.scrollHeight;
+        }
     }
     catch (error) {
         setTimeout(function () {
@@ -103,8 +105,7 @@ var useSendMultipleFilesMessage = function (_a, _b) {
             }
             logger.info('Channel: Start sending MFM', { messageParams: messageParams });
             try {
-                currentChannel.sendMultipleFilesMessage(messageParams)
-                    .onFileUploaded(function (requestId, index, uploadableFileInfo, error) {
+                currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.sendMultipleFilesMessage(messageParams).onFileUploaded(function (requestId, index, uploadableFileInfo, error) {
                     logger.info('Channel: onFileUploaded during sending MFM', {
                         requestId: requestId,
                         index: index,
@@ -121,8 +122,7 @@ var useSendMultipleFilesMessage = function (_a, _b) {
                         },
                         publishingModules: publishingModules,
                     });
-                })
-                    .onPending(function (pendingMessage) {
+                }).onPending(function (pendingMessage) {
                     logger.info('Channel: in progress of sending MFM', { pendingMessage: pendingMessage, fileInfoList: messageParams.fileInfoList });
                     pubSub.publish(pubSub_topics.pubSubTopics.SEND_MESSAGE_START, {
                         message: pendingMessage,
@@ -137,8 +137,7 @@ var useSendMultipleFilesMessage = function (_a, _b) {
                             scrollIntoLast(0);
                         }
                     }, consts.SCROLL_BOTTOM_DELAY_FOR_SEND);
-                })
-                    .onFailed(function (error, failedMessage) {
+                }).onFailed(function (error, failedMessage) {
                     logger.error('Channel: Sending MFM failed.', { error: error, failedMessage: failedMessage });
                     pubSub.publish(pubSub_topics.pubSubTopics.SEND_MESSAGE_FAILED, {
                         channel: currentChannel,
@@ -146,8 +145,7 @@ var useSendMultipleFilesMessage = function (_a, _b) {
                         publishingModules: publishingModules,
                     });
                     reject(error);
-                })
-                    .onSucceeded(function (succeededMessage) {
+                }).onSucceeded(function (succeededMessage) {
                     logger.info('Channel: Sending voice message success!', { succeededMessage: succeededMessage });
                     pubSub.publish(pubSub_topics.pubSubTopics.SEND_FILE_MESSAGE, {
                         channel: currentChannel,
@@ -176,4 +174,4 @@ exports.getParentMessageFrom = getParentMessageFrom;
 exports.isAboutSame = isAboutSame;
 exports.scrollIntoLast = scrollIntoLast;
 exports.useSendMultipleFilesMessage = useSendMultipleFilesMessage;
-//# sourceMappingURL=bundle-Cc89qdjT.js.map
+//# sourceMappingURL=bundle-DSLFcE0C.js.map