@sendbird/uikit-react 3.16.11 → 3.17.0

package/cjs/chunks/{bundle-ByMyWV5o.js → bundle-Bvjprr6O.js}

@@ -33,4 +33,4 @@ var generateDefaultAvatar = function (channel) {
 exports.generateDefaultAvatar = generateDefaultAvatar;
 exports.getChannelAvatarSource = getChannelAvatarSource;
 exports.getOpenChannelAvatar = getOpenChannelAvatar;
-//# sourceMappingURL=bundle-ByMyWV5o.js.map
+//# sourceMappingURL=bundle-Bvjprr6O.js.map

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

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

package/cjs/chunks/{bundle-BoPslgnn.js → bundle-BwwNS3QS.js}

@@ -48,4 +48,4 @@ function useElementObserver(selector, targetElement) {
 }
 
 exports.useElementObserver = useElementObserver;
-//# sourceMappingURL=bundle-BoPslgnn.js.map
+//# sourceMappingURL=bundle-BwwNS3QS.js.map

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

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

package/cjs/chunks/{bundle-CFWCM1mO.js → bundle-BzCZ_Let.js}

@@ -1,15 +1,15 @@
 'use strict';
 
-var _tslib = require('./bundle-t_oZmZ9n.js');
+var _tslib = require('./bundle-Conb-pOy.js');
 var React = require('react');
 var groupChannel = require('@sendbird/chat/groupChannel');
 var uikitTools = require('@sendbird/uikit-tools');
-var UserProfileContext = require('./bundle-Dsi0B6WF.js');
-var useMarkAsDeliveredScheduler = require('./bundle-BnaeZmJ7.js');
-var SendbirdContext = require('./bundle-C8VvVV0P.js');
-var utils = require('./bundle-CFoLTSSR.js');
-var useSendbird = require('./bundle-Ca9F08jN.js');
-var useDeepCompareEffect = require('./bundle-RBnTNdLq.js');
+var UserProfileContext = require('./bundle-Bnb8seJF.js');
+var useMarkAsDeliveredScheduler = require('./bundle-Dhgx-4nj.js');
+var SendbirdContext = require('./bundle-B19RHFpR.js');
+var utils = require('./bundle-CkQrhwR6.js');
+var useSendbird = require('./bundle-Bq15P9qk.js');
+var useDeepCompareEffect = require('./bundle-CxArG0ag.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -30,7 +30,7 @@ var useGroupChannelList = function () {
 };
 
 var GroupChannelListContext = React__default.default.createContext(null);
-var initialState = {
+var initialState = function () { return ({
     className: '',
     selectedChannelUrl: '',
     disableAutoSelect: false,
@@ -50,12 +50,12 @@ var initialState = {
     refresh: null,
     loadMore: null,
     scrollRef: { current: null },
-};
+}); };
 /**
  * @returns {ReturnType<typeof createStore<GroupChannelListState>>}
  */
 var useGroupChannelListStore = function () {
-    return SendbirdContext.useStore(GroupChannelListContext, function (state) { return state; }, initialState);
+    return SendbirdContext.useStore(GroupChannelListContext, function (state) { return state; }, initialState());
 };
 var GroupChannelListManager = function (_a) {
     var _b, _c, _d, _e, _f, _g;
@@ -171,7 +171,7 @@ var GroupChannelListManager = function (_a) {
     ]);
     return null;
 };
-var createGroupChannelListStore = function (props) { return SendbirdContext.createStore(_tslib.__assign(_tslib.__assign({}, initialState), props)); };
+var createGroupChannelListStore = function (props) { return SendbirdContext.createStore(_tslib.__assign(_tslib.__assign({}, initialState()), props)); };
 var InternalGroupChannelListProvider = function (props) {
     var children = props.children;
     var defaultProps = utils.deleteNullish({
@@ -217,4 +217,4 @@ exports.GroupChannelListProvider = GroupChannelListProvider;
 exports.useGroupChannelList = useGroupChannelList;
 exports.useGroupChannelListContext = useGroupChannelListContext;
 exports.useGroupChannelListStore = useGroupChannelListStore;
-//# sourceMappingURL=bundle-CFWCM1mO.js.map
+//# sourceMappingURL=bundle-BzCZ_Let.js.map

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

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

package/cjs/chunks/{bundle-bti4bXDj.js → bundle-C0RMVFg8.js}

@@ -1,23 +1,24 @@
 'use strict';
 
-var _tslib = require('./bundle-t_oZmZ9n.js');
+var _tslib = require('./bundle-Conb-pOy.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-Dsi0B6WF.js');
-var index$1 = require('./bundle-kCWC5zyl.js');
-var SendbirdContext = require('./bundle-C8VvVV0P.js');
-var utils = require('./bundle-BaMz3Fl9.js');
-var useSendbird = require('./bundle-Ca9F08jN.js');
-var getIsReactionEnabled = require('./bundle-D31IMJLu.js');
-var resolvedReplyType = require('./bundle-CSlBp8qu.js');
-var pubSub_topics = require('./bundle-Dq_3Fsbm.js');
-var _const = require('./bundle-BN5Tg7TA.js');
-var useDeepCompareEffect = require('./bundle-RBnTNdLq.js');
-var utils$1 = require('./bundle-CFoLTSSR.js');
-var index = require('./bundle-D0vvN7I4.js');
-var consts = require('./bundle-CJV1ehy9.js');
+var UserProfileContext = require('./bundle-Bnb8seJF.js');
+var index$1 = require('./bundle-19BZVS4G.js');
+var SendbirdContext = require('./bundle-B19RHFpR.js');
+var utils = require('./bundle-PVDrKOjZ.js');
+var useSendbird = require('./bundle-Bq15P9qk.js');
+var getIsReactionEnabled = require('./bundle-CXbYckbN.js');
+var resolvedReplyType = require('./bundle-BPUhuptz.js');
+var pubSub_topics = require('./bundle-dUH189qO.js');
+var _const = require('./bundle-BLz2EOZ5.js');
+var useDeepCompareEffect = require('./bundle-CxArG0ag.js');
+var utils$1 = require('./bundle-CkQrhwR6.js');
+var SendbirdChat = require('@sendbird/chat');
+var index = require('./bundle-Dobj18FB.js');
+var consts = require('./bundle-Cfh78Xnm.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -89,7 +90,7 @@ function useMessageActions(params) {
     }); }, [eventHandlers]);
     return {
         sendUserMessage: React.useCallback(function (params) { return _tslib.__awaiter(_this, void 0, void 0, function () {
-            var internalParams, processedParams;
+            var internalParams, processedParams, message;
             return _tslib.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -97,12 +98,20 @@ function useMessageActions(params) {
                         return [4 /*yield*/, processParams(onBeforeSendUserMessage, internalParams, 'user')];
                     case 1:
                         processedParams = _a.sent();
-                        return [2 /*return*/, sendUserMessage(processedParams, asyncScrollToBottom)];
+                        return [4 /*yield*/, sendUserMessage(processedParams, asyncScrollToBottom)];
+                    case 2:
+                        message = _a.sent();
+                        pubSub.publish(pubSub_topics.PUBSUB_TOPICS.SEND_USER_MESSAGE, {
+                            channel: currentChannel,
+                            message: message,
+                            publishingModules: [pubSub_topics.PublishingModuleType.CHANNEL],
+                        });
+                        return [2 /*return*/, message];
                 }
             });
         }); }, [buildInternalMessageParams, sendUserMessage, scrollToBottom, processParams]),
         sendFileMessage: React.useCallback(function (params) { return _tslib.__awaiter(_this, void 0, void 0, function () {
-            var internalParams, processedParams;
+            var internalParams, processedParams, message;
             return _tslib.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -110,12 +119,20 @@ function useMessageActions(params) {
                         return [4 /*yield*/, processParams(onBeforeSendFileMessage, internalParams, 'file')];
                     case 1:
                         processedParams = _a.sent();
-                        return [2 /*return*/, sendFileMessage(processedParams, asyncScrollToBottom)];
+                        return [4 /*yield*/, sendFileMessage(processedParams, asyncScrollToBottom)];
+                    case 2:
+                        message = _a.sent();
+                        pubSub.publish(pubSub_topics.PUBSUB_TOPICS.SEND_FILE_MESSAGE, {
+                            channel: currentChannel,
+                            message: message,
+                            publishingModules: [pubSub_topics.PublishingModuleType.CHANNEL],
+                        });
+                        return [2 /*return*/, message];
                 }
             });
         }); }, [buildInternalMessageParams, sendFileMessage, scrollToBottom, processParams]),
         sendMultipleFilesMessage: React.useCallback(function (params) { return _tslib.__awaiter(_this, void 0, void 0, function () {
-            var internalParams, processedParams;
+            var internalParams, processedParams, message;
             return _tslib.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -123,7 +140,15 @@ function useMessageActions(params) {
                         return [4 /*yield*/, processParams(onBeforeSendMultipleFilesMessage, internalParams, 'multipleFiles')];
                     case 1:
                         processedParams = _a.sent();
-                        return [2 /*return*/, sendMultipleFilesMessage(processedParams, asyncScrollToBottom)];
+                        return [4 /*yield*/, sendMultipleFilesMessage(processedParams, asyncScrollToBottom)];
+                    case 2:
+                        message = _a.sent();
+                        pubSub.publish(pubSub_topics.PUBSUB_TOPICS.SEND_FILE_MESSAGE, {
+                            channel: currentChannel,
+                            message: message,
+                            publishingModules: [pubSub_topics.PublishingModuleType.CHANNEL],
+                        });
+                        return [2 /*return*/, message];
                 }
             });
         }); }, [buildInternalMessageParams, sendMultipleFilesMessage, scrollToBottom, processParams]),
