@sendbird/uikit-react 3.9.1-rc-0 → 3.9.1-rc-2

package/dist/cjs/chunks/{bundle-uWB1AoIz.js → bundle-ayxcxLwI.js}

@@ -1,18 +1,18 @@
 'use strict';
 
 var React = require('react');
-var Channel_context = require('./bundle-cimsvery.js');
+var Channel_context = require('./bundle-zaeeh2h7.js');
 var ui_PlaceHolder = require('../ui/PlaceHolder.js');
 var ui_Icon = require('../ui/Icon.js');
 var Channel_components_Message = require('../Channel/components/Message.js');
-var utils = require('./bundle-4eGWgY9M.js');
+var utils = require('./bundle-xeTDYh-o.js');
 var Channel_utils_getMessagePartsInfo = require('../Channel/utils/getMessagePartsInfo.js');
 var Channel_components_UnreadCount = require('../Channel/components/UnreadCount.js');
 var Channel_components_FrozenNotification = require('../Channel/components/FrozenNotification.js');
-var consts = require('./bundle-98hUmAMo.js');
+var consts = require('./bundle-Ptyw-8Gc.js');
 var useSendbirdStateContext = require('../useSendbirdStateContext.js');
 var Message_context = require('../Message/context.js');
-var index = require('./bundle-AD4Oflxo.js');
+var index = require('./bundle-gOtrtUIz.js');
 var ui_TypingIndicatorBubble = require('../ui/TypingIndicatorBubble.js');
 var uikitTools = require('@sendbird/uikit-tools');
 
@@ -261,4 +261,4 @@ var MessageList = function (_a) {
 };
 
 exports.MessageList = MessageList;
-//# sourceMappingURL=bundle-uWB1AoIz.js.map
+//# sourceMappingURL=bundle-ayxcxLwI.js.map

package/dist/cjs/chunks/bundle-ayxcxLwI.js.map

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

package/dist/cjs/chunks/{bundle-SiCT4KKh.js → bundle-bQ1hwrcE.js}

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

package/dist/cjs/chunks/bundle-bQ1hwrcE.js.map

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

