@sendbird/uikit-react 3.14.4 → 3.14.6

package/chunks/{bundle-Bi8Wfc2I.js → bundle-DQdztuN4.js}

@@ -1,28 +1,24 @@
 import React__default, { useEffect, useCallback, useState, useReducer, useRef, useMemo } from 'react';
-import { U as UserProfileProvider } from './bundle-B7barEsR.js';
-import { _ as __assign, c as __spreadArray, a as __awaiter, b as __generator } from './bundle-7oF7KbGv.js';
-import { c as compareIds } from './bundle-BKho3Uub.js';
-import { p as pubSubTopics } from './bundle-BWuyd0AD.js';
+import { U as UserProfileProvider } from './bundle-C_dNvBEo.js';
+import { _ as __assign, c as __spreadArray, a as __awaiter, b as __generator } from './bundle-DKkCwVCs.js';
+import { c as compareIds } from './bundle-Dk5y6RzJ.js';
+import { p as pubSubTopics } from './bundle-CriEArZn.js';
 import { ChannelType } from '@sendbird/chat';
 import { OpenChannelHandler } from '@sendbird/chat/openChannel';
-import { u as uuidv4 } from './bundle-BJ46V6XQ.js';
-import { c as compressImages } from './bundle-3amhHjNa.js';
+import { u as uuidv4 } from './bundle-uIqOEfCa.js';
+import { c as compressImages } from './bundle-DYtgOX1c.js';
 import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
-import { b as useGlobalModalContext, c as ModalFooter } from './bundle-C4Z-NWqF.js';
-import { u as useLocalization } from './bundle-Bx5vhTbU.js';
-import { O as ONE_MiB } from './bundle-CD9AzC6s.js';
-import './bundle-LYAWKk4n.js';
+import { b as useGlobalModalContext, c as ModalFooter } from './bundle-CGmq3qGM.js';
+import { u as useLocalization } from './bundle-nfJ9J5Md.js';
+import { O as ONE_MiB } from './bundle-DhBuJR0w.js';
+import './bundle-prXB4t_m.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-Bi8Wfc2I.js.map
+//# sourceMappingURL=bundle-DQdztuN4.js.map

package/chunks/{bundle-Bi8Wfc2I.js.map → bundle-DQdztuN4.js.map}

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

package/chunks/{bundle-DDhhxSv0.js → bundle-DYErcqMl.js}

