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

package/chunks/{bundle-D5DtB0L7.js → bundle-gCu36B_D.js}

@@ -1,28 +1,24 @@
 import React__default, { useEffect, useCallback, useState, useReducer, useRef, useMemo } from 'react';
-import { U as UserProfileProvider } from './bundle-60et0yds.js';
-import { _ as __assign, c as __spreadArray, a as __awaiter, b as __generator } from './bundle-CDy_GVNR.js';
-import { c as compareIds } from './bundle-DwPw_RW5.js';
-import { p as pubSubTopics } from './bundle-CtgXJZJt.js';
+import { U as UserProfileProvider } from './bundle-CPH6jPCe.js';
+import { _ as __assign, c as __spreadArray, a as __awaiter, b as __generator } from './bundle-zAvvLMA9.js';
+import { c as compareIds } from './bundle-YyfBbrXK.js';
+import { p as pubSubTopics } from './bundle-Dub0HHFi.js';
 import { ChannelType } from '@sendbird/chat';
 import { OpenChannelHandler } from '@sendbird/chat/openChannel';
-import { u as uuidv4 } from './bundle-8J9SSfIS.js';
-import { c as compressImages } from './bundle-DwvN2wPi.js';
+import { u as uuidv4 } from './bundle-sq0c8UmG.js';
+import { c as compressImages } from './bundle-D86Ophow.js';
 import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
-import { b as useGlobalModalContext, c as ModalFooter } from './bundle-DiVyB2HD.js';
-import { u as useLocalization } from './bundle-CAdxJnio.js';
-import { O as ONE_MiB } from './bundle-thdxvFU8.js';
-import './bundle-q3jyuKU7.js';
+import { b as useGlobalModalContext, c as ModalFooter } from './bundle-DEcnZTr9.js';
+import { u as useLocalization } from './bundle-4r7ZPzcx.js';
+import { O as ONE_MiB } from './bundle-DaqQkuav.js';
+import './bundle-DyVURRtM.js';
 import { ButtonTypes } from '../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) {
@@ -35,7 +31,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 () {
@@ -60,7 +58,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) {
@@ -125,7 +125,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 __assign(__assign({}, state), { allMessages: [] });
@@ -156,13 +156,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;
             }