package/dist/cjs/chunks/{bundle-dR2UsXRP.js → bundle-c8PEMQg3.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var _tslib = require('./bundle-RmtoGD4w.js');
-var index = require('./bundle-CDhpLgdo.js');
+var _tslib = require('./bundle-0pCHXNhB.js');
+var index = require('./bundle-5ApFd_AY.js');
 
 var USER_MENTION_PREFIX = '@';
 
@@ -134,4 +134,4 @@ exports.TOKEN_TYPES = TOKEN_TYPES;
 exports.USER_MENTION_PREFIX = USER_MENTION_PREFIX;
 exports.getWhiteSpacePreservedText = getWhiteSpacePreservedText;
 exports.tokenizeMessage = tokenizeMessage;
-//# sourceMappingURL=bundle-dR2UsXRP.js.map
+//# sourceMappingURL=bundle-c8PEMQg3.js.map

package/dist/cjs/chunks/bundle-c8PEMQg3.js.map

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

package/dist/cjs/chunks/{bundle-DFMVl_Mm.js → bundle-eSkHuU0e.js}

@@ -1,12 +1,12 @@
 'use strict';
 
 var React = require('react');
-var index_module = require('./bundle--sK1aluY.js');
-var tokenize = require('./bundle-dR2UsXRP.js');
+var index_module = require('./bundle-tWIm10AV.js');
+var tokenize = require('./bundle-c8PEMQg3.js');
 var Message_context = require('../Message/context.js');
 var ui_MentionLabel = require('../ui/MentionLabel.js');
 var ui_LinkLabel = require('../ui/LinkLabel.js');
-var ui_Label = require('./bundle-41kBJWv1.js');
+var ui_Label = require('./bundle-4RnnhACR.js');
 
 // this function is used to generate a unique key for token in message
 // it changes with updated time and index
@@ -35,4 +35,4 @@ function TextFragment(_a) {
 }
 
 exports.TextFragment = TextFragment;
-//# sourceMappingURL=bundle-DFMVl_Mm.js.map
+//# sourceMappingURL=bundle-eSkHuU0e.js.map

package/dist/cjs/chunks/bundle-eSkHuU0e.js.map

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

package/dist/cjs/chunks/bundle-fV1pX_hi.js

@@ -0,0 +1,114 @@
+'use strict';
+
+var _tslib = require('./bundle-0pCHXNhB.js');
+var pxToNumber = require('./bundle-NrEnVvdl.js');
+
+var compressImage = function (_a) {
+    var imageFile = _a.imageFile, compressionRate = _a.compressionRate, resizingWidth = _a.resizingWidth, resizingHeight = _a.resizingHeight;
+    var image = document.createElement('img');
+    return new Promise(function (resolve, reject) {
+        image.src = URL.createObjectURL(imageFile);
+        image.onerror = reject;
+        image.onload = function () {
+            URL.revokeObjectURL(image.src);
+            var canvas = document.createElement('canvas');
+            var originWidth = image.width;
+            var originHeight = image.height;
+            var widthRatio = originWidth / (resizingWidth || originWidth);
+            var heightRatio = originHeight / (resizingHeight || originHeight);
+            var targetResizingWidth = resizingWidth || originWidth;
+            var targetResizingHeight = resizingHeight || originHeight;
+            // Use the more impactful value, so the original images' ratio won't be broken
+            if (widthRatio > heightRatio) {
+                targetResizingHeight = originHeight / (resizingWidth ? widthRatio : 1);
+            }
+            else if (heightRatio > widthRatio) {
+                targetResizingWidth = originWidth / (resizingHeight ? heightRatio : 1);
+            }
+            canvas.width = targetResizingWidth;
+            canvas.height = targetResizingHeight;
+            var ctx = canvas.getContext('2d');
+            if (!ctx) {
+                reject(new Error('Failed to get canvas 2d context'));
+                return;
+            }
+            ctx.drawImage(image, 0, 0, targetResizingWidth, targetResizingHeight);
+            ctx.canvas.toBlob(function (blob) {
+                if (blob) {
+                    var file = new File([blob], imageFile.name, { type: imageFile.type });
+                    resolve(file);
+                }
+                else {
+                    reject(new Error('Failed to compress image'));
+                }
+            }, imageFile.type, compressionRate);
+        };
+    });
+};
+var compressImages = function (_a) {
+    var files = _a.files, logger = _a.logger, imageCompression = _a.imageCompression;
+    return _tslib.__awaiter(void 0, void 0, void 0, function () {
+        var compressionRate, resizingWidth, resizingHeight, result;
+        return _tslib.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    compressionRate = imageCompression.compressionRate;
+                    resizingWidth = pxToNumber.pxToNumber(imageCompression.resizingWidth);
+                    resizingHeight = pxToNumber.pxToNumber(imageCompression.resizingHeight);
+                    result = {
+                        failedIndexes: [],
+                        compressedFiles: [],
+                    };
+                    if (!(Array.isArray(files) && files.length > 0)) {
+                        logger.warning('utils - compressImages: There are no files.', files);
+                        return [2 /*return*/, result];
+                    }
+                    if (compressionRate < 0 || 1 < compressionRate) {
+                        logger.warning('utils - compressImages: The compressionRate is not acceptable.', compressionRate);
+                        return [2 /*return*/, result];
+                    }
+                    return [4 /*yield*/, Promise.all(files
+                            .map(function (file, index) { return _tslib.__awaiter(void 0, void 0, void 0, function () {
+                            var compressedImage, err_1;
+                            return _tslib.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!(file.type === 'image/jpg' || file.type === 'image/png' || file.type === 'image/jpeg')) {
+                                            logger.warning('utils - compressImages: The fileType is not compressible.', { file: file, index: index });
+                                            result.failedIndexes.push(index);
+                                            result.compressedFiles.push(file);
+                                            return [2 /*return*/];
+                                        }
+                                        _a.label = 1;
+                                    case 1:
+                                        _a.trys.push([1, 3, , 4]);
+                                        return [4 /*yield*/, compressImage({
+                                                imageFile: file,
+                                                compressionRate: compressionRate,
+                                                resizingWidth: resizingWidth,
+                                                resizingHeight: resizingHeight,
+                                            })];
+                                    case 2:
+                                        compressedImage = _a.sent();
+                                        result.compressedFiles.push(compressedImage);
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        err_1 = _a.sent();
+                                        result.failedIndexes.push(index);
+                                        logger.warning('utils - compressImages: Failed to compress image file', { file: file, err: err_1 });
+                                        return [3 /*break*/, 4];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); }))];
+                case 1:
+                    _b.sent();
+                    logger.info('utils - compressImages: Finished compressing images', result);
+                    return [2 /*return*/, result];
+            }
+        });
+    });
+};
+
+exports.compressImages = compressImages;
+//# sourceMappingURL=bundle-fV1pX_hi.js.map

