@sendbird/uikit-react 3.14.5 → 3.14.7-rc-1

package/cjs/chunks/{bundle-8IuV93EV.js → bundle-Q0M503xu.js}

@@ -1,30 +1,26 @@
 'use strict';
 
 var React = require('react');
-var UserProfileContext = require('./bundle-D7v4i_Ae.js');
-var _tslib = require('./bundle-C-r9vRgc.js');
-var compareIds = require('./bundle-CcmMvK6l.js');
-var pubSub_topics = require('./bundle-DpK1fr1j.js');
+var UserProfileContext = require('./bundle-Ch54AIEU.js');
+var _tslib = require('./bundle-BGmEoqIq.js');
+var compareIds = require('./bundle-DHTMMHln.js');
+var pubSub_topics = require('./bundle-C9goSwm_.js');
 var SendbirdChat = require('@sendbird/chat');
 var openChannel = require('@sendbird/chat/openChannel');
-var uuid = require('./bundle-Ub33KGva.js');
-var compressImages = require('./bundle-cl2q8NwQ.js');
+var uuid = require('./bundle-nJ_H0gk1.js');
+var compressImages = require('./bundle-JqwDNyBE.js');
 var useSendbirdStateContext = require('../useSendbirdStateContext.js');
-var ui_Modal = require('./bundle-DJ9gapN2.js');
-var LocalizationContext = require('./bundle-B7wJ4Hqk.js');
-var consts = require('./bundle-Ca7xeBTO.js');
-require('./bundle-Deao1Upp.js');
+var ui_Modal = require('./bundle-CkSDsWpR.js');
+var LocalizationContext = require('./bundle-u9XWE6Rm.js');
+var consts = require('./bundle-B9KKI197.js');
+require('./bundle-DgWaY7S0.js');
 var ui_Button = require('../ui/Button.js');
 
 var shouldFetchMore = function (messageLength, maxMessages) {
     if (typeof maxMessages !== 'number') {
         return true;
     }
-    if (typeof maxMessages === 'number'
-        && maxMessages > messageLength) {
-        return true;
-    }
-    return false;
+    return maxMessages > messageLength;
 };
 /* eslint-disable default-param-last */
 var scrollIntoLast = function (initialTry, scrollRef) {
@@ -37,7 +33,9 @@ var scrollIntoLast = function (initialTry, scrollRef) {
     try {
         var scrollDOM = (scrollRef === null || scrollRef === void 0 ? void 0 : scrollRef.current) || document.querySelector('.sendbird-openchannel-conversation-scroll__container__item-container');
         // eslint-disable-next-line no-multi-assign
-        scrollDOM.scrollTop = scrollDOM.scrollHeight;
+        if (scrollDOM) {
+            scrollDOM.scrollTop = scrollDOM.scrollHeight;
+        }
     }
     catch (error) {
         setTimeout(function () {
@@ -62,7 +60,9 @@ var isOperator = function (openChannel, userId) {
     return true;
 };
 var isDisabledBecauseFrozen = function (openChannel, userId) {
-    var isFrozen = openChannel === null || openChannel === void 0 ? void 0 : openChannel.isFrozen;
+    if (!openChannel)
+        return false;
+    var isFrozen = openChannel.isFrozen;
     return isFrozen && !isOperator(openChannel, userId);
 };
 var isDisabledBecauseMuted = function (mutedParticipantIds, userId) {
@@ -127,7 +127,7 @@ var ON_META_COUNTERS_DELETED = 'ON_META_COUNTERS_DELETED';
 var ON_MENTION_RECEIVED = 'ON_MENTION_RECEIVED';
 
 function reducer(state, action) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     switch (action.type) {
         case RESET_MESSAGES: {
             return _tslib.__assign(_tslib.__assign({}, state), { allMessages: [] });
@@ -158,13 +158,13 @@ function reducer(state, action) {
         case GET_PREV_MESSAGES_SUCESS:
         case GET_PREV_MESSAGES_FAIL: {
             var isFailed = (action.type === GET_PREV_MESSAGES_FAIL);
-            var _d = action.payload, _e = _d.currentOpenChannel, currentOpenChannel = _e === void 0 ? {} : _e, _f = _d.messages, messages = _f === void 0 ? [] : _f, hasMore = _d.hasMore, lastMessageTimestamp = _d.lastMessageTimestamp;
+            var _j = action.payload, _k = _j.currentOpenChannel, currentOpenChannel = _k === void 0 ? {} : _k, _l = _j.messages, messages = _l === void 0 ? [] : _l, hasMore = _j.hasMore, lastMessageTimestamp = _j.lastMessageTimestamp;
             var actionChannelUrl = currentOpenChannel.url;
-            var receivedMessages_1 = isFailed ? [] : messages;
+            var receivedMessages_1 = (isFailed ? [] : messages);
             var _hasMore = isFailed ? false : hasMore;
             var _lastMessageTimestamp = isFailed ? 0 : lastMessageTimestamp;
             var stateChannel = state.currentOpenChannel;
-            var stateChannelUrl = stateChannel.url;
+            var stateChannelUrl = stateChannel === null || stateChannel === void 0 ? void 0 : stateChannel.url;
             if (actionChannelUrl !== stateChannelUrl) {
                 return state;
             }
@@ -175,8 +175,8 @@ function reducer(state, action) {
             return _tslib.__assign(_tslib.__assign({}, state), { loading: false, initialized: true, hasMore: _hasMore, lastMessageTimestamp: _lastMessageTimestamp, allMessages: _tslib.__spreadArray(_tslib.__spreadArray([], receivedMessages_1, true), filteredAllMessages, true) });
         }
         case SENDING_MESSAGE_START: {
-            var _g = action.payload, message_1 = _g.message, channel = _g.channel;
-            if ((channel === null || channel === void 0 ? void 0 : channel.url) !== state.currentOpenChannel.url
+            var _m = action.payload, message_1 = _m.message, channel = _m.channel;
+            if ((channel === null || channel === void 0 ? void 0 : channel.url) !== ((_c = state.currentOpenChannel) === null || _c === void 0 ? void 0 : _c.url)
                 || state.allMessages.some(function (m) { return m.reqId === message_1.reqId; })
             // Handing failed first than sending start issue
             ) {
@@ -206,7 +206,7 @@ function reducer(state, action) {
         }
         case TRIM_MESSAGE_LIST: {
             var allMessages = state.allMessages;
-            var messageLimit = (_c = action.payload) === null || _c === void 0 ? void 0 : _c.messageLimit;
+            var messageLimit = (_d = action.payload) === null || _d === void 0 ? void 0 : _d.messageLimit;
             if (messageLimit
                 && messageLimit > 0
                 && (allMessages === null || allMessages === void 0 ? void 0 : allMessages.length) > messageLimit) {
@@ -218,7 +218,7 @@ function reducer(state, action) {
         case RESENDING_MESSAGE_START: {
             var eventedChannel = action.payload.channel;
             var resentMessage_1 = action.payload.message;
-            if (eventedChannel.url !== state.currentOpenChannel.url) {
+            if (eventedChannel.url !== ((_e = state.currentOpenChannel) === null || _e === void 0 ? void 0 : _e.url)) {
                 return state;
             }
             return _tslib.__assign(_tslib.__assign({}, state), { allMessages: state.allMessages.map(function (m) { return (compareIds.compareIds(m.reqId, resentMessage_1.reqId) ? resentMessage_1 : m); }) });
@@ -226,7 +226,7 @@ function reducer(state, action) {
         case FETCH_PARTICIPANT_LIST: {
             var eventedChannel = action.payload.channel;
             var fetchedParticipantList = action.payload.users;
-            if (eventedChannel.url !== state.currentOpenChannel.url) {
+            if (eventedChannel.url !== ((_f = state.currentOpenChannel) === null || _f === void 0 ? void 0 : _f.url)) {
                 return state;
             }
             return _tslib.__assign(_tslib.__assign({}, state), { participants: _tslib.__spreadArray(_tslib.__spreadArray([], state.participants, true), fetchedParticipantList, true) });
@@ -234,7 +234,7 @@ function reducer(state, action) {
         case FETCH_BANNED_USER_LIST: {
             var eventedChannel = action.payload.channel;
             var fetchedBannedUserList = action.payload.users;
-            if ((eventedChannel.url !== state.currentOpenChannel.url)
+            if ((eventedChannel.url !== ((_g = state.currentOpenChannel) === null || _g === void 0 ? void 0 : _g.url))
                 || !(fetchedBannedUserList.every(function (user) { return typeof user.userId === 'string'; }))) {
                 return state;
             }
@@ -243,7 +243,7 @@ function reducer(state, action) {
         case FETCH_MUTED_USER_LIST: {
             var eventedChannel = action.payload.channel;
             var fetchedMutedUserList = action.payload.users;
-            if ((eventedChannel.url !== state.currentOpenChannel.url)
+            if ((eventedChannel.url !== ((_h = state.currentOpenChannel) === null || _h === void 0 ? void 0 : _h.url))
                 || !(fetchedMutedUserList.every(function (user) { return typeof user.userId === 'string'; }))) {
                 return state;
             }
@@ -254,7 +254,7 @@ function reducer(state, action) {
             var eventedChannel = action.payload.channel;
             var receivedMessage = action.payload.message;
             var currentOpenChannel = state.currentOpenChannel;
-            if (!compareIds.compareIds(eventedChannel.url, currentOpenChannel.url)
+            if (!compareIds.compareIds(eventedChannel.url, currentOpenChannel === null || currentOpenChannel === void 0 ? void 0 : currentOpenChannel.url)
                 || (!(state.allMessages.map(function (message) { return message.messageId; }).indexOf(receivedMessage.messageId) < 0))) {
                 return state;
             }
@@ -771,6 +771,7 @@ function useInitialMessagesFetch(_a, _b) {
             };
             if (userFilledMessageListParams) {
                 Object.keys(userFilledMessageListParams).forEach(function (key) {
+                    // @ts-ignore
                     messageListParams_1[key] = userFilledMessageListParams[key];
                 });
                 logger.info('OpenChannel | useInitialMessagesFetch: Used customizedMessageListParams');
@@ -823,12 +824,13 @@ function useScrollCallback(_a, _b) {
             };
             if (userFilledMessageListParams) {
                 Object.keys(userFilledMessageListParams).forEach(function (key) {
+                    // @ts-ignore
                     messageListParams_1[key] = userFilledMessageListParams[key];
                 });
                 logger.info('OpenChannel | useScrollCallback: Used userFilledMessageListParams', userFilledMessageListParams);
             }
             logger.info('OpenChannel | useScrollCallback: Fetching messages', { currentOpenChannel: currentOpenChannel, messageListParams: messageListParams_1 });
-            currentOpenChannel.getMessagesByTimestamp(lastMessageTimestamp || new Date().getTime(), messageListParams_1).then(function (messages) {
+            currentOpenChannel === null || currentOpenChannel === void 0 ? void 0 : currentOpenChannel.getMessagesByTimestamp(lastMessageTimestamp || new Date().getTime(), messageListParams_1).then(function (messages) {
                 logger.info('OpenChannel | useScrollCallback: Fetching messages succeeded', messages);
                 var hasMore = (messages && messages.length > 0);
                 var lastMessageTimestamp = hasMore ? messages[0].createdAt : null;
@@ -882,8 +884,9 @@ function useSendMessageCallback(_a, _b) {
     var currentOpenChannel = _a.currentOpenChannel, onBeforeSendUserMessage = _a.onBeforeSendUserMessage, messageInputRef = _a.messageInputRef;
     var sdk = _b.sdk, logger = _b.logger, messagesDispatcher = _b.messagesDispatcher, scrollRef = _b.scrollRef;
     return React.useCallback(function () {
+        var _a;
         if (sdk) {
-            var text = messageInputRef.current.innerText;
+            var text = (_a = messageInputRef.current) === null || _a === void 0 ? void 0 : _a.innerText;
             var createParamsDefault = function (txt) {
                 var message = txt;
                 var params = {
@@ -895,11 +898,10 @@ function useSendMessageCallback(_a, _b) {
             if (createCustomParams) {
                 logger.info('OpenChannel | useSendMessageCallback: Creating params using onBeforeSendUserMessage', onBeforeSendUserMessage);
             }
-            var params = onBeforeSendUserMessage ? onBeforeSendUserMessage(text) : createParamsDefault(text);
+            var params = onBeforeSendUserMessage ? onBeforeSendUserMessage(text !== null && text !== void 0 ? text : '') : createParamsDefault(text !== null && text !== void 0 ? text : '');
             logger.info('OpenChannel | useSendMessageCallback: Sending message has started', params);
-            var pendingMsg_1 = null;
-            currentOpenChannel.sendUserMessage(params)
-                .onPending(function (pendingMessage) {
+            var pendingMsg_1;
+            currentOpenChannel === null || currentOpenChannel === void 0 ? void 0 : currentOpenChannel.sendUserMessage(params).onPending(function (pendingMessage) {
                 messagesDispatcher({
                     type: SENDING_MESSAGE_START,
                     payload: {
@@ -909,15 +911,13 @@ function useSendMessageCallback(_a, _b) {
                 });
                 pendingMsg_1 = pendingMessage;
                 setTimeout(function () { return scrollIntoLast(0, scrollRef); });
-            })
-                .onSucceeded(function (message) {
+            }).onSucceeded(function (message) {
                 logger.info('OpenChannel | useSendMessageCallback: Sending message succeeded', message);
                 messagesDispatcher({
                     type: SENDING_MESSAGE_SUCCEEDED,
                     payload: message,
                 });
-            })
-                .onFailed(function (error) {
+            }).onFailed(function (error) {
                 logger.warning('OpenChannel | useSendMessageCallback: Sending message failed', error);
                 messagesDispatcher({
                     type: SENDING_MESSAGE_FAILED,
@@ -956,9 +956,9 @@ function useFileUploadCallback(_a, _b) {
                     if (!sdk) return [3 /*break*/, 2];
                     file_1 = Array.isArray(files) ? files[0] : files;
                     createCustomParams = onBeforeSendFileMessage && typeof onBeforeSendFileMessage === 'function';
-                    createParamsDefault = function (file_) {
+                    createParamsDefault = function (file) {
                         var params = {};
-                        params.file = file_;
+                        params.file = file;
                         return params;
                     };
                     /**
@@ -993,8 +993,7 @@ function useFileUploadCallback(_a, _b) {
                     }
                     params = onBeforeSendFileMessage ? onBeforeSendFileMessage(compressedFile) : createParamsDefault(compressedFile);
                     logger.info('OpenChannel | useFileUploadCallback: Uploading file message start', params);
-                    currentOpenChannel.sendFileMessage(params)
-                        .onPending(function (pendingMessage) {
+                    currentOpenChannel === null || currentOpenChannel === void 0 ? void 0 : currentOpenChannel.sendFileMessage(params).onPending(function (pendingMessage) {
                         messagesDispatcher({
                             type: SENDING_MESSAGE_START,
                             payload: {
@@ -1006,15 +1005,13 @@ function useFileUploadCallback(_a, _b) {
                             },
                         });
                         setTimeout(function () { return scrollIntoLast(0, scrollRef); });
-                    })
-                        .onSucceeded(function (message) {
+                    }).onSucceeded(function (message) {
                         logger.info('OpenChannel | useFileUploadCallback: Sending message succeeded', message);
                         messagesDispatcher({
                             type: SENDING_MESSAGE_SUCCEEDED,
                             payload: message,
                         });
-                    })
-                        .onFailed(function (error, message) {
+                    }).onFailed(function (error, message) {
                         logger.error('OpenChannel | useFileUploadCallback: Sending file message failed', { message: message, error: error });
                         // @ts-ignore
                         message.localUrl = URL.createObjectURL(file_1);
@@ -1037,10 +1034,9 @@ function useUpdateMessageCallback(_a, _b) {
     var logger = _b.logger, messagesDispatcher = _b.messagesDispatcher;
     return React.useCallback(function (messageId, text, callback) {
         var createParamsDefault = function (txt) {
-            var params = {
+            return {
                 message: txt,
             };
-            return params;
         };
         if (onBeforeSendUserMessage && typeof onBeforeSendUserMessage === 'function') {
             logger.info('OpenChannel | useUpdateMessageCallback: Creating params using onBeforeUpdateUserMessage');
@@ -1085,7 +1081,7 @@ function useDeleteMessageCallback(_a, _b) {
                 return;
             }
             var messageToDelete = message;
-            currentOpenChannel.deleteMessage(messageToDelete).then(function () {
+            currentOpenChannel === null || currentOpenChannel === void 0 ? void 0 : currentOpenChannel.deleteMessage(messageToDelete).then(function () {
                 logger.info('OpenChannel | useDeleteMessageCallback: Deleting message on server', sendingStatus);
                 if (callback) {
                     callback();
@@ -1114,9 +1110,7 @@ function useResendMessageCallback(_a, _b) {
             && failedMessage.isResendable) {
             // userMessage
             if (failedMessage.isUserMessage()) {
-                currentOpenChannel
-                    .resendMessage(failedMessage)
-                    .onPending(function (message) {
+                currentOpenChannel === null || currentOpenChannel === void 0 ? void 0 : currentOpenChannel.resendMessage(failedMessage).onPending(function (message) {
                     messagesDispatcher({
                         type: RESENDING_MESSAGE_START,
                         payload: {
@@ -1124,15 +1118,13 @@ function useResendMessageCallback(_a, _b) {
                             message: message,
                         },
                     });
-                })
-                    .onSucceeded(function (message) {
+                }).onSucceeded(function (message) {
                     logger.info('OpenChannel | useResendMessageCallback: Reseding message succeeded', message);
                     messagesDispatcher({
                         type: SENDING_MESSAGE_SUCCEEDED,
                         payload: message,
                     });
-                })
-                    .onFailed(function (error, message) {
+                }).onFailed(function (error, message) {
                     logger.warning('OpenChannel | useResendMessageCallback: Resending message failed', error);
                     messagesDispatcher({
                         type: SENDING_MESSAGE_FAILED,
@@ -1142,9 +1134,7 @@ function useResendMessageCallback(_a, _b) {
             }
             // fileMessage
             if (failedMessage.isFileMessage()) {
-                currentOpenChannel
-                    .resendMessage(failedMessage)
-                    .onPending(function (message) {
+                currentOpenChannel === null || currentOpenChannel === void 0 ? void 0 : currentOpenChannel.resendMessage(failedMessage).onPending(function (message) {
                     messagesDispatcher({
                         type: RESENDING_MESSAGE_START,
                         payload: {
@@ -1152,15 +1142,13 @@ function useResendMessageCallback(_a, _b) {
                             message: message,
                         },
                     });
-                })
-                    .onSucceeded(function (message) {
+                }).onSucceeded(function (message) {
                     logger.info('OpenChannel | useResendMessageCallback: Resending file message succeeded', message);
                     messagesDispatcher({
                         type: SENDING_MESSAGE_SUCCEEDED,
                         payload: message,
                     });
-                })
-                    .onFailed(function (error, message) {
+                }).onFailed(function (error, message) {
                     logger.warning('OpenChannel | useResendMessageCallback: Resending file message failed', error);
                     messagesDispatcher({
                         type: SENDING_MESSAGE_FAILED,
@@ -1191,7 +1179,7 @@ function useTrimMessageList(_a, _b) {
         if (inProgress) {
             return;
         }
-        if (typeof messagesLength === 'number' && messagesLength > messageLimit) {
+        if (typeof messagesLength === 'number' && typeof messageLimit === 'number' && messagesLength > messageLimit) {
             logger.info('Trimming MessageList');
             messagesDispatcher({
                 type: TRIM_MESSAGE_LIST,
@@ -1203,7 +1191,7 @@ function useTrimMessageList(_a, _b) {
     }, [messagesLength, messageLimit]);
 }
 
-var OpenChannelContext = React.createContext(undefined);
+var OpenChannelContext = React.createContext(null);
 var OpenChannelProvider = function (props) {
     var _a, _b, _c, _d, _e, _f, _g;
     var channelUrl = props.channelUrl, children = props.children, _h = props.isMessageGroupingEnabled, isMessageGroupingEnabled = _h === void 0 ? true : _h, queries = props.queries, onBeforeSendUserMessage = props.onBeforeSendUserMessage, messageLimit = props.messageLimit, onBeforeSendFileMessage = props.onBeforeSendFileMessage, onChatHeaderActionClick = props.onChatHeaderActionClick, onBackClick = props.onBackClick, disableUserProfile = props.disableUserProfile, renderUserProfile = props.renderUserProfile;
@@ -1243,7 +1231,7 @@ var OpenChannelProvider = function (props) {
     useHandleChannelEvents({ currentOpenChannel: currentOpenChannel, checkScrollBottom: checkScrollBottom }, { sdk: sdk, logger: logger, messagesDispatcher: messagesDispatcher, scrollRef: conversationScrollRef });
     useInitialMessagesFetch({ currentOpenChannel: currentOpenChannel, userFilledMessageListParams: userFilledMessageListParams }, { logger: logger, messagesDispatcher: messagesDispatcher, scrollRef: conversationScrollRef });
     var fetchMore = shouldFetchMore(allMessages === null || allMessages === void 0 ? void 0 : allMessages.length, messageLimit);
-    // donot fetch more for streaming
+    // do not fetch more for streaming
     var onScroll = useScrollCallback({ currentOpenChannel: currentOpenChannel, lastMessageTimestamp: lastMessageTimestamp, fetchMore: fetchMore }, { sdk: sdk, logger: logger, messagesDispatcher: messagesDispatcher, hasMore: hasMore, userFilledMessageListParams: userFilledMessageListParams });
     var handleSendMessage = useSendMessageCallback({ currentOpenChannel: currentOpenChannel, onBeforeSendUserMessage: onBeforeSendUserMessage, checkScrollBottom: checkScrollBottom, messageInputRef: messageInputRef }, { sdk: sdk, logger: logger, messagesDispatcher: messagesDispatcher, scrollRef: conversationScrollRef });
     var handleFileUpload = useFileUploadCallback({ currentOpenChannel: currentOpenChannel, onBeforeSendFileMessage: onBeforeSendFileMessage, checkScrollBottom: checkScrollBottom, imageCompression: imageCompression }, { sdk: sdk, logger: logger, messagesDispatcher: messagesDispatcher, scrollRef: conversationScrollRef });
@@ -1361,9 +1349,14 @@ var OpenChannelProvider = function (props) {
         } },
         React.createElement(UserProfileContext.UserProfileProvider, { isOpenChannel: true, renderUserProfile: props === null || props === void 0 ? void 0 : props.renderUserProfile, disableUserProfile: (_g = props === null || props === void 0 ? void 0 : props.disableUserProfile) !== null && _g !== void 0 ? _g : config === null || config === void 0 ? void 0 : config.disableUserProfile }, children)));
 };
-var useOpenChannelContext = function () { return React.useContext(OpenChannelContext); };
+var useOpenChannelContext = function () {
+    var context = React.useContext(OpenChannelContext);
+    if (!context)
+        throw new Error('OpenChannelContext not found. Use within the OpenChannel module');
+    return context;
+};
 
 exports.OpenChannelProvider = OpenChannelProvider;
 exports.kFormatter = kFormatter;
 exports.useOpenChannelContext = useOpenChannelContext;
-//# sourceMappingURL=bundle-8IuV93EV.js.map
+//# sourceMappingURL=bundle-Q0M503xu.js.map

package/cjs/chunks/{bundle-8IuV93EV.js.map → bundle-Q0M503xu.js.map}

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

package/cjs/chunks/{bundle-CPIzT1cf.js → bundle-Q30PMAyi.js}

@@ -7,4 +7,4 @@ var USER_ACTIONS = {
 };
 
 exports.USER_ACTIONS = USER_ACTIONS;
-//# sourceMappingURL=bundle-CPIzT1cf.js.map
+//# sourceMappingURL=bundle-Q30PMAyi.js.map

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

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

package/cjs/chunks/{bundle-B-0_xv9u.js → bundle-V6Y5v5ft.js}

@@ -11,7 +11,7 @@ exports.CHANNEL_TYPE = void 0;
     CHANNEL_TYPE["BROADCAST"] = "broadcast";
 })(exports.CHANNEL_TYPE || (exports.CHANNEL_TYPE = {}));
 
-var CreateChannelContext = React.createContext(undefined);
+var CreateChannelContext = React.createContext(null);
 var CreateChannelProvider = function (props) {
     var _a;
     var children = props.children, onCreateChannelClick = props.onCreateChannelClick, onBeforeCreateChannel = props.onBeforeCreateChannel, onChannelCreated = props.onChannelCreated, userListQuery = props.userListQuery, onCreateChannel = props.onCreateChannel, overrideInviteUser = props.overrideInviteUser;
@@ -20,6 +20,7 @@ var CreateChannelProvider = function (props) {
     var _b = React.useState(0), step = _b[0], setStep = _b[1];
     var _c = React.useState(exports.CHANNEL_TYPE.GROUP), type = _c[0], setType = _c[1];
     return (React.createElement(CreateChannelContext.Provider, { value: {
+            sdk: store.stores.sdkStore.sdk,
             createChannel: sendbirdSelectors.getCreateGroupChannel(store),
             onCreateChannelClick: onCreateChannelClick,
             onBeforeCreateChannel: onBeforeCreateChannel,
@@ -33,8 +34,13 @@ var CreateChannelProvider = function (props) {
             overrideInviteUser: overrideInviteUser,
         } }, children));
 };
-var useCreateChannelContext = function () { return (React.useContext(CreateChannelContext)); };
+var useCreateChannelContext = function () {
+    var context = React.useContext(CreateChannelContext);
+    if (!context)
+        throw new Error('CreateChannelContext not found. Use within the CreateChannel module.');
+    return context;
+};
 
 exports.CreateChannelProvider = CreateChannelProvider;
 exports.useCreateChannelContext = useCreateChannelContext;
-//# sourceMappingURL=bundle-B-0_xv9u.js.map
+//# sourceMappingURL=bundle-V6Y5v5ft.js.map

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

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

package/cjs/chunks/{bundle-DFVUnSWq.js → bundle-VNK4cKfS.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var _tslib = require('./bundle-C-r9vRgc.js');
+var _tslib = require('./bundle-BGmEoqIq.js');
 
 var USER_MENTION_PREFIX = '@';
 
@@ -148,4 +148,4 @@ exports.TOKEN_TYPES = TOKEN_TYPES;
 exports.USER_MENTION_PREFIX = USER_MENTION_PREFIX;
 exports.getWhiteSpacePreservedText = getWhiteSpacePreservedText;
 exports.tokenizeMessage = tokenizeMessage;
-//# sourceMappingURL=bundle-DFVUnSWq.js.map
+//# sourceMappingURL=bundle-VNK4cKfS.js.map

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

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

package/cjs/chunks/{bundle-BCt-Rzil.js → bundle-WLDzr4U5.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-CRjV-DLM.js');
+var tokenize = require('./bundle-VNK4cKfS.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-DgWaY7S0.js');
 
 // this function is used to generate a unique key for token in message
 // it changes with updated time and index
@@ -24,15 +24,15 @@ function TextFragment(_a) {
     return (React.createElement(React.Fragment, null, tokens === null || tokens === void 0 ? void 0 : tokens.map(function (token, idx) {
         var key = keyGenerator(createdAt, updatedAt, idx);
         return index.K(token.type)
-            .with(tokenize.TOKEN_TYPES.mention, function () { return (React.createElement("span", { className: "sendbird-word", key: key },
+            .with(tokenize.TOKEN_TYPES.mention, function () { return (React.createElement("span", { className: "sendbird-word", key: key, "data-testid": "sendbird-ui-word" },
             React.createElement(ui_MentionLabel, { mentionTemplate: tokenize.USER_MENTION_PREFIX, 
                 // @ts-ignore
                 mentionedUserId: token.userId, mentionedUserNickname: token.value, isByMe: isByMe }))); })
-            .with(tokenize.TOKEN_TYPES.url, function () { return (React.createElement("span", { className: "sendbird-word", key: key },
+            .with(tokenize.TOKEN_TYPES.url, function () { return (React.createElement("span", { className: "sendbird-word", key: key, "data-testid": "sendbird-ui-word" },
             React.createElement(ui_LinkLabel.default, { className: "sendbird-word__url", src: token.value, type: ui_Label.LabelTypography.BODY_1 }, token.value))); })
             .otherwise(function () { return React.createElement(React.Fragment, { key: key }, tokenize.getWhiteSpacePreservedText(token.value)); });
     })));
 }
 
 exports.TextFragment = TextFragment;
-//# sourceMappingURL=bundle-BCt-Rzil.js.map
+//# sourceMappingURL=bundle-WLDzr4U5.js.map

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

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

package/cjs/chunks/{bundle-C4UzGGy_.js → bundle-WrRM6A2K.js}

@@ -19,4 +19,4 @@ var NodeNames = {
 exports.MessageInputKeys = MessageInputKeys;
 exports.NodeNames = NodeNames;
 exports.NodeTypes = NodeTypes;
-//# sourceMappingURL=bundle-C4UzGGy_.js.map
+//# sourceMappingURL=bundle-WrRM6A2K.js.map

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

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

package/cjs/chunks/{bundle-B4EdciCR.js → bundle-XqNA0vsK.js}

@@ -5,6 +5,7 @@ var getOpenChannelAvatar = function (channel) {
     if (channel === null || channel === void 0 ? void 0 : channel.coverUrl) {
         return channel.coverUrl;
     }
+    return undefined;
 };
 var getChannelAvatarSource = function (channel, currentUserId) {
     if (channel === null || channel === void 0 ? void 0 : channel.coverUrl) {
@@ -32,4 +33,4 @@ var generateDefaultAvatar = function (channel) {
 exports.generateDefaultAvatar = generateDefaultAvatar;
 exports.getChannelAvatarSource = getChannelAvatarSource;
 exports.getOpenChannelAvatar = getOpenChannelAvatar;
-//# sourceMappingURL=bundle-B4EdciCR.js.map
+//# sourceMappingURL=bundle-XqNA0vsK.js.map

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

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