@@ -173,8 +173,8 @@ function reducer(state, action) {
             return __assign(__assign({}, state), { loading: false, initialized: true, hasMore: _hasMore, lastMessageTimestamp: _lastMessageTimestamp, allMessages: __spreadArray(__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
             ) {
@@ -204,7 +204,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) {
@@ -216,7 +216,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 __assign(__assign({}, state), { allMessages: state.allMessages.map(function (m) { return (compareIds(m.reqId, resentMessage_1.reqId) ? resentMessage_1 : m); }) });
@@ -224,7 +224,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 __assign(__assign({}, state), { participants: __spreadArray(__spreadArray([], state.participants, true), fetchedParticipantList, true) });
@@ -232,7 +232,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;
             }
@@ -241,7 +241,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;
             }
@@ -252,7 +252,7 @@ function reducer(state, action) {
             var eventedChannel = action.payload.channel;
             var receivedMessage = action.payload.message;
             var currentOpenChannel = state.currentOpenChannel;
-            if (!compareIds(eventedChannel.url, currentOpenChannel.url)
+            if (!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;
             }
@@ -769,6 +769,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');
@@ -821,12 +822,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;
@@ -880,8 +882,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 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 = {
@@ -893,11 +896,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: {
@@ -907,15 +909,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,
@@ -954,9 +954,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;
                     };
                     /**
@@ -991,8 +991,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: {
@@ -1004,15 +1003,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);
@@ -1035,10 +1032,9 @@ function useUpdateMessageCallback(_a, _b) {
     var logger = _b.logger, messagesDispatcher = _b.messagesDispatcher;
     return 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');
@@ -1083,7 +1079,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();
@@ -1112,9 +1108,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: {
@@ -1122,15 +1116,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,
@@ -1140,9 +1132,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: {
@@ -1150,15 +1140,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,
@@ -1189,7 +1177,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,
@@ -1201,7 +1189,7 @@ function useTrimMessageList(_a, _b) {
     }, [messagesLength, messageLimit]);
 }
 
-var OpenChannelContext = React__default.createContext(undefined);
+var OpenChannelContext = React__default.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;
@@ -1241,7 +1229,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 });
@@ -1359,7 +1347,12 @@ var OpenChannelProvider = function (props) {
         } },
         React__default.createElement(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__default.useContext(OpenChannelContext); };
+var useOpenChannelContext = function () {
+    var context = React__default.useContext(OpenChannelContext);
+    if (!context)
+        throw new Error('OpenChannelContext not found. Use within the OpenChannel module');
+    return context;
+};
 
 export { OpenChannelProvider as O, kFormatter as k, useOpenChannelContext as u };
-//# sourceMappingURL=bundle-D5DtB0L7.js.map
+//# sourceMappingURL=bundle-gCu36B_D.js.map

package/chunks/{bundle-D5DtB0L7.js.map → bundle-gCu36B_D.js.map}

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

package/chunks/{bundle-DUVa5cu6.js → bundle-jD9nAlqc.js}

@@ -1,4 +1,4 @@
 var TEXT_MESSAGE_BODY_CLASSNAME = 'sendbird-text-message-item-body';
 
 export { TEXT_MESSAGE_BODY_CLASSNAME as T };
-//# sourceMappingURL=bundle-DUVa5cu6.js.map
+//# sourceMappingURL=bundle-jD9nAlqc.js.map

package/chunks/bundle-jD9nAlqc.js.map

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

package/chunks/{bundle-C1XVT5qc.js → bundle-lS9BV-1I.js}

@@ -1,8 +1,9 @@
-import { c as __spreadArray } from './bundle-CDy_GVNR.js';
+import { c as __spreadArray } from './bundle-zAvvLMA9.js';
 import React__default from 'react';
 import ImageRenderer from '../ui/ImageRenderer.js';
-import { p as pxToNumber } from './bundle-BQPvwBK8.js';
+import { p as pxToNumber } from './bundle-BEDpWEUq.js';
 import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
+import { c as classnames } from './bundle-Dl6p5CcR.js';
 
 var AvatarDefault = function (props) {
     var width = props.width, height = props.height, text = props.text;
@@ -14,7 +15,7 @@ var AvatarDefault = function (props) {
     if (typeof iconHeight === 'number' && !Number.isNaN(iconHeight)) {
         iconHeight *= 0.575;
     }
-    return (React__default.createElement("div", { className: "sendbird-avatar-img--default ".concat(text ? 'text' : ''), style: { width: width, height: height } }, text
+    return (React__default.createElement("div", { className: classnames('sendbird-avatar-img--default', text && 'text'), style: { width: width, height: height } }, text
         ? React__default.createElement("div", { className: 'sendbird-avatar-text' }, text)
         : React__default.createElement(Icon, { type: IconTypes.USER, fillColor: IconColors.CONTENT, width: iconWidth, height: iconHeight })));
 };
@@ -67,4 +68,4 @@ function Avatar(_a, ref) {
 var Avatar$1 = React__default.forwardRef(Avatar);
 
 export { Avatar$1 as A, AvatarDefault as a, AvatarInner as b };
-//# sourceMappingURL=bundle-C1XVT5qc.js.map
+//# sourceMappingURL=bundle-lS9BV-1I.js.map

package/chunks/bundle-lS9BV-1I.js.map

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

package/chunks/{bundle-D-cEFrBM.js → bundle-oF8OKbPo.js}

@@ -1,14 +1,14 @@
-import { _ as __assign, c as __spreadArray, a as __awaiter, b as __generator } from './bundle-CDy_GVNR.js';
+import { _ as __assign, c as __spreadArray, a as __awaiter, b as __generator } from './bundle-zAvvLMA9.js';
 import React__default, { useEffect, useCallback, useReducer, useState, useMemo, useContext } from 'react';
 import { GroupChannelHandler, GroupChannelListOrder } from '@sendbird/chat/groupChannel';
-import { p as pubSubTopics } from './bundle-CtgXJZJt.js';
-import { u as uuidv4 } from './bundle-8J9SSfIS.js';
-import { n as noop } from './bundle-DhJuLwLJ.js';
-import { D as DELIVERY_RECEIPT$1 } from './bundle-thdxvFU8.js';
-import { U as UserProfileProvider } from './bundle-60et0yds.js';
+import { p as pubSubTopics } from './bundle-Dub0HHFi.js';
+import { u as uuidv4 } from './bundle-sq0c8UmG.js';
+import { n as noop } from './bundle-Dl6p5CcR.js';
+import { D as DELIVERY_RECEIPT$1 } from './bundle-DaqQkuav.js';
+import { U as UserProfileProvider } from './bundle-CPH6jPCe.js';
 import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
-import { K, $ as filterChannelListParams, a0 as getChannelsWithUpsertedChannel, a1 as S } from './bundle-BH5EGLxi.js';
-import { u as useReconnectOnIdle } from './bundle-cgNuve_E.js';
+import { K, $ as filterChannelListParams, a0 as getChannelsWithUpsertedChannel, a1 as S } from './bundle-CMOqM33u.js';
+import { u as useReconnectOnIdle } from './bundle-CsleEf9Z.js';
 
 var RESET_CHANNEL_LIST = 'RESET_CHANNEL_LIST';
 var CREATE_CHANNEL = 'CREATE_CHANNEL';
@@ -97,7 +97,8 @@ var createEventHandler = function (_a) {
             }
         },
         onMessageUpdated: function (channel, message) {
-            if (channel.isGroupChannel() && channel.lastMessage.isEqual(message)) {
+            var _a;
+            if (channel.isGroupChannel() && ((_a = channel.lastMessage) === null || _a === void 0 ? void 0 : _a.isEqual(message))) {
                 logger.info('ChannelList: onMessageUpdated', channel);
                 channelListDispatcher({
                     type: ON_LAST_MESSAGE_UPDATED,
@@ -143,6 +144,7 @@ var createChannelListQuery = function (_a) {
     };
     if (userFilledChannelListQuery) {
         Object.keys(userFilledChannelListQuery).forEach(function (key) {
+            // @ts-ignore
             params[key] = userFilledChannelListQuery[key];
         });
     }
@@ -240,8 +242,8 @@ var pubSubHandler = function (pubSub, channelListDispatcher) {
     var subscriber = new Map();
     if (!pubSub)
         return subscriber;
-    subscriber.set(pubSubTopics.CREATE_CHANNEL, pubSub.subscribe(pubSubTopics.CREATE_CHANNEL, function (msg) {
-        var channel = msg.channel;
+    subscriber.set(pubSubTopics.CREATE_CHANNEL, pubSub.subscribe(pubSubTopics.CREATE_CHANNEL, function (_a) {
+        var channel = _a.channel;
         channelListDispatcher({
             type: CREATE_CHANNEL,
             payload: channel,
@@ -696,27 +698,7 @@ function useHandleReconnectForChannelList(_a) {
     }, [shouldReconnect]);
 }
 
-var ChannelListContext = React__default.createContext({
-    disableUserProfile: true,
-    allowProfileEdit: true,
-    onBeforeCreateChannel: null,
-    onThemeChange: null,
-    onProfileEditSuccess: null,
-    onChannelSelect: null,
-    queries: {},
-    className: null,
-    initialized: false,
-    loading: false,
-    allChannels: [],
-    currentChannel: null,
-    channelListQuery: {},
-    currentUserId: null,
-    channelListDispatcher: null,
-    channelSource: null,
-    typingChannels: [],
-    fetchChannelList: noop,
-    reconnectOnIdle: true,
-});
+var ChannelListContext = React__default.createContext(null);
 var ChannelListProvider = function (props) {
     var _a, _b;
     // destruct props
@@ -737,7 +719,7 @@ var ChannelListProvider = function (props) {
     // enable if it is true at least once(both are false by default)
     var userDefinedDisableUserProfile = disableUserProfile !== null && disableUserProfile !== void 0 ? disableUserProfile : !config.common.enableUsingDefaultUserProfile;
     var userDefinedRenderProfile = config === null || config === void 0 ? void 0 : config.renderUserProfile;
-    var enableEditProfile = allowProfileEdit || (config === null || config === void 0 ? void 0 : config.allowProfileEdit);
+    var enableEditProfile = allowProfileEdit || config.allowProfileEdit;
     var userFilledChannelListQuery = queries === null || queries === void 0 ? void 0 : queries.channelListQuery;
     var userFilledApplicationUserListQuery = queries === null || queries === void 0 ? void 0 : queries.applicationUserListQuery;
     var sdkIntialized = sdkStore === null || sdkStore === void 0 ? void 0 : sdkStore.initialized;
@@ -762,7 +744,7 @@ var ChannelListProvider = function (props) {
                 channelListDispatcher: channelListDispatcher,
                 setChannelSource: setChannelSource,
                 onChannelSelect: onChannelSelect,
-                userFilledChannelListQuery: userFilledChannelListQuery,
+                userFilledChannelListQuery: __assign({}, userFilledChannelListQuery),
                 logger: logger,
                 sortChannelList: sortChannelList,
                 disableAutoSelect: disableAutoSelect,
@@ -936,8 +918,10 @@ var ChannelListProvider = function (props) {
 };
 function useChannelListContext() {
     var context = useContext(ChannelListContext);
+    if (!context)
+        throw new Error('ChannelListContext not found. Use within the ChannelList module.');
     return context;
 }
 
 export { ChannelListProvider as C, LEAVE_CHANNEL_SUCCESS as L, SET_CURRENT_CHANNEL as S, useChannelListContext as u };
-//# sourceMappingURL=bundle-D-cEFrBM.js.map
+//# sourceMappingURL=bundle-oF8OKbPo.js.map

package/chunks/{bundle-D-cEFrBM.js.map → bundle-oF8OKbPo.js.map}

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

package/chunks/{bundle-YveljAuC.js → bundle-q8TfLkpw.js}

@@ -1,4 +1,4 @@
 var MENTION_USER_LABEL_CLASSNAME = 'sendbird-mention-user-label';
 
 export { MENTION_USER_LABEL_CLASSNAME as M };
-//# sourceMappingURL=bundle-YveljAuC.js.map
+//# sourceMappingURL=bundle-q8TfLkpw.js.map

package/chunks/bundle-q8TfLkpw.js.map

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

package/chunks/{bundle-8J9SSfIS.js → bundle-sq0c8UmG.js}

@@ -10,4 +10,4 @@ var uuidv4 = function () { return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace
 }); };
 
 export { uuidv4 as u };
-//# sourceMappingURL=bundle-8J9SSfIS.js.map
+//# sourceMappingURL=bundle-sq0c8UmG.js.map

package/chunks/bundle-sq0c8UmG.js.map

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

package/chunks/{bundle-Br_sURBN.js → bundle-wPqhzyo_.js}

@@ -17,4 +17,4 @@ var AddGroupChannelView = function (_a) {
 };
 
 export { AddGroupChannelView as A };
-//# sourceMappingURL=bundle-Br_sURBN.js.map
+//# sourceMappingURL=bundle-wPqhzyo_.js.map

package/chunks/bundle-wPqhzyo_.js.map

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

package/chunks/{bundle-CDy_GVNR.js → bundle-zAvvLMA9.js}

@@ -106,4 +106,4 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 export { __assign as _, __awaiter as a, __generator as b, __spreadArray as c, __extends as d, __rest as e };
-//# sourceMappingURL=bundle-CDy_GVNR.js.map
+//# sourceMappingURL=bundle-zAvvLMA9.js.map

package/chunks/{bundle-CDy_GVNR.js.map → bundle-zAvvLMA9.js.map}

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