package/dist/cjs/chunks/bundle-fV1pX_hi.js.map

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

package/dist/cjs/chunks/{bundle-2B2B2GGi.js → bundle-f_lSJlZS.js}

@@ -12,4 +12,4 @@ var uuidv4 = function () { return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace
 }); };
 
 exports.uuidv4 = uuidv4;
-//# sourceMappingURL=bundle-2B2B2GGi.js.map
+//# sourceMappingURL=bundle-f_lSJlZS.js.map

package/dist/cjs/chunks/bundle-f_lSJlZS.js.map

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

package/dist/cjs/chunks/{bundle-AD4Oflxo.js → bundle-gOtrtUIz.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 var React = require('react');
-var consts = require('./bundle-98hUmAMo.js');
+var consts = require('./bundle-Ptyw-8Gc.js');
 
 function useDebounce(callback, delay) {
     var timeoutRef = React.useRef(null);
@@ -72,4 +72,4 @@ function useHandleOnScrollCallback(_a) {
 
 exports.useDebounce = useDebounce;
 exports.useHandleOnScrollCallback = useHandleOnScrollCallback;
-//# sourceMappingURL=bundle-AD4Oflxo.js.map
+//# sourceMappingURL=bundle-gOtrtUIz.js.map

package/dist/cjs/chunks/bundle-gOtrtUIz.js.map

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

package/dist/cjs/chunks/{bundle-NyrRrrQE.js → bundle-ga2lvSm8.js}

@@ -43,4 +43,4 @@ var pubSubTopics = exports.PUBSUB_TOPICS;
 exports.pubSubTopics = pubSubTopics;
 exports.shouldPubSubPublishToChannel = shouldPubSubPublishToChannel;
 exports.shouldPubSubPublishToThread = shouldPubSubPublishToThread;
-//# sourceMappingURL=bundle-NyrRrrQE.js.map
+//# sourceMappingURL=bundle-ga2lvSm8.js.map

package/dist/cjs/chunks/bundle-ga2lvSm8.js.map

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

package/dist/cjs/chunks/{bundle-txKvbPEx.js → bundle-jGjSthM3.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var consts = require('./bundle-98hUmAMo.js');
+var consts = require('./bundle-Ptyw-8Gc.js');
 var lame_all = require('../lame.all.js');
 
 // Thanks to https://codesandbox.io/s/media-recorder-api-downsampling-16k-mp3-encode-using-lame-js-forked-n1pblw
@@ -125,4 +125,4 @@ function bufferToWav(abuffer, len) {
 
 exports.downsampleToWav = downsampleToWav;
 exports.encodeMp3 = encodeMp3;
-//# sourceMappingURL=bundle-txKvbPEx.js.map
+//# sourceMappingURL=bundle-jGjSthM3.js.map

package/dist/cjs/chunks/bundle-jGjSthM3.js.map

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

package/dist/cjs/chunks/{bundle-NBLrSxcj.js → bundle-kbntHY88.js}

@@ -1,15 +1,22 @@
 'use strict';
 
 var React = require('react');
-var index = require('./bundle-isd9KugI.js');
-var UserProfileContext = require('./bundle-O5wLOxN7.js');
-var _tslib = require('./bundle-RmtoGD4w.js');
-var compareIds = require('./bundle-Mswmp_1O.js');
-var pubSub_topics = require('./bundle-NyrRrrQE.js');
+var index = require('./bundle-3CEbSubz.js');
+var UserProfileContext = require('./bundle-Xwc-PXin.js');
+var _tslib = require('./bundle-0pCHXNhB.js');
+var compareIds = require('./bundle-_fpgAJFT.js');
+var pubSub_topics = require('./bundle-ga2lvSm8.js');
 var SendbirdChat = require('@sendbird/chat');
 var openChannel = require('@sendbird/chat/openChannel');
-var uuid = require('./bundle-2B2B2GGi.js');
+var uuid = require('./bundle-f_lSJlZS.js');
+var compressImages = require('./bundle-fV1pX_hi.js');
 var useSendbirdStateContext = require('../useSendbirdStateContext.js');
+var hooks_useModal = require('../hooks/useModal.js');
+var LocalizationContext = require('./bundle--gwwLhzk.js');
+var consts = require('./bundle-Ptyw-8Gc.js');
+var ui_Modal = require('./bundle-2Gla4s_W.js');
+require('./bundle-4RnnhACR.js');
+var ui_Button = require('../ui/Button.js');
 
 var getMessageCreatedAt = function (message) { return index.format(message.createdAt, 'p'); };
 var shouldFetchMore = function (messageLength, maxMessages) {
@@ -108,18 +115,6 @@ var fetchWithListQuery = function (listQuery, logger, eachQueryNextCallback) {
     };
     logger.info('OpenChannel | FetchUserList start', listQuery);
     fetchList(listQuery);
-};
-var pxToNumber = function (px) {
-    if (typeof px === 'number') {
-        return px;
-    }
-    if (typeof px === 'string') {
-        var parsed = Number.parseFloat(px);
-        if (!Number.isNaN(parsed)) {
-            return parsed;
-        }
-    }
-    return null;
 };
 
 var SET_CURRENT_CHANNEL = 'SET_CURRENT_CHANNEL';
@@ -981,145 +976,99 @@ function useSendMessageCallback(_a, _b) {
 }
 
 function useFileUploadCallback(_a, _b) {
+    var _this = this;
     var currentOpenChannel = _a.currentOpenChannel, checkScrollBottom = _a.checkScrollBottom, _c = _a.imageCompression, imageCompression = _c === void 0 ? {} : _c, onBeforeSendFileMessage = _a.onBeforeSendFileMessage;
     var sdk = _b.sdk, logger = _b.logger, messagesDispatcher = _b.messagesDispatcher, scrollRef = _b.scrollRef;
-    return React.useCallback(function (files) {
-        if (sdk) {
-            /**
-             * OpenChannel does not currently support file lists.
-             * However, this change is made to maintain interface consistency with group channels.
-             */
-            var file_1 = Array.isArray(files) ? files[0] : files;
-            var compressionRate_1 = imageCompression.compressionRate, resizingWidth_1 = imageCompression.resizingWidth, resizingHeight_1 = imageCompression.resizingHeight;
-            var createCustomParams_1 = onBeforeSendFileMessage && typeof onBeforeSendFileMessage === 'function';
-            var compressibleFileType = (file_1.type === 'image/jpg' || file_1.type === 'image/png' || file_1.type === 'image/jpeg');
-            var compressibleRatio = (compressionRate_1 > 0) && (compressionRate_1 < 1);
-            // pxToNumber returns null if values are invalid
-            var compressibleDiamensions_1 = pxToNumber(resizingWidth_1)
-                || pxToNumber(resizingHeight_1);
-            var canCompressImage = compressibleFileType && (compressibleRatio || compressibleDiamensions_1);
-            var createParamsDefault_1 = function (file_) {
-                var params = {};
-                params.file = file_;
-                return params;
-            };
-            if (canCompressImage) { // Using image compression
-                try {
-                    var image_1 = document.createElement('img');
-                    image_1.src = URL.createObjectURL(file_1);
-                    image_1.onload = function () {
-                        URL.revokeObjectURL(image_1.src);
-                        var canvas = document.createElement('canvas');
-                        var imageWidth = image_1.naturalWidth || image_1.width;
-                        var imageHeight = image_1.naturalHeight || image_1.height;
-                        var targetWidth = pxToNumber(resizingWidth_1) || imageWidth;
-                        var targetHeight = pxToNumber(resizingHeight_1) || imageHeight;
-                        // In canvas.toBlob(callback, mimeType, qualityArgument)
-                        // qualityArgument doesnt work
-                        // so in case compressibleDiamensions are not present, we use ratio
-                        if (file_1.type === 'image/png' && !compressibleDiamensions_1) {
-                            targetWidth *= compressionRate_1;
-                            targetHeight *= compressionRate_1;
-                        }
-                        canvas.width = targetWidth;
-                        canvas.height = targetHeight;
-                        var context = canvas.getContext('2d');
-                        context.drawImage(image_1, 0, 0, targetWidth, targetHeight);
-                        context.canvas.toBlob(function (newImageBlob) {
-                            var compressedFile = new File([newImageBlob], file_1.name, { type: file_1.type });
-                            if (createCustomParams_1) {
-                                logger.info('OpenChannel | useFileUploadCallback: Creating params using onBeforeSendFileMessage', onBeforeSendFileMessage);
-                            }
-                            var params = onBeforeSendFileMessage ? onBeforeSendFileMessage(compressedFile) : createParamsDefault_1(compressedFile);
-                            logger.info('OpenChannel | useFileUploadCallback: Uploading file message start', params);
-                            var isBottom = checkScrollBottom();
-                            currentOpenChannel.sendFileMessage(params)
-                                .onPending(function (pendingMessage) {
-                                messagesDispatcher({
-                                    type: SENDING_MESSAGE_START,
-                                    payload: {
-                                        message: _tslib.__assign(_tslib.__assign({}, pendingMessage), { url: URL.createObjectURL(file_1), 
-                                            // pending thumbnail message seems to be failed
-                                            requestState: 'pending' }),
-                                        channel: currentOpenChannel,
-                                    },
-                                });
-                            })
-                                .onSucceeded(function (message) {
-                                logger.info('OpenChannel | useFileUploadCallback: Sending message succeeded', message);
-                                messagesDispatcher({
-                                    type: SENDING_MESSAGE_SUCCEEDED,
-                                    payload: message,
-                                });
-                                if (isBottom) {
-                                    setTimeout(function () {
-                                        scrollIntoLast(0, scrollRef);
-                                    });
-                                }
-                            })
-                                .onFailed(function (error, message) {
-                                logger.error('OpenChannel | useFileUploadCallback: Sending file message failed', { message: message, error: error });
-                                // @ts-ignore
-                                message.localUrl = URL.createObjectURL(file_1);
-                                // @ts-ignore
-                                message.file = file_1;
-                                messagesDispatcher({
-                                    type: SENDING_MESSAGE_FAILED,
-                                    payload: message,
-                                });
-                            });
-                        }, file_1.type, compressionRate_1);
+    var stringSet = LocalizationContext.useLocalization().stringSet;
+    var openModal = hooks_useModal.useGlobalModalContext().openModal;
+    var config = useSendbirdStateContext.useSendbirdStateContext().config;
+    var uikitUploadSizeLimit = config.uikitUploadSizeLimit;
+    return React.useCallback(function (files) { return _tslib.__awaiter(_this, void 0, void 0, function () {
+        var file_1, createCustomParams, createParamsDefault, compressedFiles, compressedFile, params, isBottom_1;
+        return _tslib.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!sdk) return [3 /*break*/, 2];
+                    file_1 = Array.isArray(files) ? files[0] : files;
+                    createCustomParams = onBeforeSendFileMessage && typeof onBeforeSendFileMessage === 'function';
+                    createParamsDefault = function (file_) {
+                        var params = {};
+                        params.file = file_;
+                        return params;
                     };
-                }
-                catch (error) {
-                    logger.warning('OpenChannel | useFileUploadCallback: Sending file message with image compression failed', error);
-                }
-            }
-            else { // Not using image compression
-                if (createCustomParams_1) {
-                    logger.info('OpenChannel | useFileUploadCallback: Creating params using onBeforeSendFileMessage', onBeforeSendFileMessage);
-                }
-                var params = onBeforeSendFileMessage ? onBeforeSendFileMessage(file_1) : createParamsDefault_1(file_1);
-                logger.info('OpenChannel | useFileUploadCallback: Uploading file message start', params);
-                var isBottom_1 = checkScrollBottom();
-                currentOpenChannel.sendFileMessage(params)
-                    .onPending(function (pendingMessage) {
-                    messagesDispatcher({
-                        type: SENDING_MESSAGE_START,
-                        payload: {
-                            message: _tslib.__assign(_tslib.__assign({}, pendingMessage), { url: URL.createObjectURL(file_1), 
-                                // pending thumbnail message seems to be failed
-                                requestState: 'pending' }),
-                            channel: currentOpenChannel,
-                        },
-                    });
-                })
-                    .onSucceeded(function (message) {
-                    logger.info('OpenChannel | useFileUploadCallback: Sending message succeeded', message);
-                    messagesDispatcher({
-                        type: SENDING_MESSAGE_SUCCEEDED,
-                        payload: message,
-                    });
-                    if (isBottom_1) {
-                        setTimeout(function () {
-                            scrollIntoLast(0, scrollRef);
+                    /**
+                     * Validate file sizes
+                     * The default value of uikitUploadSizeLimit is 25MiB
+                     */
+                    if (file_1.size > uikitUploadSizeLimit) {
+                        logger.info("OpenChannel | useFileUploadCallback: Cannot upload file size exceeding ".concat(uikitUploadSizeLimit));
+                        openModal({
+                            modalProps: {
+                                titleText: stringSet.FILE_UPLOAD_NOTIFICATION__SIZE_LIMIT.replace('%d', "".concat(Math.floor(uikitUploadSizeLimit / consts.ONE_MiB))),
+                                hideFooter: true,
+                            },
+                            childElement: function (_a) {
+                                var closeModal = _a.closeModal;
+                                return (React.createElement(ui_Modal.ModalFooter, { type: ui_Button.ButtonTypes.PRIMARY, submitText: stringSet.BUTTON__OK, hideCancelButton: true, onCancel: closeModal, onSubmit: closeModal }));
+                            },
                         });
+                        return [2 /*return*/];
                     }
-                })
-                    .onFailed(function (error, message) {
-                    logger.error('OpenChannel | useFileUploadCallback: Sending file message failed', { message: message, error: error });
-                    // @ts-ignore
-                    message.localUrl = URL.createObjectURL(file_1);
-                    // @ts-ignore
-                    message.file = file_1;
-                    messagesDispatcher({
-                        type: SENDING_MESSAGE_FAILED,
-                        payload: message,
+                    return [4 /*yield*/, compressImages.compressImages({
+                            files: [file_1],
+                            imageCompression: imageCompression,
+                            logger: logger,
+                        })];
+                case 1:
+                    compressedFiles = (_a.sent()).compressedFiles;
+                    compressedFile = compressedFiles[0];
+                    // Send FileMessage
+                    if (createCustomParams) {
+                        logger.info('OpenChannel | useFileUploadCallback: Creating params using onBeforeSendFileMessage', onBeforeSendFileMessage);
+                    }
+                    params = onBeforeSendFileMessage ? onBeforeSendFileMessage(compressedFile) : createParamsDefault(compressedFile);
+                    logger.info('OpenChannel | useFileUploadCallback: Uploading file message start', params);
+                    isBottom_1 = checkScrollBottom();
+                    currentOpenChannel.sendFileMessage(params)
+                        .onPending(function (pendingMessage) {
+                        messagesDispatcher({
+                            type: SENDING_MESSAGE_START,
+                            payload: {
+                                message: _tslib.__assign(_tslib.__assign({}, pendingMessage), { url: URL.createObjectURL(file_1), 
+                                    // pending thumbnail message seems to be failed
+                                    requestState: 'pending' }),
+                                channel: currentOpenChannel,
+                            },
+                        });
+                    })
+                        .onSucceeded(function (message) {
+                        logger.info('OpenChannel | useFileUploadCallback: Sending message succeeded', message);
+                        messagesDispatcher({
+                            type: SENDING_MESSAGE_SUCCEEDED,
+                            payload: message,
+                        });
+                        if (isBottom_1) {
+                            setTimeout(function () {
+                                scrollIntoLast(0, scrollRef);
+                            });
+                        }
+                    })
+                        .onFailed(function (error, message) {
+                        logger.error('OpenChannel | useFileUploadCallback: Sending file message failed', { message: message, error: error });
+                        // @ts-ignore
+                        message.localUrl = URL.createObjectURL(file_1);
+                        // @ts-ignore
+                        message.file = file_1;
+                        messagesDispatcher({
+                            type: SENDING_MESSAGE_FAILED,
+                            payload: message,
+                        });
                     });
-                });
+                    _a.label = 2;
+                case 2: return [2 /*return*/];
             }
-        }
-    }, [currentOpenChannel, onBeforeSendFileMessage, checkScrollBottom, imageCompression]);
+        });
+    }); }, [currentOpenChannel, onBeforeSendFileMessage, checkScrollBottom, imageCompression]);
 }
 
 function useUpdateMessageCallback(_a, _b) {
@@ -1457,4 +1406,4 @@ exports.OpenChannelProvider = OpenChannelProvider;
 exports.compareMessagesForGrouping = compareMessagesForGrouping;
 exports.kFormatter = kFormatter;
 exports.useOpenChannelContext = useOpenChannelContext;
-//# sourceMappingURL=bundle-NBLrSxcj.js.map
+//# sourceMappingURL=bundle-kbntHY88.js.map

package/dist/cjs/chunks/{bundle-NBLrSxcj.js.map → bundle-kbntHY88.js.map}

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

package/dist/cjs/chunks/{bundle-PwiP9Ezo.js → bundle-oTWBtf3l.js}

@@ -507,4 +507,4 @@ var locale = {
 var defaultLocale = locale;
 
 exports.defaultLocale = defaultLocale;
-//# sourceMappingURL=bundle-PwiP9Ezo.js.map
+//# sourceMappingURL=bundle-oTWBtf3l.js.map