@@ -209,13 +234,20 @@ var useGroupChannel = function () {
                     if (state.currentChannel && !state.hasNext()) {
                         state.resetNewMessages();
                         if (!state.disableMarkAsRead) {
-                            markAsReadScheduler.push(state.currentChannel);
+                            if (!config.groupChannel.enableMarkAsUnread && state.currentChannel.myMemberState !== 'none') {
+                                markAsReadScheduler.push(state.currentChannel);
+                            }
                         }
                     }
                     return [2 /*return*/];
             }
         });
-    }); }, [state.scrollRef.current, config.isOnline, markAsReadScheduler]);
+    }); }, [state.scrollRef.current, config.isOnline, markAsReadScheduler, config.groupChannel.enableMarkAsUnread]);
+    var markAsReadAll = React.useCallback(function (channel) {
+        if (config.isOnline && !state.disableMarkAsRead && channel) {
+            markAsReadScheduler === null || markAsReadScheduler === void 0 ? void 0 : markAsReadScheduler.push(channel);
+        }
+    }, [config.isOnline, state.disableMarkAsRead]);
     var scrollToMessage = React.useCallback(function (createdAt, messageId, messageFocusAnimated, scrollAnimated) { return _tslib.__awaiter(void 0, void 0, void 0, function () {
         var element, parentNode, clickHandler, message, topOffset;
         return _tslib.__generator(this, function (_a) {
@@ -296,10 +328,10 @@ var useGroupChannel = function () {
     }, [(_b = state.currentChannel) === null || _b === void 0 ? void 0 : _b.deleteReaction, (_c = state.currentChannel) === null || _c === void 0 ? void 0 : _c.addReaction]);
     var messageActions = useMessageActions(_tslib.__assign(_tslib.__assign({}, state), { scrollToBottom: scrollToBottom }));
     var setCurrentChannel = React.useCallback(function (channel) {
-        store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { currentChannel: channel, fetchChannelError: null, quoteMessage: null, animatedMessageId: null, nicknamesMap: new Map(channel.members.map(function (_a) {
+        store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { currentChannel: channel, fetchChannelError: null, quoteMessage: null, animatedMessageId: null, nicknamesMap: channel ? new Map(channel.members.map(function (_a) {
                 var userId = _a.userId, nickname = _a.nickname;
                 return [userId, nickname];
-            })) })); }, true);
+            })) : new Map() })); }, true);
     }, []);
     var handleChannelError = React.useCallback(function (error) {
         store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { currentChannel: null, fetchChannelError: error, quoteMessage: null, animatedMessageId: null })); });