@@ -1,4 +1,4 @@
-import { K, b as isFileMessage, c as isMultipleFilesMessage } from './bundle-BWCGFXhj.js';
+import { K, b as isFileMessage, c as isMultipleFilesMessage } from './bundle-janisM9b.js';
 
 function getMessageFirstFileType(message) {
     return K(message)
@@ -65,4 +65,4 @@ function getMessageFirstFileThumbnailUrl(message) {
 }
 
 export { getMessageFirstFileType as a, getMessageFirstFileName as b, getMessageFirstFileThumbnailUrl as c, getMessageFirstFileUrl as g };
-//# sourceMappingURL=bundle-DDhhxSv0.js.map
+//# sourceMappingURL=bundle-DYErcqMl.js.map

package/chunks/bundle-DYErcqMl.js.map

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

package/chunks/{bundle-3amhHjNa.js → bundle-DYtgOX1c.js}

@@ -1,5 +1,5 @@
-import { a as __awaiter, b as __generator } from './bundle-7oF7KbGv.js';
-import { p as pxToNumber } from './bundle-CT8ZXUi2.js';
+import { a as __awaiter, b as __generator } from './bundle-DKkCwVCs.js';
+import { p as pxToNumber } from './bundle-Bmk2FVdj.js';
 
 var compressImage = function (_a) {
     var imageFile = _a.imageFile, compressionRate = _a.compressionRate, resizingWidth = _a.resizingWidth, resizingHeight = _a.resizingHeight, outputFormat = _a.outputFormat;
@@ -59,8 +59,8 @@ var compressImages = function (_a) { return __awaiter(void 0, [_a], void 0, func
         switch (_d.label) {
             case 0:
                 compressionRate = imageCompression.compressionRate, _c = imageCompression.outputFormat, outputFormat = _c === void 0 ? 'preserve' : _c;
-                resizingWidth = pxToNumber(imageCompression.resizingWidth);
-                resizingHeight = pxToNumber(imageCompression.resizingHeight);
+                resizingWidth = imageCompression.resizingWidth ? pxToNumber(imageCompression.resizingWidth) : undefined;
+                resizingHeight = imageCompression.resizingHeight ? pxToNumber(imageCompression.resizingHeight) : undefined;
                 result = {
                     failedIndexes: [],
                     compressedFiles: [],
@@ -69,7 +69,7 @@ var compressImages = function (_a) { return __awaiter(void 0, [_a], void 0, func
                     logger === null || logger === void 0 ? void 0 : logger.warning('utils - compressImages: There are no files.', files);
                     return [2 /*return*/, result];
                 }
-                if (compressionRate < 0 || 1 < compressionRate) {
+                if (!compressionRate || compressionRate < 0 || 1 < compressionRate) {
                     logger === null || logger === void 0 ? void 0 : logger.warning('utils - compressImages: The compressionRate is not acceptable.', compressionRate);
                     return [2 /*return*/, result];
                 }
@@ -117,4 +117,4 @@ var compressImages = function (_a) { return __awaiter(void 0, [_a], void 0, func
 }); };
 
 export { compressImages as c };
-//# sourceMappingURL=bundle-3amhHjNa.js.map
+//# sourceMappingURL=bundle-DYtgOX1c.js.map

package/chunks/{bundle-3amhHjNa.js.map → bundle-DYtgOX1c.js.map}

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

package/chunks/{bundle-CD9AzC6s.js → bundle-DhBuJR0w.js}

@@ -28,10 +28,11 @@ var DELIVERY_RECEIPT = 'delivery_receipt';
 var SLIDER_BUTTON_ICON_SIDE_LENGTH = '32px';
 // multiple files message file info count limit
 var DEFAULT_MULTIPLE_FILES_MESSAGE_LIMIT = 10;
+var DEFAULT_UPLOAD_SIZE_LIMIT = 25 * 1024 * 1024;
 // Local storage item key for sdk templates token
 var CACHED_MESSAGE_TEMPLATES_TOKEN_KEY = 'sendbird_message_templates_token_key';
 // Local storage item key for templates in JSON string form
 var CACHED_MESSAGE_TEMPLATES_KEY = 'sendbird_message_templates_key';
 
-export { BROWSER_SUPPORT_MIME_TYPE_LIST as B, CACHED_MESSAGE_TEMPLATES_TOKEN_KEY as C, DELIVERY_RECEIPT as D, META_ARRAY_VOICE_DURATION_KEY as M, ONE_MiB as O, SCROLL_BUFFER as S, VOICE_RECORDER_AUDIO_SAMPLE_RATE as V, SCROLL_BOTTOM_DELAY_FOR_FETCH as a, SCROLL_BOTTOM_DELAY_FOR_SEND as b, VOICE_PLAYER_AUDIO_ID as c, VOICE_RECORDER_DEFAULT_MIN as d, VOICE_RECORDER_CLICK_BUFFER_TIME as e, VOICE_PLAYER_ROOT_ID as f, VOICE_MESSAGE_FILE_NAME as g, VOICE_MESSAGE_MIME_TYPE as h, META_ARRAY_MESSAGE_TYPE_KEY as i, META_ARRAY_MESSAGE_TYPE_VALUE__VOICE as j, VOICE_RECORDER_AUDIO_BIT_RATE as k, SLIDER_BUTTON_ICON_SIDE_LENGTH as l, CACHED_MESSAGE_TEMPLATES_KEY as m, DEFAULT_MULTIPLE_FILES_MESSAGE_LIMIT as n, VOICE_RECORDER_DEFAULT_MAX as o };
-//# sourceMappingURL=bundle-CD9AzC6s.js.map
+export { BROWSER_SUPPORT_MIME_TYPE_LIST as B, CACHED_MESSAGE_TEMPLATES_TOKEN_KEY as C, DELIVERY_RECEIPT as D, META_ARRAY_VOICE_DURATION_KEY as M, ONE_MiB as O, SCROLL_BUFFER as S, VOICE_RECORDER_AUDIO_SAMPLE_RATE as V, SCROLL_BOTTOM_DELAY_FOR_FETCH as a, SCROLL_BOTTOM_DELAY_FOR_SEND as b, VOICE_PLAYER_AUDIO_ID as c, VOICE_RECORDER_CLICK_BUFFER_TIME as d, VOICE_RECORDER_DEFAULT_MIN as e, VOICE_PLAYER_ROOT_ID as f, VOICE_MESSAGE_FILE_NAME as g, VOICE_MESSAGE_MIME_TYPE as h, META_ARRAY_MESSAGE_TYPE_KEY as i, META_ARRAY_MESSAGE_TYPE_VALUE__VOICE as j, VOICE_RECORDER_AUDIO_BIT_RATE as k, SLIDER_BUTTON_ICON_SIDE_LENGTH as l, CACHED_MESSAGE_TEMPLATES_KEY as m, DEFAULT_MULTIPLE_FILES_MESSAGE_LIMIT as n, DEFAULT_UPLOAD_SIZE_LIMIT as o, VOICE_RECORDER_DEFAULT_MAX as p };
+//# sourceMappingURL=bundle-DhBuJR0w.js.map

package/chunks/bundle-DhBuJR0w.js.map

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

package/chunks/{bundle-BKho3Uub.js → bundle-Dk5y6RzJ.js}

@@ -11,4 +11,4 @@ function compareIds(a, b) {
 }
 
 export { compareIds as c };
-//# sourceMappingURL=bundle-BKho3Uub.js.map
+//# sourceMappingURL=bundle-Dk5y6RzJ.js.map

package/chunks/bundle-Dk5y6RzJ.js.map

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

package/chunks/{bundle-C1ds4cil.js → bundle-DprHnWfH.js}

@@ -483,4 +483,4 @@ var locale = {
 var defaultLocale = locale;
 
 export { defaultLocale as d };
-//# sourceMappingURL=bundle-C1ds4cil.js.map
+//# sourceMappingURL=bundle-DprHnWfH.js.map