@sendbird/uikit-react 3.14.5 → 3.14.6

package/cjs/chunks/{bundle-B1uXZFKP.js → bundle-BE-L5873.js}

@@ -1,20 +1,20 @@
 'use strict';
 
 var React = require('react');
-var _tslib = require('./bundle-C-r9vRgc.js');
+var _tslib = require('./bundle-eTYC1RPT.js');
 var message = require('@sendbird/chat/message');
 var useSendbirdStateContext = require('../useSendbirdStateContext.js');
 var ui_Icon = require('../ui/Icon.js');
 var ui_ImageRenderer = require('../ui/ImageRenderer.js');
-var index = require('./bundle-Cw7xe6J1.js');
-var ui_FileViewer = require('./bundle-IZLtKe6R.js');
+var index = require('./bundle-DrYI_bNa.js');
+var ui_FileViewer = require('./bundle-CTraI7aM.js');
 
 function ImageGrid(_a) {
     var _b;
     var children = _a.children, className = _a.className, message = _a.message, isReactionEnabled = _a.isReactionEnabled;
     return (React.createElement("div", { className: 'sendbird-image-grid-wrap' },
         React.createElement("div", { className: index.getClassName([
-                className,
+                className !== null && className !== void 0 ? className : '',
                 'sendbird-image-grid',
                 (isReactionEnabled && ((_b = message === null || message === void 0 ? void 0 : message.reactions) === null || _b === void 0 ? void 0 : _b.length) > 0) ? 'reactions' : '',
             ]) }, children)));
@@ -70,16 +70,15 @@ function MultipleFilesMessageItemBody(_a) {
     function onClickRight() {
         setCurrentFileViewerIndex(currentFileViewerIndex === statefulFileInfoList.length - 1 ? 0 : currentFileViewerIndex + 1);
     }
-    return (threadMessageKindKey && (React.createElement(React.Fragment, null,
+    return (threadMessageKindKey ? (React.createElement(React.Fragment, null,
         currentFileViewerIndex > -1 && (React.createElement(ui_FileViewer.FileViewer, { message: message$1, statefulFileInfoList: statefulFileInfoList, currentIndex: currentFileViewerIndex, onClickLeft: onClickLeft, onClickRight: onClickRight, onClose: onClose, onDownloadClick: function (e) { return _tslib.__awaiter(_this, void 0, void 0, function () {
                 var allowDownload, err_1;
                 var _a, _b;
                 return _tslib.__generator(this, function (_c) {
                     switch (_c.label) {
                         case 0:
-                            if (!onBeforeDownloadFileMessage) {
-                                return [2 /*return*/, null];
-                            }
+                            if (!onBeforeDownloadFileMessage)
+                                return [2 /*return*/];
                             _c.label = 1;
                         case 1:
                             _c.trys.push([1, 3, , 4]);
@@ -100,15 +99,15 @@ function MultipleFilesMessageItemBody(_a) {
                 });
             }); } })),
         React.createElement(ImageGrid, { className: className, message: message$1, isReactionEnabled: isReactionEnabled }, statefulFileInfoList.map(function (fileInfo, index$1) {
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             return (React.createElement("div", { className: "sendbird-multiple-files-image-renderer-wrapper", onClick: message$1.sendingStatus === message.SendingStatus.SUCCEEDED ? function () { return setCurrentFileViewerIndex(index$1); } : undefined, key: "sendbird-multiple-files-image-renderer-".concat(index$1, "-").concat(fileInfo.url) },
-                React.createElement(ui_ImageRenderer.default, { url: (_c = (_b = (_a = fileInfo.thumbnails) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.url) !== null && _c !== void 0 ? _c : fileInfo.url, fixedSize: false, width: MULTIPLE_FILES_IMAGE_SIDE_LENGTH[threadMessageKindKey], maxSideLength: MULTIPLE_FILES_IMAGE_SIDE_LENGTH.CHAT_WEB, height: MULTIPLE_FILES_IMAGE_SIDE_LENGTH[threadMessageKindKey], borderRadius: ui_ImageRenderer.getBorderRadiusForMultipleImageRenderer(MULTIPLE_FILES_IMAGE_BORDER_RADIUS[threadMessageKindKey], index$1, statefulFileInfoList.length), shadeOnHover: true, isUploaded: !!fileInfo.isUploaded, placeHolder: function (_a) {
+                React.createElement(ui_ImageRenderer.default, { url: (_d = (_c = (_b = (_a = fileInfo.thumbnails) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.url) !== null && _c !== void 0 ? _c : fileInfo.url) !== null && _d !== void 0 ? _d : '', fixedSize: false, width: MULTIPLE_FILES_IMAGE_SIDE_LENGTH[threadMessageKindKey], maxSideLength: MULTIPLE_FILES_IMAGE_SIDE_LENGTH.CHAT_WEB, height: MULTIPLE_FILES_IMAGE_SIDE_LENGTH[threadMessageKindKey], borderRadius: ui_ImageRenderer.getBorderRadiusForMultipleImageRenderer(MULTIPLE_FILES_IMAGE_BORDER_RADIUS[threadMessageKindKey], index$1, statefulFileInfoList.length), shadeOnHover: true, isUploaded: !!fileInfo.isUploaded, placeHolder: function (_a) {
                         var style = _a.style;
-                        if (index.isGif(fileInfo.mimeType))
+                        if (fileInfo.mimeType && index.isGif(fileInfo.mimeType))
                             return React.createElement(ImagePlaceholder.GIF, { style: style });
                         return React.createElement(ImagePlaceholder.Default, { style: style });
                     }, defaultComponent: React.createElement(ImagePlaceholder.LoadError, null) })));
-        })))));
+        })))) : React.createElement(React.Fragment, null));
 }
 var ImagePlaceholder = {
     Default: function (_a) {
@@ -146,6 +145,7 @@ function useThreadMessageKindKeySelector(_a) {
 // SendingStatus.SCHEDULED is currently not covered in UIKit
 //  So we can ignore for now, but for future, it is better to explicitly use PENDING, FAILED, or CANCELED.
 var useFileInfoListWithUploaded = function (message$1) {
+    var _a, _b;
     var blobHandler = React.useRef(new Map());
     var getObjectURL = function (index, blob) {
         if (!blobHandler.current.has(index) && blob)
@@ -166,13 +166,16 @@ var useFileInfoListWithUploaded = function (message$1) {
     }
     else if (message$1.sendingStatus === message.SendingStatus.SUCCEEDED) {
         revokeURLs();
-        return message$1.fileInfoList.map(function (it) { return (_tslib.__assign(_tslib.__assign({}, it), { url: it.url, isUploaded: true })); });
+        return message$1.fileInfoList.map(function (it) {
+            var _a, _b;
+            return (_tslib.__assign(_tslib.__assign({}, it), { url: it.url, isUploaded: true, mimeType: (_a = it.mimeType) !== null && _a !== void 0 ? _a : undefined, fileName: (_b = it.fileName) !== null && _b !== void 0 ? _b : undefined }));
+        });
     }
     else {
-        return message$1.messageParams.fileInfoList.map(function (it, index) {
+        return (_b = (_a = message$1 === null || message$1 === void 0 ? void 0 : message$1.messageParams) === null || _a === void 0 ? void 0 : _a.fileInfoList.map(function (it, index) {
             var _a, _b;
             return (_tslib.__assign(_tslib.__assign({}, it), { url: (_b = (_a = getObjectURL(index)) !== null && _a !== void 0 ? _a : it.fileUrl) !== null && _b !== void 0 ? _b : (it.file instanceof Blob ? getObjectURL(index, it.file) : undefined), isUploaded: !it.file && typeof it.fileUrl === 'string' && it.fileUrl.length > 0 }));
-        });
+        })) !== null && _b !== void 0 ? _b : [];
     }
 };
 
@@ -180,4 +183,4 @@ exports.MultipleFilesMessageItemBody = MultipleFilesMessageItemBody;
 exports.ThreadMessageKind = ThreadMessageKind;
 exports.useFileInfoListWithUploaded = useFileInfoListWithUploaded;
 exports.useThreadMessageKindKeySelector = useThreadMessageKindKeySelector;
-//# sourceMappingURL=bundle-B1uXZFKP.js.map
+//# sourceMappingURL=bundle-BE-L5873.js.map

package/cjs/chunks/{bundle-B1uXZFKP.js.map → bundle-BE-L5873.js.map}

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

package/cjs/chunks/{bundle-DZMn5ScB.js → bundle-BE1dAigY.js}

@@ -2,11 +2,11 @@
 
 var React = require('react');
 var reactDom = require('react-dom');
-var ui_Avatar = require('./bundle-C0ZNrrcl.js');
+var ui_Avatar = require('./bundle-C_8UQBXr.js');
 var ui_Icon = require('../ui/Icon.js');
-var ui_Label = require('./bundle-Deao1Upp.js');
-var index = require('./bundle-Cw7xe6J1.js');
-var ui_Modal = require('./bundle-DJ9gapN2.js');
+var ui_Label = require('./bundle-DY5rfl6W.js');
+var index = require('./bundle-DrYI_bNa.js');
+var ui_Modal = require('./bundle-DW8u-n3u.js');
 var useSendbirdStateContext = require('../useSendbirdStateContext.js');
 
 var FileViewerView = function (_a) {
@@ -14,7 +14,7 @@ var FileViewerView = function (_a) {
     var sender = message.sender, type = message.type, url = message.url, _b = message.name, name = _b === void 0 ? '' : _b, threadInfo = message.threadInfo;
     var profileUrl = sender.profileUrl, nickname = sender.nickname, userId = sender.userId;
     var config = useSendbirdStateContext.useSendbirdStateContext().config;
-    return reactDom.createPortal(React.createElement(FileViewerComponent, { profileUrl: profileUrl, nickname: nickname, type: type, url: url, name: name, onCancel: onCancel, onDelete: function () { return deleteMessage(message).then(function () { return onCancel(); }); }, isByMe: config.userId === userId, disableDelete: (threadInfo === null || threadInfo === void 0 ? void 0 : threadInfo.replyCount) > 0, onDownloadClick: onDownloadClick }), document.getElementById(ui_Modal.MODAL_ROOT));
+    return reactDom.createPortal(React.createElement(FileViewerComponent, { profileUrl: profileUrl, nickname: nickname, type: type, url: url, name: name, onCancel: onCancel, onDelete: function () { return deleteMessage(message).then(function () { return onCancel(); }); }, isByMe: config.userId === userId, disableDelete: (threadInfo === null || threadInfo === void 0 ? void 0 : threadInfo.replyCount) ? threadInfo.replyCount > 0 : false, onDownloadClick: onDownloadClick }), document.getElementById(ui_Modal.MODAL_ROOT));
 };
 var FileViewerComponent = function (_a) {
     var 
@@ -52,4 +52,4 @@ var FileViewerComponent = function (_a) {
 };
 
 exports.FileViewerView = FileViewerView;
-//# sourceMappingURL=bundle-DZMn5ScB.js.map
+//# sourceMappingURL=bundle-BE1dAigY.js.map

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

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

package/cjs/chunks/{bundle-Ci6F_UQc.js → bundle-BFy8_d3W.js}

@@ -8,4 +8,4 @@ var Role = {
 };
 
 exports.Role = Role;
-//# sourceMappingURL=bundle-Ci6F_UQc.js.map
+//# sourceMappingURL=bundle-BFy8_d3W.js.map

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

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

package/cjs/chunks/{bundle-CcmMvK6l.js → bundle-BK_SqbHE.js}

@@ -13,4 +13,4 @@ function compareIds(a, b) {
 }
 
 exports.compareIds = compareIds;
-//# sourceMappingURL=bundle-CcmMvK6l.js.map
+//# sourceMappingURL=bundle-BK_SqbHE.js.map

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

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

package/cjs/chunks/{bundle-8IuV93EV.js → bundle-BLs0JcXs.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-DTzydpqA.js');
+var _tslib = require('./bundle-eTYC1RPT.js');
+var compareIds = require('./bundle-BK_SqbHE.js');
+var pubSub_topics = require('./bundle-7CEyuoln.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-YRiE_c63.js');
+var compressImages = require('./bundle-C1YuUjH3.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-DW8u-n3u.js');
+var LocalizationContext = require('./bundle-OWb8eJt-.js');
+var consts = require('./bundle-BNzVVkzd.js');
+require('./bundle-DY5rfl6W.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-BLs0JcXs.js.map

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

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

package/cjs/chunks/{bundle-DWBc-Yv7.js → bundle-BNMoxGCr.js}

@@ -236,4 +236,4 @@ var getStringSet = function (lang) {
 };
 
 exports.getStringSet = getStringSet;
-//# sourceMappingURL=bundle-DWBc-Yv7.js.map
+//# sourceMappingURL=bundle-BNMoxGCr.js.map

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

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

package/cjs/chunks/{bundle-Ca7xeBTO.js → bundle-BNzVVkzd.js}

@@ -30,6 +30,7 @@ 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
@@ -39,6 +40,7 @@ exports.BROWSER_SUPPORT_MIME_TYPE_LIST = BROWSER_SUPPORT_MIME_TYPE_LIST;
 exports.CACHED_MESSAGE_TEMPLATES_KEY = CACHED_MESSAGE_TEMPLATES_KEY;
 exports.CACHED_MESSAGE_TEMPLATES_TOKEN_KEY = CACHED_MESSAGE_TEMPLATES_TOKEN_KEY;
 exports.DEFAULT_MULTIPLE_FILES_MESSAGE_LIMIT = DEFAULT_MULTIPLE_FILES_MESSAGE_LIMIT;
+exports.DEFAULT_UPLOAD_SIZE_LIMIT = DEFAULT_UPLOAD_SIZE_LIMIT;
 exports.DELIVERY_RECEIPT = DELIVERY_RECEIPT;
 exports.META_ARRAY_MESSAGE_TYPE_KEY = META_ARRAY_MESSAGE_TYPE_KEY;
 exports.META_ARRAY_MESSAGE_TYPE_VALUE__VOICE = META_ARRAY_MESSAGE_TYPE_VALUE__VOICE;
@@ -57,4 +59,4 @@ exports.VOICE_RECORDER_AUDIO_SAMPLE_RATE = VOICE_RECORDER_AUDIO_SAMPLE_RATE;
 exports.VOICE_RECORDER_CLICK_BUFFER_TIME = VOICE_RECORDER_CLICK_BUFFER_TIME;
 exports.VOICE_RECORDER_DEFAULT_MAX = VOICE_RECORDER_DEFAULT_MAX;
 exports.VOICE_RECORDER_DEFAULT_MIN = VOICE_RECORDER_DEFAULT_MIN;
-//# sourceMappingURL=bundle-Ca7xeBTO.js.map
+//# sourceMappingURL=bundle-BNzVVkzd.js.map

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

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