@sendbird/uikit-react 3.17.12 → 3.18.1

package/cjs/chunks/{bundle-BW65DB4j.js → bundle-DHujV3Ns.js}

@@ -1,15 +1,15 @@
 'use strict';
 
-var _tslib = require('./bundle-C5mxhXoI.js');
+var _tslib = require('./bundle-BX9JpkVP.js');
 var React = require('react');
 var ui_Icon = require('../ui/Icon.js');
 var ui_ChannelAvatar = require('../ui/ChannelAvatar.js');
-var utils = require('./bundle-bqOzYE_N.js');
-var MediaQueryContext = require('./bundle-Bk2QOCY1.js');
-var LocalizationContext = require('./bundle-BiH38g8Z.js');
+var utils = require('./bundle-BEZJwC-3.js');
+var MediaQueryContext = require('./bundle-DLPt543m.js');
+var LocalizationContext = require('./bundle-JZ1A5dHC.js');
 var ui_Header = require('../ui/Header.js');
-var utils$1 = require('./bundle-DVTKYwk8.js');
-var useSendbird = require('./bundle-D18FtXyq.js');
+var utils$1 = require('./bundle-DoUok50d.js');
+var useSendbird = require('./bundle-CBb6rgl-.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-BW65DB4j.js.map
+//# sourceMappingURL=bundle-DHujV3Ns.js.map

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

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

package/cjs/chunks/{bundle-Bk2QOCY1.js → bundle-DLPt543m.js}

@@ -76,4 +76,4 @@ var useMediaQueryContext = function () { return React__default.default.useContex
 
 exports.MediaQueryProvider = MediaQueryProvider;
 exports.useMediaQueryContext = useMediaQueryContext;
-//# sourceMappingURL=bundle-Bk2QOCY1.js.map
+//# sourceMappingURL=bundle-DLPt543m.js.map

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

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

package/cjs/chunks/{bundle-Q3QnKudh.js → bundle-DM0hUlx4.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var _tslib = require('./bundle-C5mxhXoI.js');
-var pxToNumber = require('./bundle-orSDTEo4.js');
+var _tslib = require('./bundle-BX9JpkVP.js');
+var pxToNumber = require('./bundle-BoEX39oK.js');
 
 var compressImage = function (_a) {
     var imageFile = _a.imageFile, compressionRate = _a.compressionRate, resizingWidth = _a.resizingWidth, resizingHeight = _a.resizingHeight, outputFormat = _a.outputFormat;
@@ -120,4 +120,4 @@ var compressImages = function (_a) { return _tslib.__awaiter(void 0, [_a], void
 }); };
 
 exports.compressImages = compressImages;
-//# sourceMappingURL=bundle-Q3QnKudh.js.map
+//# sourceMappingURL=bundle-DM0hUlx4.js.map

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

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

package/cjs/chunks/{bundle-CKpfSH9x.js → bundle-DMIPKf7C.js}

@@ -2,10 +2,10 @@
 
 var React = require('react');
 var openChannel = require('@sendbird/chat/openChannel');
-var pubSub_topics = require('./bundle-BucGViqp.js');
-var uuid = require('./bundle-DMroWEST.js');
-var _tslib = require('./bundle-C5mxhXoI.js');
-var useSendbird = require('./bundle-D18FtXyq.js');
+var pubSub_topics = require('./bundle-DUac1WMX.js');
+var uuid = require('./bundle-Qchcdxzl.js');
+var _tslib = require('./bundle-BX9JpkVP.js');
+var useSendbird = require('./bundle-CBb6rgl-.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -19,7 +19,7 @@ exports.OpenChannelListFetchingStatus = void 0;
     OpenChannelListFetchingStatus["ERROR"] = "ERROR";
 })(exports.OpenChannelListFetchingStatus || (exports.OpenChannelListFetchingStatus = {}));
 
-var OpenChannelListActionTypes;
+var OpenChannelListActionTypes$1;
 (function (OpenChannelListActionTypes) {
     // actions
     OpenChannelListActionTypes["INIT_OPEN_CHANNEL_LIST_START"] = "INIT_OPEN_CHANNEL_LIST_START";
@@ -34,46 +34,46 @@ var OpenChannelListActionTypes;
     OpenChannelListActionTypes["UPDATE_OPEN_CHANNEL_LIST_QUERY"] = "UPDATE_OPEN_CHANNEL_LIST_QUERY";
     OpenChannelListActionTypes["UPDATE_OPEN_CHANNEL"] = "UPDATE_OPEN_CHANNEL";
     OpenChannelListActionTypes["DELETE_OPEN_CHANNEL"] = "DELETE_OPEN_CHANNEL";
-})(OpenChannelListActionTypes || (OpenChannelListActionTypes = {}));
-var OpenChannelListActionTypes$1 = OpenChannelListActionTypes;
+})(OpenChannelListActionTypes$1 || (OpenChannelListActionTypes$1 = {}));
+var OpenChannelListActionTypes = OpenChannelListActionTypes$1;
 
 function reducer(state, action) {
     var _a, _b, _c;
     switch (action.type) {
-        case OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_START: {
+        case OpenChannelListActionTypes.INIT_OPEN_CHANNEL_LIST_START: {
             return _tslib.__assign(_tslib.__assign({}, state), { fetchingStatus: exports.OpenChannelListFetchingStatus.FETCHING });
         }
-        case OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_SUCCESS: {
+        case OpenChannelListActionTypes.INIT_OPEN_CHANNEL_LIST_SUCCESS: {
             var channelList = action.payload;
             return _tslib.__assign(_tslib.__assign({}, state), { allChannels: channelList, fetchingStatus: channelList.length > 0
                     ? exports.OpenChannelListFetchingStatus.DONE
                     : exports.OpenChannelListFetchingStatus.EMPTY });
         }
-        case OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_FAILURE: {
+        case OpenChannelListActionTypes.INIT_OPEN_CHANNEL_LIST_FAILURE: {
             return _tslib.__assign(_tslib.__assign({}, state), { allChannels: [], fetchingStatus: exports.OpenChannelListFetchingStatus.ERROR });
         }
-        case OpenChannelListActionTypes$1.RESET_OPEN_CHANNEL_LIST: {
+        case OpenChannelListActionTypes.RESET_OPEN_CHANNEL_LIST: {
             return _tslib.__assign(_tslib.__assign({}, state), { allChannels: [], fetchingStatus: exports.OpenChannelListFetchingStatus.EMPTY });
         }
-        case OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_START: {
+        case OpenChannelListActionTypes.FETCH_OPEN_CHANNEL_LIST_START: {
             return state;
         }
-        case OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_SUCCESS: {
+        case OpenChannelListActionTypes.FETCH_OPEN_CHANNEL_LIST_SUCCESS: {
             return _tslib.__assign(_tslib.__assign({}, state), { allChannels: _tslib.__spreadArray(_tslib.__spreadArray([], state.allChannels, true), action.payload, true) });
         }
-        case OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_FAILURE: {
+        case OpenChannelListActionTypes.FETCH_OPEN_CHANNEL_LIST_FAILURE: {
             return state;
         }
-        case OpenChannelListActionTypes$1.CREATE_OPEN_CHANNEL: {
+        case OpenChannelListActionTypes.CREATE_OPEN_CHANNEL: {
             return _tslib.__assign(_tslib.__assign({}, state), { currentChannel: action.payload, allChannels: _tslib.__spreadArray([action.payload], state.allChannels, true) });
         }
-        case OpenChannelListActionTypes$1.SET_CURRENT_OPEN_CHANNEL: {
+        case OpenChannelListActionTypes.SET_CURRENT_OPEN_CHANNEL: {
             return _tslib.__assign(_tslib.__assign({}, state), { currentChannel: action.payload });
         }
-        case OpenChannelListActionTypes$1.UPDATE_OPEN_CHANNEL_LIST_QUERY: {
+        case OpenChannelListActionTypes.UPDATE_OPEN_CHANNEL_LIST_QUERY: {
             return _tslib.__assign(_tslib.__assign({}, state), { channelListQuery: action === null || action === void 0 ? void 0 : action.payload });
         }
-        case OpenChannelListActionTypes$1.UPDATE_OPEN_CHANNEL: {
+        case OpenChannelListActionTypes.UPDATE_OPEN_CHANNEL: {
             return _tslib.__assign(_tslib.__assign({}, state), { allChannels: state.allChannels.map(function (channel) {
                     var _a;
                     return ((channel === null || channel === void 0 ? void 0 : channel.url) === ((_a = action.payload) === null || _a === void 0 ? void 0 : _a.url) ? action.payload : channel);
@@ -81,7 +81,7 @@ function reducer(state, action) {
                     ? state.currentChannel
                     : action.payload });
         }
-        case OpenChannelListActionTypes$1.DELETE_OPEN_CHANNEL: {
+        case OpenChannelListActionTypes.DELETE_OPEN_CHANNEL: {
             var channelUrl_1 = action.payload;
             var updatedChannels = state.allChannels.filter(function (channel) { return (channel === null || channel === void 0 ? void 0 : channel.url) !== channelUrl_1; });
             return _tslib.__assign(_tslib.__assign({}, state), { allChannels: updatedChannels, currentChannel: ((_c = state.currentChannel) === null || _c === void 0 ? void 0 : _c.url) === channelUrl_1 ? null : state.currentChannel });
@@ -106,7 +106,7 @@ function useFetchNextCallback(_a, _b) {
         if (sdkInitialized && (openChannelListQuery === null || openChannelListQuery === void 0 ? void 0 : openChannelListQuery.hasNext)) {
             logger.info('OpenChannelList|useFetchNextCallback : Fetch channels');
             openChannelListDispatcher({
-                type: OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_START,
+                type: OpenChannelListActionTypes.FETCH_OPEN_CHANNEL_LIST_START,
                 payload: null,
             });
             openChannelListQuery.next()
@@ -114,7 +114,7 @@ function useFetchNextCallback(_a, _b) {
                 callback(channelList, undefined);
                 logger.info('OpenChannelList|useFetchNextCallback: Succeeded fetching channels', channelList);
                 openChannelListDispatcher({
-                    type: OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_SUCCESS,
+                    type: OpenChannelListActionTypes.FETCH_OPEN_CHANNEL_LIST_SUCCESS,
                     payload: channelList,
                 });
             })
@@ -122,7 +122,7 @@ function useFetchNextCallback(_a, _b) {
                 callback(undefined, err);
                 logger.error('OpenChannelList|useFetchNextCallback: Failed fetching channels', err);
                 openChannelListDispatcher({
-                    type: OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_FAILURE,
+                    type: OpenChannelListActionTypes.FETCH_OPEN_CHANNEL_LIST_FAILURE,
                     payload: null,
                 });
             });
@@ -148,7 +148,7 @@ function createChannelListQuery(_a) {
     var channelListQuery = (_c = (_b = sdk === null || sdk === void 0 ? void 0 : sdk.openChannel) === null || _b === void 0 ? void 0 : _b.createOpenChannelListQuery) === null || _c === void 0 ? void 0 : _c.call(_b, params);
     logger.info(logMessage, channelListQuery);
     openChannelListDispatcher({
-        type: OpenChannelListActionTypes$1.UPDATE_OPEN_CHANNEL_LIST_QUERY,
+        type: OpenChannelListActionTypes.UPDATE_OPEN_CHANNEL_LIST_QUERY,
         payload: channelListQuery,
     });
     return channelListQuery;
@@ -171,21 +171,21 @@ function useSetupOpenChannelList(_a, _b) {
                 if (channelListQuery === null || channelListQuery === void 0 ? void 0 : channelListQuery.hasNext) {
                     logger === null || logger === void 0 ? void 0 : logger.info('OpenChannelList|useSetupOpenChannelList: Fetch channels');
                     openChannelListDispatcher({
-                        type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_START,
+                        type: OpenChannelListActionTypes.INIT_OPEN_CHANNEL_LIST_START,
                         payload: null,
                     });
                     channelListQuery.next()
                         .then(function (channelList) {
                         logger === null || logger === void 0 ? void 0 : logger.info('OpenChannelList|useSetupOpenChannelList: Succeeded fetching channels', channelList);
                         openChannelListDispatcher({
-                            type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_SUCCESS,
+                            type: OpenChannelListActionTypes.INIT_OPEN_CHANNEL_LIST_SUCCESS,
                             payload: channelList,
                         });
                     })
                         .catch(function (err) {
                         logger === null || logger === void 0 ? void 0 : logger.error('OpenChannelList|useSetupOpenChannelList: Failed fetching channels', err);
                         openChannelListDispatcher({
-                            type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_FAILURE,
+                            type: OpenChannelListActionTypes.INIT_OPEN_CHANNEL_LIST_FAILURE,
                             payload: null,
                         });
                     });
@@ -201,7 +201,7 @@ function useSetupOpenChannelList(_a, _b) {
         else {
             logger === null || logger === void 0 ? void 0 : logger.info('OpenChannelList|useSetupOpenChannelList: Reset OpenChannelList', { sdkInitialized: sdkInitialized });
             openChannelListDispatcher({
-                type: OpenChannelListActionTypes$1.RESET_OPEN_CHANNEL_LIST,
+                type: OpenChannelListActionTypes.RESET_OPEN_CHANNEL_LIST,
                 payload: null,
             });
         }
@@ -216,7 +216,7 @@ function useRefreshOpenChannelList(_a, _b) {
         if (!sdkInitialized) {
             logger.info('OpenChannelList|useRefreshOpenChannelList: Reset OpenChannelList', { sdkInitialized: sdkInitialized });
             openChannelListDispatcher({
-                type: OpenChannelListActionTypes$1.RESET_OPEN_CHANNEL_LIST,
+                type: OpenChannelListActionTypes.RESET_OPEN_CHANNEL_LIST,
                 payload: null,
             });
             return;
@@ -240,21 +240,21 @@ function useRefreshOpenChannelList(_a, _b) {
         if (channelListQuery.hasNext) {
             logger.info('OpenChannelList|useRefreshOpenChannelList: Fetch channels');
             openChannelListDispatcher({
-                type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_START,
+                type: OpenChannelListActionTypes.INIT_OPEN_CHANNEL_LIST_START,
                 payload: null,
             });
             channelListQuery.next()
                 .then(function (channelList) {
                 logger.info('OpenChannelList|useRefreshOpenChannelList: Succeeded fetching channels', channelList);
                 openChannelListDispatcher({
-                    type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_SUCCESS,
+                    type: OpenChannelListActionTypes.INIT_OPEN_CHANNEL_LIST_SUCCESS,
                     payload: channelList,
                 });
             })
                 .catch(function (err) {
                 logger.error('OpenChannelList|useRefreshOpenChannelList: Failed fetching channels', err);
                 openChannelListDispatcher({
-                    type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_FAILURE,
+                    type: OpenChannelListActionTypes.INIT_OPEN_CHANNEL_LIST_FAILURE,
                     payload: null,
                 });
             });
@@ -299,7 +299,7 @@ var OpenChannelListProvider = function (_a) {
         if (pubSub === null || pubSub === void 0 ? void 0 : pubSub.subscribe) {
             subscriber.set(pubSub_topics.pubSubTopics.UPDATE_OPEN_CHANNEL, pubSub.subscribe(pubSub_topics.pubSubTopics.UPDATE_OPEN_CHANNEL, function (channel) {
                 openChannelListDispatcher({
-                    type: OpenChannelListActionTypes$1.UPDATE_OPEN_CHANNEL,
+                    type: OpenChannelListActionTypes.UPDATE_OPEN_CHANNEL,
                     payload: channel,
                 });
             }));
@@ -317,7 +317,7 @@ var OpenChannelListProvider = function (_a) {
                 onChannelDeleted: function (channelUrl) {
                     logger.info('OpenChannelList: onChannelDeleted', channelUrl);
                     openChannelListDispatcher({
-                        type: OpenChannelListActionTypes$1.DELETE_OPEN_CHANNEL,
+                        type: OpenChannelListActionTypes.DELETE_OPEN_CHANNEL,
                         payload: channelUrl,
                     });
                 },
@@ -364,13 +364,13 @@ var OpenChannelListProvider = function (_a) {
         } },
         React__default.default.createElement("div", { className: "sendbird-open-channel-list ".concat(className) }, children)));
 };
-var OpenChannelListProvider$1 = {
+var OpenChannelListProvider_default = {
     OpenChannelListProvider: OpenChannelListProvider,
     useOpenChannelListContext: useOpenChannelListContext,
 };
 
-exports.OpenChannelListActionTypes = OpenChannelListActionTypes$1;
+exports.OpenChannelListActionTypes = OpenChannelListActionTypes;
 exports.OpenChannelListProvider = OpenChannelListProvider;
-exports.OpenChannelListProvider$1 = OpenChannelListProvider$1;
+exports.OpenChannelListProvider_default = OpenChannelListProvider_default;
 exports.useOpenChannelListContext = useOpenChannelListContext;
-//# sourceMappingURL=bundle-CKpfSH9x.js.map
+//# sourceMappingURL=bundle-DMIPKf7C.js.map

package/cjs/chunks/{bundle-CKpfSH9x.js.map → bundle-DMIPKf7C.js.map}

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

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

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

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

package/cjs/chunks/{bundle-BucGViqp.js → bundle-DUac1WMX.js}

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

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

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

package/cjs/chunks/{bundle-DrXHYoHC.js → bundle-DVEX2FpT.js}

@@ -1,24 +1,24 @@
 'use strict';
 
-var _tslib = require('./bundle-C5mxhXoI.js');
+var _tslib = require('./bundle-BX9JpkVP.js');
 var React = require('react');
 var message = require('@sendbird/chat/message');
 var groupChannel = require('@sendbird/chat/groupChannel');
 var uikitTools = require('@sendbird/uikit-tools');
-var UserProfileContext = require('./bundle-DjxBXPXB.js');
-var index$1 = require('./bundle-jz5h__uT.js');
-var SendbirdContext = require('./bundle-Ct1kTyi8.js');
-var utils = require('./bundle-DGCxxnjy.js');
-var useSendbird = require('./bundle-D18FtXyq.js');
-var getIsReactionEnabled = require('./bundle-2be6tixp.js');
-var resolvedReplyType = require('./bundle-Bgxgjzs4.js');
-var pubSub_topics = require('./bundle-BucGViqp.js');
-var _const = require('./bundle-Zv_4ZO0n.js');
-var useDeepCompareEffect = require('./bundle-y6b30rI4.js');
-var utils$1 = require('./bundle-DVTKYwk8.js');
+var UserProfileContext = require('./bundle-BQ35gC0Z.js');
+var index$1 = require('./bundle-7IQ3xcsN.js');
+var SendbirdContext = require('./bundle-DG9KyMWt.js');
+var utils = require('./bundle-BFC8OQzW.js');
+var useSendbird = require('./bundle-CBb6rgl-.js');
+var getIsReactionEnabled = require('./bundle-CbINTXEf.js');
+var resolvedReplyType = require('./bundle-BF83Typ-.js');
+var pubSub_topics = require('./bundle-DUac1WMX.js');
+var _const = require('./bundle-CN82E46K.js');
+var useDeepCompareEffect = require('./bundle-o6JT7yPs.js');
+var utils$1 = require('./bundle-DoUok50d.js');
 var SendbirdChat = require('@sendbird/chat');
-var index = require('./bundle-CtVNyiwe.js');
-var consts = require('./bundle-DSwCeEJP.js');
+var index = require('./bundle-Dmbgwti3.js');
+var consts = require('./bundle-BmdLztHu.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -275,7 +275,6 @@ var useGroupChannel = function () {
                         },
                     };
                     clickHandler.deactivate();
-                    setAnimatedMessageId(null);
                     message = state.messages.find(function (it) { return it.messageId === messageId || it.createdAt === createdAt; });
                     if (!message) return [3 /*break*/, 1];
                     topOffset = utils.getMessageTopOffset(message.createdAt);
@@ -704,18 +703,30 @@ var GroupChannelManager = function (props) {
                 }];
         });
     }); }, [messageDataSource.initialized, (_c = state.currentChannel) === null || _c === void 0 ? void 0 : _c.url]);
-    // Starting point handling
+    // Starting point handling — skip when animated message handles scroll
     React.useEffect(function () {
-        if (typeof startingPoint === 'number' && state.initialized) {
+        if (typeof startingPoint === 'number' && state.initialized && !_animatedMessageId) {
             actions.scrollToMessage(startingPoint, 0, false, false);
         }
     }, [state.initialized, startingPoint]);
-    // Animated message handling
+    // Animated message handling — scroll + animation
+    // NOTE: Depend on state.initialized so that deep-link / direct Provider usage
+    // (animatedMessageId + startingPoint set on initial mount) retries after the
+    // channel is initialized. Without it, scrollToMessage runs while messages are
+    // empty and the starting-point effect is suppressed by !_animatedMessageId,
+    // leaving the message un-scrolled and un-animated.
     React.useEffect(function () {
-        if (_animatedMessageId) {
-            actions.setAnimatedMessageId(_animatedMessageId);
+        if (_animatedMessageId && state.initialized) {
+            if (typeof startingPoint === 'number') {
+                // Search result click: scroll to message and animate
+                actions.scrollToMessage(startingPoint, _animatedMessageId, true, false);
+            }
+            else {
+                // Thread parent jump: scroll already handled by startingPoint effect, just animate
+                actions.setAnimatedMessageId(_animatedMessageId);
+            }
         }
-    }, [_animatedMessageId]);
+    }, [_animatedMessageId, state.initialized]);
     // State update effect
     var eventHandlers = React.useMemo(function () { return ({
         onBeforeSendUserMessage: onBeforeSendUserMessage,
@@ -834,4 +845,4 @@ exports.GroupChannelProvider = GroupChannelProvider;
 exports.InternalGroupChannelProvider = InternalGroupChannelProvider;
 exports.useGroupChannel = useGroupChannel;
 exports.useGroupChannelContext = useGroupChannelContext;
-//# sourceMappingURL=bundle-DrXHYoHC.js.map
+//# sourceMappingURL=bundle-DVEX2FpT.js.map

package/{chunks/bundle-DdzbXETc.js.map → cjs/chunks/bundle-DVEX2FpT.js.map}

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

package/cjs/chunks/{bundle-KjR3U4Uq.js → bundle-DVfrpRqM.js}

@@ -1,21 +1,21 @@
 'use strict';
 
-var _tslib = require('./bundle-C5mxhXoI.js');
+var _tslib = require('./bundle-BX9JpkVP.js');
 var React = require('react');
-var useSendMultipleFilesMessage = require('./bundle-BEC0Joom.js');
-var UserProfileContext = require('./bundle-DjxBXPXB.js');
-var SendbirdContext = require('./bundle-Ct1kTyi8.js');
+var useSendMultipleFilesMessage = require('./bundle-B-DgoOBD.js');
+var UserProfileContext = require('./bundle-BQ35gC0Z.js');
+var SendbirdContext = require('./bundle-DG9KyMWt.js');
 var SendbirdChat = require('@sendbird/chat');
-var pubSub_topics = require('./bundle-BucGViqp.js');
+var pubSub_topics = require('./bundle-DUac1WMX.js');
 var groupChannel = require('@sendbird/chat/groupChannel');
-var uuid = require('./bundle-DMroWEST.js');
-var compareIds = require('./bundle-BOF3mEIQ.js');
+var uuid = require('./bundle-Qchcdxzl.js');
+var compareIds = require('./bundle-Ca6tAmei.js');
 var Thread_context_types = require('../Thread/context/types.js');
-var useSendbird = require('./bundle-D18FtXyq.js');
-var useDeepCompareEffect = require('./bundle-y6b30rI4.js');
+var useSendbird = require('./bundle-CBb6rgl-.js');
+var useDeepCompareEffect = require('./bundle-o6JT7yPs.js');
 var message = require('@sendbird/chat/message');
-require('./bundle-BiH38g8Z.js');
-var consts = require('./bundle-DSwCeEJP.js');
+require('./bundle-JZ1A5dHC.js');
+var consts = require('./bundle-BmdLztHu.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -325,11 +325,14 @@ function useUpdateMessageCallback(_a, _b) {
     // TODO: add type
     return React.useCallback(function (props) {
         var _a;
-        var messageId = props.messageId, message = props.message, mentionedUsers = props.mentionedUsers, mentionTemplate = props.mentionTemplate;
+        var messageId = props.messageId, message = props.message, mentionedUsers = props.mentionedUsers, mentionedUserIds = props.mentionedUserIds, mentionTemplate = props.mentionTemplate;
         var createParamsDefault = function () {
             var params = {};
             params.message = message;
-            if (isMentionEnabled && mentionedUsers && (mentionedUsers === null || mentionedUsers === void 0 ? void 0 : mentionedUsers.length) > 0) {
+            if (isMentionEnabled && mentionedUserIds) {
+                params.mentionedUserIds = mentionedUserIds;
+            }
+            else if (isMentionEnabled && mentionedUsers) {
                 params.mentionedUsers = mentionedUsers;
             }
             if (isMentionEnabled && mentionTemplate) {
@@ -5980,7 +5983,7 @@ lodash.exports;
 	      bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);
 
 	      if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
-	        bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
+	        bitmask &= -4;
 	      }
 	      var newData = [
 	        func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,
@@ -6083,7 +6086,7 @@ lodash.exports;
 	      }
 	      var length = partials ? partials.length : 0;
 	      if (!length) {
-	        bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
+	        bitmask &= -97;
 	        partials = holders = undefined$1;
 	      }
 	      ary = ary === undefined$1 ? ary : nativeMax(toInteger(ary), 0);
@@ -6116,7 +6119,7 @@ lodash.exports;
 	        : nativeMax(newData[9] - length, 0);
 
 	      if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
-	        bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
+	        bitmask &= -25;
 	      }
 	      if (!bitmask || bitmask == WRAP_BIND_FLAG) {
 	        var result = createBind(func, bitmask, thisArg);
@@ -17973,15 +17976,37 @@ var useThread = function () {
             }
             return _tslib.__assign(_tslib.__assign({}, state), { isMuted: false });
         }); }, [store]),
-        onUserBanned: React.useCallback(function () { return store.setState(function (state) {
-            return _tslib.__assign(_tslib.__assign({}, state), { channelState: Thread_context_types.ChannelStateTypes.NIL, threadListState: Thread_context_types.ThreadListStateTypes.NIL, parentMessageState: Thread_context_types.ParentMessageStateTypes.NIL, currentChannel: null, parentMessage: null, allThreadMessages: [], hasMorePrev: false, hasMoreNext: false });
-        }); }, [store]),
+        onUserBanned: React.useCallback(function (channel, user) {
+            store.setState(function (state) {
+                var _a;
+                if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url)) {
+                    return state;
+                }
+                // Only reset state when the current user is banned
+                if (state.currentUserId === (user === null || user === void 0 ? void 0 : user.userId)) {
+                    return _tslib.__assign(_tslib.__assign({}, state), { channelState: Thread_context_types.ChannelStateTypes.NIL, threadListState: Thread_context_types.ThreadListStateTypes.NIL, parentMessageState: Thread_context_types.ParentMessageStateTypes.NIL, currentChannel: null, parentMessage: null, allThreadMessages: [], hasMorePrev: false, hasMoreNext: false });
+                }
+                // Another user banned: update channel info and nicknames map
+                return _tslib.__assign(_tslib.__assign({}, state), { currentChannel: channel, nicknamesMap: useSendMultipleFilesMessage.getNicknamesMapFromMembers(channel === null || channel === void 0 ? void 0 : channel.members) });
+            });
+        }, [store]),
         onUserUnbanned: React.useCallback(function () { return store.setState(function (state) {
             return _tslib.__assign({}, state);
         }); }, [store]),
-        onUserLeft: React.useCallback(function () { return store.setState(function (state) {
-            return _tslib.__assign(_tslib.__assign({}, state), { channelState: Thread_context_types.ChannelStateTypes.NIL, threadListState: Thread_context_types.ThreadListStateTypes.NIL, parentMessageState: Thread_context_types.ParentMessageStateTypes.NIL, currentChannel: null, parentMessage: null, allThreadMessages: [], hasMorePrev: false, hasMoreNext: false });
-        }); }, [store]),
+        onUserLeft: React.useCallback(function (channel, user) {
+            store.setState(function (state) {
+                var _a;
+                if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url)) {
+                    return state;
+                }
+                // Only reset state when the current user has left
+                if (state.currentUserId === (user === null || user === void 0 ? void 0 : user.userId)) {
+                    return _tslib.__assign(_tslib.__assign({}, state), { channelState: Thread_context_types.ChannelStateTypes.NIL, threadListState: Thread_context_types.ThreadListStateTypes.NIL, parentMessageState: Thread_context_types.ParentMessageStateTypes.NIL, currentChannel: null, parentMessage: null, allThreadMessages: [], hasMorePrev: false, hasMoreNext: false });
+                }
+                // Another user left: update channel info and nicknames map
+                return _tslib.__assign(_tslib.__assign({}, state), { currentChannel: channel, nicknamesMap: useSendMultipleFilesMessage.getNicknamesMapFromMembers(channel === null || channel === void 0 ? void 0 : channel.members) });
+            });
+        }, [store]),
         onChannelFrozen: React.useCallback(function () { return store.setState(function (state) {
             return _tslib.__assign(_tslib.__assign({}, state), { isChannelFrozen: true });
         }); }, [store]),
@@ -18230,7 +18255,7 @@ function useHandleChannelEvents(_a, _b) {
                 },
                 onUserBanned: function (channel, user) {
                     logger.info('Thread | useHandleChannelEvents: onUserBanned', { channel: channel, user: user });
-                    onUserBanned();
+                    onUserBanned(channel, user);
                 },
                 onUserUnbanned: function (channel, user) {
                     logger.info('Thread | useHandleChannelEvents: onUserUnbanned', { channel: channel, user: user });
@@ -18238,7 +18263,7 @@ function useHandleChannelEvents(_a, _b) {
                 },
                 onUserLeft: function (channel, user) {
                     logger.info('Thread | useHandleChannelEvents: onUserLeft', { channel: channel, user: user });
-                    onUserLeft();
+                    onUserLeft(channel, user);
                 },
                 // channel status change
                 onChannelFrozen: function (channel) {
@@ -18371,7 +18396,7 @@ var ThreadManager = function (props) {
         sdkInit: sdkInit,
         currentChannel: currentChannel,
         parentMessage: parentMessage,
-    }, { logger: logger, pubSub: pubSub });
+    }, { pubSub: pubSub });
     React.useEffect(function () {
         if (stores.sdkStore.initialized && config.isOnline) {
             initializeThreadFetcher();
@@ -18432,4 +18457,4 @@ exports.ThreadManager = ThreadManager;
 exports.ThreadProvider = ThreadProvider;
 exports.useThread = useThread;
 exports.useThreadContext = useThreadContext;
-//# sourceMappingURL=bundle-KjR3U4Uq.js.map
+//# sourceMappingURL=bundle-DVfrpRqM.js.map