@@ -307,11 +339,21 @@ var useGroupChannel = function () {
     var setQuoteMessage = React.useCallback(function (message) {
         store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { quoteMessage: message })); });
     }, []);
+    var setReadStateChanged = React.useCallback(function (readState) {
+        store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { readState: readState })); });
+    }, []);
+    var setFirstUnreadMessageId = React.useCallback(function (messageId) {
+        store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { firstUnreadMessageId: messageId })); });
+    }, []);
     var actions = React.useMemo(function () {
-        return _tslib.__assign({ setCurrentChannel: setCurrentChannel, handleChannelError: handleChannelError, setQuoteMessage: setQuoteMessage, scrollToBottom: scrollToBottom, scrollToMessage: scrollToMessage, toggleReaction: toggleReaction, setAnimatedMessageId: setAnimatedMessageId, setIsScrollBottomReached: setIsScrollBottomReached }, messageActions);
+        return _tslib.__assign({ setCurrentChannel: setCurrentChannel, handleChannelError: handleChannelError, markAsReadAll: markAsReadAll, markAsUnread: state.markAsUnread, setReadStateChanged: setReadStateChanged, setFirstUnreadMessageId: setFirstUnreadMessageId, setQuoteMessage: setQuoteMessage, scrollToBottom: scrollToBottom, scrollToMessage: scrollToMessage, toggleReaction: toggleReaction, setAnimatedMessageId: setAnimatedMessageId, setIsScrollBottomReached: setIsScrollBottomReached }, messageActions);
     }, [
         setCurrentChannel,
         handleChannelError,
+        markAsReadAll,
+        state.markAsUnread,
+        setReadStateChanged,
+        setFirstUnreadMessageId,
         setQuoteMessage,
         scrollToBottom,
         scrollToMessage,
@@ -412,7 +454,7 @@ function getScrollBehavior(behavior, animated) {
     return behavior;
 }
 
-var initialState = {
+var initialState = function () { return ({
     currentChannel: null,
     channelUrl: '',
     fetchChannelError: null,
@@ -423,6 +465,7 @@ var initialState = {
     quoteMessage: null,
     animatedMessageId: null,
     isScrollBottomReached: true,
+    readState: null,
     scrollRef: { current: null },
     scrollDistanceFromBottomRef: { current: 0 },
     scrollPositionRef: { current: 0 },
@@ -436,9 +479,9 @@ var initialState = {
     disableMarkAsRead: false,
     scrollBehavior: 'auto',
     scrollPubSub: null,
-};
+}); };
 var GroupChannelContext = React.createContext(null);
-var createGroupChannelStore = function (props) { return SendbirdContext.createStore(_tslib.__assign(_tslib.__assign({}, initialState), props)); };
+var createGroupChannelStore = function (props) { return SendbirdContext.createStore(_tslib.__assign(_tslib.__assign({}, initialState()), props)); };
 var InternalGroupChannelProvider = function (props) {
     var children = props.children;
     var defaultProps = utils$1.deleteNullish({
@@ -483,7 +526,7 @@ var GroupChannelManager = function (props) {
     var updateState = useGroupChannelStore().updateState;
     var _h = useSendbird.useSendbird().state, config = _h.config, stores = _h.stores;
     var sdkStore = stores.sdkStore;
-    var markAsReadScheduler = config.markAsReadScheduler, logger = config.logger, pubSub = config.pubSub;
+    var userId = config.userId, markAsReadScheduler = config.markAsReadScheduler, logger = config.logger, pubSub = config.pubSub;
     // ScrollHandler initialization
     var _j = useMessageListScroll(scrollBehavior, [(_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url]), scrollRef = _j.scrollRef, scrollPubSub = _j.scrollPubSub, scrollDistanceFromBottomRef = _j.scrollDistanceFromBottomRef, scrollPositionRef = _j.scrollPositionRef;
     var isScrollBottomReached = state.isScrollBottomReached;
@@ -501,6 +544,32 @@ var GroupChannelManager = function (props) {
             return message.ReplyType.NONE;
         return message.ReplyType.ONLY_REPLY_TO_CHANNEL;
     });
+    var markAsUnreadSourceRef = React.useRef(undefined);
+    var markAsUnread = React.useCallback(function (message, source) {
+        var _a, _b, _c, _d;
+        if (!config.groupChannel.enableMarkAsUnread)
+            return;
+        if (!state.currentChannel) {
+            (_a = logger === null || logger === void 0 ? void 0 : logger.error) === null || _a === void 0 ? void 0 : _a.call(logger, 'GroupChannelProvider: channel is required for markAsUnread');
+            return;
+        }
+        try {
+            if (state.currentChannel.markAsUnread) {
+                state.currentChannel.markAsUnread(message);
+                (_b = logger === null || logger === void 0 ? void 0 : logger.info) === null || _b === void 0 ? void 0 : _b.call(logger, 'GroupChannelProvider: markAsUnread called for message', {
+                    messageId: message.messageId,
+                    source: source || 'unknown',
+                });
+                markAsUnreadSourceRef.current = source || 'internal';
+            }
+            else {
+                (_c = logger === null || logger === void 0 ? void 0 : logger.error) === null || _c === void 0 ? void 0 : _c.call(logger, 'GroupChannelProvider: markAsUnread method not available in current SDK version');
+            }
+        }
+        catch (error) {
+            (_d = logger === null || logger === void 0 ? void 0 : logger.error) === null || _d === void 0 ? void 0 : _d.call(logger, 'GroupChannelProvider: markAsUnread failed', error);
+        }
+    }, [state.currentChannel, logger, config.groupChannel.enableMarkAsUnread]);
     // Message Collection setup
     var messageDataSource = uikitTools.useGroupChannelMessages(sdkStore.sdk, state.currentChannel, {
         startingPoint: startingPoint,
@@ -508,8 +577,10 @@ var GroupChannelManager = function (props) {
         collectionCreator: getCollectionCreator(state.currentChannel, messageListQueryParams),
         shouldCountNewMessages: function () { return !isScrollBottomReached; },
         markAsRead: function (channels) {
-            if (isScrollBottomReached && !disableMarkAsRead) {
-                channels.forEach(function (it) { return markAsReadScheduler.push(it); });
+            if (!config.groupChannel.enableMarkAsUnread) {
+                if (isScrollBottomReached && !disableMarkAsRead) {
+                    channels.forEach(function (it) { return markAsReadScheduler.push(it); });
+                }
             }
         },
         onMessagesReceived: function (messages) {
@@ -519,7 +590,9 @@ var GroupChannelManager = function (props) {
                 // even though the next messages and the current messages length are the same.
                 // So added this condition to check if they are the same to prevent unnecessary calling scrollToBottom action
                 && messages.length !== state.messages.length) {
-                setTimeout(function () { return actions.scrollToBottom(true); }, 10);
+                setTimeout(function () { return _tslib.__awaiter(void 0, void 0, void 0, function () { return _tslib.__generator(this, function (_a) {
+                    return [2 /*return*/, actions.scrollToBottom(true)];
+                }); }); }, 10);
             }
         },
         onChannelDeleted: function () {
@@ -530,7 +603,15 @@ var GroupChannelManager = function (props) {
             actions.setCurrentChannel(null);
             onBackClick === null || onBackClick === void 0 ? void 0 : onBackClick();
         },
-        onChannelUpdated: function (channel) {
+        onChannelUpdated: function (channel, ctx) {
+            if (ctx.source === SendbirdChat.CollectionEventSource.EVENT_CHANNEL_UNREAD
+                && ctx.userIds.includes(userId)) {
+                actions.setReadStateChanged('unread');
+            }
+            if (ctx.source === SendbirdChat.CollectionEventSource.EVENT_CHANNEL_READ
+                && ctx.userIds.includes(userId)) {
+                actions.setReadStateChanged('read');
+            }
             actions.setCurrentChannel(channel);
         },
         logger: logger,
@@ -576,8 +657,8 @@ var GroupChannelManager = function (props) {
             if ((pubSub === null || pubSub === void 0 ? void 0 : pubSub.subscribe) === undefined)
                 return [2 /*return*/];
             subscriptions = [
-                config.pubSub.subscribe(pubSub_topics.pubSubTopics.SEND_USER_MESSAGE, handleExternalMessage),
-                config.pubSub.subscribe(pubSub_topics.pubSubTopics.SEND_FILE_MESSAGE, handleExternalMessage),
+                pubSub.subscribe(pubSub_topics.pubSubTopics.SEND_USER_MESSAGE, handleExternalMessage),
+                pubSub.subscribe(pubSub_topics.pubSubTopics.SEND_FILE_MESSAGE, handleExternalMessage),
             ];
             return [2 /*return*/, function () {
                     subscriptions.forEach(function (subscription) { return subscription.remove(); });
@@ -662,9 +743,9 @@ var GroupChannelManager = function (props) {
         isScrollBottomReached,
     ]);
     useDeepCompareEffect.useDeepCompareEffect(function () {
-        updateState(_tslib.__assign(_tslib.__assign(_tslib.__assign(_tslib.__assign(_tslib.__assign({ 
+        updateState(_tslib.__assign(_tslib.__assign(_tslib.__assign(_tslib.__assign(_tslib.__assign(_tslib.__assign({ 
             // Channel state
-            channelUrl: channelUrl, currentChannel: state.currentChannel }, configurations), scrollState), eventHandlers), renderProps), messageDataSource));
+            channelUrl: channelUrl, currentChannel: state.currentChannel }, configurations), scrollState), eventHandlers), renderProps), messageDataSource), { markAsUnread: markAsUnread, markAsUnreadSourceRef: markAsUnreadSourceRef }));
     }, [
         channelUrl,
         (_c = state.currentChannel) === null || _c === void 0 ? void 0 : _c.serialize(),
@@ -679,7 +760,7 @@ var GroupChannelManager = function (props) {
     return children;
 };
 var GroupChannelProvider = function (props) {
-    return (React__default.default.createElement(InternalGroupChannelProvider, _tslib.__assign({}, props),
+    return (React__default.default.createElement(InternalGroupChannelProvider, _tslib.__assign({ key: props.channelUrl }, props),
         React__default.default.createElement(GroupChannelManager, _tslib.__assign({}, props),
             React__default.default.createElement(UserProfileContext.UserProfileProvider, _tslib.__assign({}, props), props.children))));
 };
@@ -688,7 +769,7 @@ var GroupChannelProvider = function (props) {
  * @returns {ReturnType<typeof createStore<GroupChannelState>>}
  */
 var useGroupChannelStore = function () {
-    return SendbirdContext.useStore(GroupChannelContext, function (state) { return state; }, initialState);
+    return SendbirdContext.useStore(GroupChannelContext, function (state) { return state; }, initialState());
 };
 // Keep this function for backward compatibility.
 var useGroupChannelContext = function () {
@@ -708,4 +789,4 @@ exports.GroupChannelProvider = GroupChannelProvider;
 exports.InternalGroupChannelProvider = InternalGroupChannelProvider;
 exports.useGroupChannel = useGroupChannel;
 exports.useGroupChannelContext = useGroupChannelContext;
-//# sourceMappingURL=bundle-bti4bXDj.js.map
+//# sourceMappingURL=bundle-C0RMVFg8.js.map

package/cjs/chunks/{bundle-bti4bXDj.js.map → bundle-C0RMVFg8.js.map}

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

package/cjs/chunks/{bundle-DEP1sxOT.js → bundle-C5D9vwVf.js}

@@ -1,9 +1,9 @@
 'use strict';
 
 var React = require('react');
-var pubSub_topics = require('./bundle-Dq_3Fsbm.js');
-var _tslib = require('./bundle-t_oZmZ9n.js');
-var useSendbird = require('./bundle-Ca9F08jN.js');
+var pubSub_topics = require('./bundle-dUH189qO.js');
+var _tslib = require('./bundle-Conb-pOy.js');
+var useSendbird = require('./bundle-Bq15P9qk.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -341,4 +341,4 @@ exports.OpenChannelListActionTypes = OpenChannelListActionTypes$1;
 exports.OpenChannelListProvider = OpenChannelListProvider;
 exports.OpenChannelListProvider$1 = OpenChannelListProvider$1;
 exports.useOpenChannelListContext = useOpenChannelListContext;
-//# sourceMappingURL=bundle-DEP1sxOT.js.map
+//# sourceMappingURL=bundle-C5D9vwVf.js.map

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

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

package/cjs/chunks/{bundle-DJtO7Gzg.js → bundle-C5p82xwC.js}

@@ -1,8 +1,8 @@
 'use strict';
 
-var _tslib = require('./bundle-t_oZmZ9n.js');
+var _tslib = require('./bundle-Conb-pOy.js');
 var React = require('react');
-var MediaQueryContext = require('./bundle-CTarVwtF.js');
+var MediaQueryContext = require('./bundle-Fv6PNPGZ.js');
 
 var DEFAULT_DURATION = 300;
 function preventDefault(e) {
@@ -76,4 +76,4 @@ function useLongPress(_a, _b) {
 }
 
 exports.useLongPress = useLongPress;
-//# sourceMappingURL=bundle-DJtO7Gzg.js.map
+//# sourceMappingURL=bundle-C5p82xwC.js.map

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

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

package/cjs/chunks/bundle-C6rru8Hj.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var _tslib = require('./bundle-Conb-pOy.js');
+
+var uikitConfigStorage = {
+    getItem: function (key) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var _a;
+            return _tslib.__generator(this, function (_b) {
+                return [2 /*return*/, (_a = localStorage.getItem(key)) !== null && _a !== void 0 ? _a : null];
+            });
+        });
+    },
+    setItem: function (key, value) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                return [2 /*return*/, localStorage.setItem(key, value)];
+            });
+        });
+    },
+};
+
+exports.uikitConfigStorage = uikitConfigStorage;
+//# sourceMappingURL=bundle-C6rru8Hj.js.map

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

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

package/cjs/chunks/{bundle-CQ3azLOm.js → bundle-C8INNeGk.js}

@@ -22,4 +22,4 @@ function useReconnectOnIdle(isOnline, currentGroupChannel, reconnectOnIdle) {
 }
 
 exports.useReconnectOnIdle = useReconnectOnIdle;
-//# sourceMappingURL=bundle-CQ3azLOm.js.map
+//# sourceMappingURL=bundle-C8INNeGk.js.map

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

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

package/cjs/chunks/{bundle-CcbqrlOG.js → bundle-C99t7tzf.js}

@@ -14,4 +14,4 @@ var pxToNumber = function (px) {
 };
 
 exports.pxToNumber = pxToNumber;
-//# sourceMappingURL=bundle-CcbqrlOG.js.map
+//# sourceMappingURL=bundle-C99t7tzf.js.map

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

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

package/cjs/chunks/{bundle-Bho3lWXj.js → bundle-CHAKEXIJ.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var index = require('./bundle-CZ9HZzlb.js');
-var index$1 = require('./bundle-mZOg8YmN.js');
+var index = require('./bundle-CVJwHwWn.js');
+var index$1 = require('./bundle-Cyl6_qLo.js');
 
 /**
  * @name isDate
@@ -1647,4 +1647,4 @@ function cleanEscapedString(input) {
 
 exports.format = format;
 exports.toInteger = toInteger;
-//# sourceMappingURL=bundle-Bho3lWXj.js.map
+//# sourceMappingURL=bundle-CHAKEXIJ.js.map