@sendbird/uikit-react 3.18.3 → 3.19.0

package/cjs/chunks/{bundle-CJ0UXnTP.js → bundle-9zR07pOD.js}

@@ -1,14 +1,14 @@
 'use strict';
 
 var React = require('react');
-var _tslib = require('./bundle-BGe3zkmE.js');
+var _tslib = require('./bundle-Cy2hoAU0.js');
 var message = require('@sendbird/chat/message');
 var ui_Icon = require('../ui/Icon.js');
 var ui_ImageRenderer = require('../ui/ImageRenderer.js');
-var index = require('./bundle-B2X1DIz7.js');
+var index = require('./bundle-IiaDOxN6.js');
 var ui_FileViewer = require('../ui/FileViewer.js');
-var useSendbird = require('./bundle-ZMriK7oQ.js');
-var index$1 = require('./bundle-C-JicQq3.js');
+var useSendbird = require('./bundle-4i_6rq-O.js');
+var index$1 = require('./bundle-D0OvVO0x.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -187,4 +187,4 @@ exports.MultipleFilesMessageItemBody = MultipleFilesMessageItemBody;
 exports.ThreadMessageKind = ThreadMessageKind;
 exports.useFileInfoListWithUploaded = useFileInfoListWithUploaded;
 exports.useThreadMessageKindKeySelector = useThreadMessageKindKeySelector;
-//# sourceMappingURL=bundle-CJ0UXnTP.js.map
+//# sourceMappingURL=bundle-9zR07pOD.js.map

package/cjs/chunks/bundle-9zR07pOD.js.map

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

package/cjs/chunks/{bundle-CFlDhpYt.js → bundle-B5uT2q49.js}

@@ -27,4 +27,4 @@ var copyToClipboard = function (text) {
 };
 
 exports.copyToClipboard = copyToClipboard;
-//# sourceMappingURL=bundle-CFlDhpYt.js.map
+//# sourceMappingURL=bundle-B5uT2q49.js.map

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

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

package/cjs/chunks/{bundle-HkBDm4Qf.js → bundle-BMgWqiBJ.js}

@@ -1,15 +1,15 @@
 'use strict';
 
-var _tslib = require('./bundle-BGe3zkmE.js');
+var _tslib = require('./bundle-Cy2hoAU0.js');
 var React = require('react');
 var ui_Icon = require('../ui/Icon.js');
 var ui_ChannelAvatar = require('../ui/ChannelAvatar.js');
-var utils = require('./bundle-RsvHcqa6.js');
-var MediaQueryContext = require('./bundle-L4FAt7Cn.js');
-var LocalizationContext = require('./bundle-gK1bSKqR.js');
+var utils = require('./bundle-BWiJUwnR.js');
+var MediaQueryContext = require('./bundle-8bzXq37f.js');
+var LocalizationContext = require('./bundle-DJ-JijOD.js');
 var ui_Header = require('../ui/Header.js');
-var utils$1 = require('./bundle-D7y7huIH.js');
-var useSendbird = require('./bundle-ZMriK7oQ.js');
+var utils$1 = require('./bundle-Dl83958K.js');
+var useSendbird = require('./bundle-4i_6rq-O.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -36,4 +36,4 @@ var GroupChannelHeaderView = function (_a) {
 };
 
 exports.GroupChannelHeaderView = GroupChannelHeaderView;
-//# sourceMappingURL=bundle-HkBDm4Qf.js.map
+//# sourceMappingURL=bundle-BMgWqiBJ.js.map

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

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

package/cjs/chunks/{bundle-Dtj1g5uX.js → bundle-BNMzEs3-.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var index$1 = require('./bundle-B2X1DIz7.js');
-var index = require('./bundle-C-JicQq3.js');
+var index$1 = require('./bundle-IiaDOxN6.js');
+var index = require('./bundle-D0OvVO0x.js');
 
 function getModalDeleteMessageTitle(stringSet, message) {
     return index.K(message)
@@ -15,4 +15,4 @@ function getModalDeleteMessageTitle(stringSet, message) {
 }
 
 exports.getModalDeleteMessageTitle = getModalDeleteMessageTitle;
-//# sourceMappingURL=bundle-Dtj1g5uX.js.map
+//# sourceMappingURL=bundle-BNMzEs3-.js.map

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

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

package/cjs/chunks/{bundle-7z8ksUr-.js → bundle-BNrXNyB4.js}

@@ -1,18 +1,18 @@
 'use strict';
 
-var _tslib = require('./bundle-BGe3zkmE.js');
+var _tslib = require('./bundle-Cy2hoAU0.js');
 var React = require('react');
 var SendbirdChat = require('@sendbird/chat');
-var LocalizationContext = require('./bundle-gK1bSKqR.js');
+var LocalizationContext = require('./bundle-DJ-JijOD.js');
 var ui_Button = require('../ui/Button.js');
-var UserListItemMenu = require('./bundle-iwJrfGij.js');
+var UserListItemMenu = require('./bundle-CN6TJubV.js');
 var ui_UserListItem = require('../ui/UserListItem.js');
-var ui_Modal = require('./bundle-BNBSN8J4.js');
-var utils = require('./bundle-D7y7huIH.js');
-var index = require('./bundle-D2spSJZz.js');
-var useChannelSettings = require('./bundle-DUcsQrAm.js');
-require('./bundle-C4xnXl2z.js');
-var useSendbird = require('./bundle-ZMriK7oQ.js');
+var ui_Modal = require('./bundle-CLX5eMdj.js');
+var utils = require('./bundle-Dl83958K.js');
+var index = require('./bundle-5_FBmAmW.js');
+var useChannelSettings = require('./bundle-ClrkzepM.js');
+require('./bundle-DE8Y9-kK.js');
+var useSendbird = require('./bundle-4i_6rq-O.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -266,4 +266,4 @@ var MemberList = function (_a) {
 };
 
 exports.MemberList = MemberList;
-//# sourceMappingURL=bundle-7z8ksUr-.js.map
+//# sourceMappingURL=bundle-BNrXNyB4.js.map

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

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

package/cjs/chunks/{bundle-BXiW6k4J.js → bundle-BRlDLBbF.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-BXiW6k4J.js.map
+//# sourceMappingURL=bundle-BRlDLBbF.js.map

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

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

package/cjs/chunks/{bundle-Cg7kcMQx.js → bundle-BTygW3-K.js}

@@ -1,16 +1,16 @@
 'use strict';
 
 var React = require('react');
-var ui_Label = require('./bundle-C4xnXl2z.js');
+var ui_Label = require('./bundle-DE8Y9-kK.js');
 var ui_Icon = require('../ui/Icon.js');
-var ui_Avatar = require('./bundle-CyGPqsX6.js');
-var LocalizationContext = require('./bundle-gK1bSKqR.js');
-var uuid = require('./bundle-CtNsx3WQ.js');
-var utils = require('./bundle-D7y7huIH.js');
-var _const$1 = require('./bundle-Ciqscdyw.js');
-var _const = require('./bundle-BFD7OOOw.js');
-var _tslib = require('./bundle-BGe3zkmE.js');
-var useSendbird = require('./bundle-ZMriK7oQ.js');
+var ui_Avatar = require('./bundle-BtEpJHeW.js');
+var LocalizationContext = require('./bundle-DJ-JijOD.js');
+var uuid = require('./bundle-Bb8Gf8D6.js');
+var utils = require('./bundle-Dl83958K.js');
+var _const$1 = require('./bundle-BasyRNED.js');
+var _const = require('./bundle-BmTqH53r.js');
+var _tslib = require('./bundle-Cy2hoAU0.js');
+var useSendbird = require('./bundle-4i_6rq-O.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -179,4 +179,4 @@ var SuggestedMentionListView = function (props) {
 };
 
 exports.SuggestedMentionListView = SuggestedMentionListView;
-//# sourceMappingURL=bundle-Cg7kcMQx.js.map
+//# sourceMappingURL=bundle-BTygW3-K.js.map

package/cjs/chunks/bundle-BTygW3-K.js.map

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

package/cjs/chunks/{bundle-aWBgGjMg.js → bundle-BUvZj7cQ.js}

@@ -1,21 +1,21 @@
 'use strict';
 
-var _tslib = require('./bundle-BGe3zkmE.js');
+var _tslib = require('./bundle-Cy2hoAU0.js');
 var React = require('react');
 var message = require('@sendbird/chat/message');
-var utils = require('./bundle-sL0KYRBS.js');
-var UserProfileContext = require('./bundle-LzK214OE.js');
-var SendbirdContext = require('./bundle-CIRlgPaD.js');
+var utils = require('./bundle-BXkr0YUW.js');
+var UserProfileContext = require('./bundle-CBsIaz1F.js');
+var SendbirdContext = require('./bundle-1o4tJ2ll.js');
 var SendbirdChat = require('@sendbird/chat');
 var groupChannel = require('@sendbird/chat/groupChannel');
-var uuid = require('./bundle-CtNsx3WQ.js');
-var compareIds = require('./bundle-ClEp9fdZ.js');
+var uuid = require('./bundle-Bb8Gf8D6.js');
+var compareIds = require('./bundle-D8Sq196Q.js');
 var uikitTools = require('@sendbird/uikit-tools');
 var Thread_context_types = require('../Thread/context/types.js');
-var useSendbird = require('./bundle-ZMriK7oQ.js');
-var useDeepCompareEffect = require('./bundle-BCLFAROV.js');
-var pubSub_topics = require('./bundle-ofAyqBnL.js');
-var consts = require('./bundle-tSDh-1k7.js');
+var useSendbird = require('./bundle-4i_6rq-O.js');
+var useDeepCompareEffect = require('./bundle-DBejULtB.js');
+var pubSub_topics = require('./bundle-DuVexw6o.js');
+var consts = require('./bundle-DET4Uytg.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -45,16 +45,18 @@ function useToggleReactionCallback(_a, _b) {
 var scrollToLastAfterSend = function () {
     setTimeout(function () { return utils.scrollIntoLast(); }, consts.SCROLL_BOTTOM_DELAY_FOR_SEND);
 };
-var attachLocalFilePreview = function (pendingMessage, file) {
+var attachLocalFilePreview = function (pendingMessage, file, localFilePreviews) {
     var localUrl = URL.createObjectURL(file);
     var localFileMessage = pendingMessage;
     localFileMessage.localUrl = localUrl;
     localFileMessage.file = file;
+    if (pendingMessage.reqId)
+        localFilePreviews.set(pendingMessage.reqId, { localUrl: localUrl, file: file });
     return localUrl;
 };
 function useThreadMessageActions(state, _a) {
     var logger = _a.logger, pubSub = _a.pubSub, isMentionEnabled = _a.isMentionEnabled;
-    var currentChannel = state.currentChannel, onBeforeSendUserMessage = state.onBeforeSendUserMessage, onBeforeSendFileMessage = state.onBeforeSendFileMessage, onBeforeSendVoiceMessage = state.onBeforeSendVoiceMessage, onBeforeSendMultipleFilesMessage = state.onBeforeSendMultipleFilesMessage, dsSendUserMessage = state.dsSendUserMessage, dsSendFileMessage = state.dsSendFileMessage, dsSendMultipleFilesMessage = state.dsSendMultipleFilesMessage, dsUpdateUserMessage = state.dsUpdateUserMessage, dsResendMessage = state.dsResendMessage, dsDeleteMessage = state.dsDeleteMessage;
+    var currentChannel = state.currentChannel, onBeforeSendUserMessage = state.onBeforeSendUserMessage, onBeforeSendFileMessage = state.onBeforeSendFileMessage, onBeforeSendVoiceMessage = state.onBeforeSendVoiceMessage, onBeforeSendMultipleFilesMessage = state.onBeforeSendMultipleFilesMessage, dsSendUserMessage = state.dsSendUserMessage, dsSendFileMessage = state.dsSendFileMessage, dsSendMultipleFilesMessage = state.dsSendMultipleFilesMessage, dsUpdateUserMessage = state.dsUpdateUserMessage, dsResendMessage = state.dsResendMessage, dsDeleteMessage = state.dsDeleteMessage, localFilePreviews = state.localFilePreviews;
     var sendMessage = React.useCallback(function (props) {
         var _a;
         var message = props.message, quoteMessage = props.quoteMessage, mentionTemplate = props.mentionTemplate, mentionedUsers = props.mentionedUsers;
@@ -92,6 +94,15 @@ function useThreadMessageActions(state, _a) {
     }, [dsSendUserMessage, onBeforeSendUserMessage, currentChannel, isMentionEnabled]);
     var sendFileMessage = React.useCallback(function (file, quoteMessage) {
         var _a;
+        if (!dsSendFileMessage || !currentChannel) {
+            var error = new Error('Thread | useThreadMessageActions: Sending file message cannot be sent because current channel or data source is unavailable.');
+            logger.warning('Thread | useThreadMessageActions: Sending file message failed, because current channel or data source is unavailable.', {
+                currentChannel: currentChannel,
+                dsSendFileMessage: dsSendFileMessage,
+                error: error,
+            });
+            return Promise.reject(error);
+        }
         var createParamsDefault = function () {
             var params = {};
             params.file = file;
@@ -102,17 +113,23 @@ function useThreadMessageActions(state, _a) {
             return params;
         };
         var params = (_a = onBeforeSendFileMessage === null || onBeforeSendFileMessage === void 0 ? void 0 : onBeforeSendFileMessage(file, quoteMessage)) !== null && _a !== void 0 ? _a : createParamsDefault();
-        if (!dsSendFileMessage || !currentChannel)
-            return Promise.resolve(null);
         logger.info('Thread | useThreadMessageActions: Sending file message start.', params);
         var localPreviewUrl;
+        var pendingReqId;
         return dsSendFileMessage(params, function (pendingMessage) {
-            localPreviewUrl = attachLocalFilePreview(pendingMessage, file);
+            pendingReqId = pendingMessage.reqId;
+            localPreviewUrl = attachLocalFilePreview(pendingMessage, file, localFilePreviews);
             scrollToLastAfterSend();
         })
             .then(function (sentMessage) {
-            if (localPreviewUrl)
+            var preview = pendingReqId && localFilePreviews.get(pendingReqId);
+            if (preview) {
+                URL.revokeObjectURL(preview.localUrl);
+                localFilePreviews.delete(pendingReqId);
+            }
+            else if (localPreviewUrl) {
                 URL.revokeObjectURL(localPreviewUrl);
+            }
             pubSub.publish(pubSub_topics.pubSubTopics.SEND_FILE_MESSAGE, {
                 channel: currentChannel,
                 message: sentMessage,
@@ -120,7 +137,7 @@ function useThreadMessageActions(state, _a) {
             });
             return sentMessage;
         });
-    }, [dsSendFileMessage, onBeforeSendFileMessage, currentChannel]);
+    }, [dsSendFileMessage, onBeforeSendFileMessage, currentChannel, localFilePreviews]);
     var sendVoiceMessage = React.useCallback(function (file, duration, quoteMessage) {
         var params = (onBeforeSendVoiceMessage && typeof onBeforeSendVoiceMessage === 'function')
             ? onBeforeSendVoiceMessage(file, quoteMessage)
@@ -141,13 +158,21 @@ function useThreadMessageActions(state, _a) {
             return;
         logger.info('Thread | useThreadMessageActions: Sending voice message start.', params);
         var localPreviewUrl;
+        var pendingReqId;
         dsSendFileMessage(params, function (pendingMessage) {
-            localPreviewUrl = attachLocalFilePreview(pendingMessage, file);
+            pendingReqId = pendingMessage.reqId;
+            localPreviewUrl = attachLocalFilePreview(pendingMessage, file, localFilePreviews);
             scrollToLastAfterSend();
         })
             .then(function (sentMessage) {
-            if (localPreviewUrl)
+            var preview = pendingReqId && localFilePreviews.get(pendingReqId);
+            if (preview) {
+                URL.revokeObjectURL(preview.localUrl);
+                localFilePreviews.delete(pendingReqId);
+            }
+            else if (localPreviewUrl) {
                 URL.revokeObjectURL(localPreviewUrl);
+            }
             pubSub.publish(pubSub_topics.pubSubTopics.SEND_FILE_MESSAGE, {
                 channel: currentChannel,
                 message: sentMessage,
@@ -157,9 +182,23 @@ function useThreadMessageActions(state, _a) {
             .catch(function (error) {
             logger.info('Thread | useThreadMessageActions: Sending voice message failed.', error);
         });
-    }, [dsSendFileMessage, onBeforeSendVoiceMessage, currentChannel]);
+    }, [dsSendFileMessage, onBeforeSendVoiceMessage, currentChannel, localFilePreviews]);
     var sendMultipleFilesMessage = React.useCallback(function (files, quoteMessage) {
         var _a;
+        if (files.length <= 1) {
+            var error = new Error('Thread | useThreadMessageActions: Sending multiple files message requires at least two files.');
+            logger.warning('Thread | useThreadMessageActions: Sending multiple files message failed, because there are no multiple files.', { files: files, error: error });
+            return Promise.reject(error);
+        }
+        if (!dsSendMultipleFilesMessage || !currentChannel) {
+            var error = new Error('Thread | useThreadMessageActions: Sending multiple files message cannot be sent because current channel or data source is unavailable.');
+            logger.warning('Thread | useThreadMessageActions: Sending multiple files message failed, because current channel or data source is unavailable.', {
+                currentChannel: currentChannel,
+                dsSendMultipleFilesMessage: dsSendMultipleFilesMessage,
+                error: error,
+            });
+            return Promise.reject(error);
+        }
         var createParamsDefault = function () {
             var params = {
                 fileInfoList: files.map(function (file) { return ({
@@ -176,8 +215,6 @@ function useThreadMessageActions(state, _a) {
             return params;
         };
         var params = (_a = onBeforeSendMultipleFilesMessage === null || onBeforeSendMultipleFilesMessage === void 0 ? void 0 : onBeforeSendMultipleFilesMessage(files, quoteMessage)) !== null && _a !== void 0 ? _a : createParamsDefault();
-        if (!dsSendMultipleFilesMessage || !currentChannel)
-            return Promise.resolve(null);
         logger.info('Thread | useThreadMessageActions: Sending multiple files message start.', params);
         return dsSendMultipleFilesMessage(params, function () { return scrollToLastAfterSend(); })
             .then(function (sentMessage) {
@@ -221,12 +258,29 @@ function useThreadMessageActions(state, _a) {
             logger.warning('Thread | useThreadMessageActions: Message update failed.', error);
         });
     }, [dsUpdateUserMessage, currentChannel, isMentionEnabled]);
-    var deleteMessage = React.useCallback(function (message) {
+    var deleteMessage = React.useCallback(function (message$1) {
         if (!dsDeleteMessage)
             return Promise.resolve();
-        logger.info('Thread | useThreadMessageActions: Deleting message.', message);
-        return dsDeleteMessage(message);
-    }, [dsDeleteMessage]);
+        logger.info('Thread | useThreadMessageActions: Deleting message.', message$1);
+        return dsDeleteMessage(message$1)
+            .then(function () {
+            var preview = message$1.reqId && localFilePreviews.get(message$1.reqId);
+            if (preview) {
+                URL.revokeObjectURL(preview.localUrl);
+                localFilePreviews.delete(message$1.reqId);
+            }
+        })
+            .catch(function (error) {
+            if (message$1.sendingStatus !== message.SendingStatus.SUCCEEDED && currentChannel) {
+                var preview = message$1.reqId && localFilePreviews.get(message$1.reqId);
+                if (preview) {
+                    URL.revokeObjectURL(preview.localUrl);
+                    localFilePreviews.delete(message$1.reqId);
+                }
+            }
+            throw error;
+        });
+    }, [dsDeleteMessage, localFilePreviews, currentChannel]);
     var resendMessage = React.useCallback(function (failedMessage) {
         if (!(failedMessage === null || failedMessage === void 0 ? void 0 : failedMessage.isResendable) || !dsResendMessage || !currentChannel) {
             logger.warning('Thread | useThreadMessageActions: Message is not resendable.', failedMessage);
@@ -277,36 +331,117 @@ var useThread = function () {
     var state = SendbirdContext.shimExports.useSyncExternalStore(store.subscribe, store.getState);
     var currentChannel = state.currentChannel;
     var toggleReaction = useToggleReactionCallback({ currentChannel: currentChannel }, { logger: logger });
-    var initializeThreadFetcher = React.useCallback(function (callback) {
-        var _a = store.getState(), resetWithStartingPoint = _a.resetWithStartingPoint, anchorMessage = _a.message, parentMessage = _a.parentMessage;
-        if (!resetWithStartingPoint)
-            return;
-        // Mirror ThreadProvider's initial startingPoint: anchor at the specific reply when entering from
-        // one, otherwise open at the latest edge (MAX). parentMessage.createdAt would anchor at the oldest
-        // edge (replies are created after the parent), hiding the latest replies behind hasMoreNext.
-        var startingPoint = (anchorMessage && parentMessage && anchorMessage.messageId !== parentMessage.messageId)
-            ? anchorMessage.createdAt
-            : Number.MAX_SAFE_INTEGER;
-        resetWithStartingPoint(startingPoint).then(function () {
-            setTimeout(function () { return callback === null || callback === void 0 ? void 0 : callback(store.getState().allThreadMessages); });
+    var initializeThreadFetcher = React.useCallback(function (callback) { return _tslib.__awaiter(void 0, void 0, void 0, function () {
+        var _a, resetWithStartingPoint, anchorMessage, parentMessage, startingPoint, page, error_1;
+        return _tslib.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = store.getState(), resetWithStartingPoint = _a.resetWithStartingPoint, anchorMessage = _a.message, parentMessage = _a.parentMessage;
+                    if (!resetWithStartingPoint)
+                        return [2 /*return*/];
+                    startingPoint = (anchorMessage && parentMessage && anchorMessage.messageId !== parentMessage.messageId)
+                        ? anchorMessage.createdAt
+                        : Number.MAX_SAFE_INTEGER;
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, resetWithStartingPoint(startingPoint, function (messages) {
+                            page = messages;
+                        })];
+                case 2:
+                    _b.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_1 = _b.sent();
+                    logger.warning('Thread resetWithStartingPoint failed', error_1);
+                    return [2 /*return*/];
+                case 4:
+                    // onFetched fires only when the fetch succeeded (an empty page arrives as []), so `undefined`
+                    // means the load failed or was guarded upstream — settle without the callback (pre-v3.18.3 behavior).
+                    if (page === undefined)
+                        return [2 /*return*/];
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    return [4 /*yield*/, new Promise(function (resolve) {
+                            setTimeout(resolve);
+                        })];
+                case 5:
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    _b.sent();
+                    callback === null || callback === void 0 ? void 0 : callback(page);
+                    return [2 /*return*/];
+            }
         });
-    }, [store]);
-    var fetchPrevThreads = React.useCallback(function (callback) {
-        var loadPrevious = store.getState().loadPrevious;
-        if (!loadPrevious)
-            return;
-        loadPrevious().then(function () {
-            setTimeout(function () { return callback === null || callback === void 0 ? void 0 : callback(store.getState().allThreadMessages); });
+    }); }, [store, logger]);
+    var fetchPrevThreads = React.useCallback(function (callback) { return _tslib.__awaiter(void 0, void 0, void 0, function () {
+        var loadPrevious, page;
+        return _tslib.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    loadPrevious = store.getState().loadPrevious;
+                    if (!loadPrevious)
+                        return [2 /*return*/];
+                    return [4 /*yield*/, loadPrevious(function (messages) {
+                            page = messages;
+                        })];
+                case 1:
+                    _a.sent();
+                    // onFetched fires only when the fetch succeeded (an empty page arrives as []), so `undefined`
+                    // means the load failed or was guarded upstream — settle without the callback (pre-v3.18.3 behavior).
+                    if (page === undefined)
+                        return [2 /*return*/];
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    return [4 /*yield*/, new Promise(function (resolve) {
+                            setTimeout(resolve);
+                        })];
+                case 2:
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    _a.sent();
+                    callback === null || callback === void 0 ? void 0 : callback(page);
+                    return [2 /*return*/];
+            }
         });
-    }, [store]);
-    var fetchNextThreads = React.useCallback(function (callback) {
-        var loadNext = store.getState().loadNext;
-        if (!loadNext)
-            return;
-        loadNext().then(function () {
-            setTimeout(function () { return callback === null || callback === void 0 ? void 0 : callback(store.getState().allThreadMessages); });
+    }); }, [store]);
+    var fetchNextThreads = React.useCallback(function (callback) { return _tslib.__awaiter(void 0, void 0, void 0, function () {
+        var loadNext, page;
+        return _tslib.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    loadNext = store.getState().loadNext;
+                    if (!loadNext)
+                        return [2 /*return*/];
+                    return [4 /*yield*/, loadNext(function (messages) {
+                            page = messages;
+                        })];
+                case 1:
+                    _a.sent();
+                    // onFetched fires only when the fetch succeeded (an empty page arrives as []), so `undefined`
+                    // means the load failed or was guarded upstream — settle without the callback (pre-v3.18.3 behavior).
+                    if (page === undefined)
+                        return [2 /*return*/];
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    return [4 /*yield*/, new Promise(function (resolve) {
+                            setTimeout(resolve);
+                        })];
+                case 2:
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    _a.sent();
+                    callback === null || callback === void 0 ? void 0 : callback(page);
+                    return [2 /*return*/];
+            }
         });
-    }, [store]);
+    }); }, [store]);
     var messageActions = useThreadMessageActions(state, { logger: logger, pubSub: pubSub, isMentionEnabled: isMentionEnabled });
     var simpleActions = {
         setCurrentUserId: React.useCallback(function (currentUserId) { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { currentUserId: currentUserId })); }); }, [store]),
@@ -619,6 +754,7 @@ var initialState = function () { return ({
     currentUserId: '',
     typingMembers: [],
     nicknamesMap: null,
+    localFilePreviews: new Map(),
 }); };
 var ThreadContext = React__default.default.createContext(null);
 var createThreadStore = function (props) { return SendbirdContext.createStore(_tslib.__assign(_tslib.__assign({}, initialState()), props)); };
@@ -642,7 +778,7 @@ var InternalThreadProvider = function (props) {
 };
 var ThreadManager = function (props) {
     var message$1 = props.message, channelUrl = props.channelUrl, onHeaderActionClick = props.onHeaderActionClick, onMoveToParentMessage = props.onMoveToParentMessage, onBeforeSendUserMessage = props.onBeforeSendUserMessage, onBeforeSendFileMessage = props.onBeforeSendFileMessage, onBeforeSendVoiceMessage = props.onBeforeSendVoiceMessage, onBeforeSendMultipleFilesMessage = props.onBeforeSendMultipleFilesMessage, onBeforeDownloadFileMessage = props.onBeforeDownloadFileMessage, isMultipleFilesMessageEnabled = props.isMultipleFilesMessageEnabled, filterEmojiCategoryIds = props.filterEmojiCategoryIds;
-    var _a = useThread().state, currentChannel = _a.currentChannel, parentMessage = _a.parentMessage, parentMessageState = _a.parentMessageState;
+    var _a = useThread().state, currentChannel = _a.currentChannel, parentMessage = _a.parentMessage, parentMessageState = _a.parentMessageState, localFilePreviews = _a.localFilePreviews;
     var updateState = useThreadStore().updateState;
     var propsParentMessage = utils.getParentMessageFrom(message$1);
     // Context from SendbirdProvider
@@ -738,6 +874,13 @@ var ThreadManager = function (props) {
     var hasMorePrev = threadDataSource.hasPrevious();
     var hasMoreNext = threadDataSource.hasNext();
     var store = React.useContext(ThreadContext);
+    React.useEffect(function () {
+        return function () {
+            var previews = store === null || store === void 0 ? void 0 : store.getState().localFilePreviews;
+            previews === null || previews === void 0 ? void 0 : previews.forEach(function (preview) { return URL.revokeObjectURL(preview.localUrl); });
+            previews === null || previews === void 0 ? void 0 : previews.clear();
+        };
+    }, [store]);
     var messagesSyncKey = threadDataSource.messages
         .map(function (message) {
         var uploadParams = message.messageParams;
@@ -748,12 +891,30 @@ var ThreadManager = function (props) {
     })
         .join('~');
     React.useEffect(function () {
-        if (!parentMessage)
+        if (!parentMessage) {
+            localFilePreviews.forEach(function (preview) { return URL.revokeObjectURL(preview.localUrl); });
+            localFilePreviews.clear();
             return;
+        }
+        var scopedMessages = threadDataSource.messages;
+        scopedMessages.forEach(function (message$1) {
+            var _a, _b;
+            var sendableMessage = message$1;
+            var preview = localFilePreviews.get(sendableMessage.reqId);
+            if (!preview)
+                return;
+            if (sendableMessage.sendingStatus === message.SendingStatus.SUCCEEDED) {
+                URL.revokeObjectURL(preview.localUrl);
+                localFilePreviews.delete(sendableMessage.reqId);
+                return;
+            }
+            var localFileMessage = message$1;
+            (_a = localFileMessage.localUrl) !== null && _a !== void 0 ? _a : (localFileMessage.localUrl = preview.localUrl);
+            (_b = localFileMessage.file) !== null && _b !== void 0 ? _b : (localFileMessage.file = preview.file);
+        });
         // core-ts scopes the collection to this thread's replies (belongsToThread on the event/fetch and
         // send/resend paths), so mirror them as-is. Split into the legacy public shape: allThreadMessages =
         // succeeded (server) messages, localThreadMessages = pending/failed; threadMessages = all of them.
-        var scopedMessages = threadDataSource.messages;
         var localThreadMessages = scopedMessages.filter(function (m) {
             var sendingStatus = m.sendingStatus;
             return sendingStatus === message.SendingStatus.PENDING || sendingStatus === message.SendingStatus.FAILED;
@@ -820,4 +981,4 @@ exports.ThreadManager = ThreadManager;
 exports.ThreadProvider = ThreadProvider;
 exports.useThread = useThread;
 exports.useThreadContext = useThreadContext;
-//# sourceMappingURL=bundle-aWBgGjMg.js.map
+//# sourceMappingURL=bundle-BUvZj7cQ.js.map

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

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

package/cjs/chunks/{bundle-RsvHcqa6.js → bundle-BWiJUwnR.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var ui_Label = require('./bundle-C4xnXl2z.js');
-var index = require('./bundle-B2X1DIz7.js');
+var ui_Label = require('./bundle-DE8Y9-kK.js');
+var index = require('./bundle-IiaDOxN6.js');
 
 var getChannelTitle = function (channel, currentUserId, stringSet) {
     var _a;
@@ -25,4 +25,4 @@ var getChannelTitle = function (channel, currentUserId, stringSet) {
 };
 
 exports.getChannelTitle = getChannelTitle;
-//# sourceMappingURL=bundle-RsvHcqa6.js.map
+//# sourceMappingURL=bundle-BWiJUwnR.js.map

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

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

package/cjs/chunks/{bundle-sL0KYRBS.js → bundle-BXkr0YUW.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 require('../utils/message/getOutgoingMessageState.js');
-require('./bundle-gK1bSKqR.js');
+require('./bundle-DJ-JijOD.js');
 
 var getNicknamesMapFromMembers = function (members) {
     if (members === void 0) { members = []; }
@@ -73,4 +73,4 @@ exports.getNicknamesMapFromMembers = getNicknamesMapFromMembers;
 exports.getParentMessageFrom = getParentMessageFrom;
 exports.isAboutSame = isAboutSame;
 exports.scrollIntoLast = scrollIntoLast;
-//# sourceMappingURL=bundle-sL0KYRBS.js.map
+//# sourceMappingURL=bundle-BXkr0YUW.js.map

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

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