@sendbird/uikit-react 3.14.4 → 3.14.6

package/chunks/{bundle-BjrRhdgd.js → bundle-D5P54ZJi.js}

@@ -4,16 +4,17 @@ import IconButton from '../ui/IconButton.js';
 import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
 import ContextMenu, { MenuItems, OperatorMenuItem, MuteMenuItem, MenuItem } from '../ui/ContextMenu.js';
 import UserListItem$1 from '../ChannelSettings/components/UserListItem.js';
-import { _ as __assign, a as __awaiter, b as __generator, c as __spreadArray, e as __rest } from './bundle-7oF7KbGv.js';
+import { c as __spreadArray, a as __awaiter, b as __generator, e as __rest } from './bundle-DKkCwVCs.js';
 import { Role } from '@sendbird/chat';
-import { M as Modal } from './bundle-C4Z-NWqF.js';
+import { M as Modal } from './bundle-CGmq3qGM.js';
 import UserListItem from '../ui/UserListItem.js';
-import { n as noop } from './bundle-ByvmbZD0.js';
+import { n as noop } from './bundle-Dw9nwO7e.js';
 import { useChannelSettingsContext } from '../ChannelSettings/context.js';
 import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
-import { L as LocalizationContext, u as useLocalization } from './bundle-Bx5vhTbU.js';
-import { u as useOnScrollPositionChangeDetector } from './bundle-DaoHZIZy.js';
-import './bundle-LYAWKk4n.js';
+import { L as LocalizationContext, u as useLocalization } from './bundle-nfJ9J5Md.js';
+import { u as useOnScrollPositionChangeDetector } from './bundle-Ck_ke5Gq.js';
+import './bundle-prXB4t_m.js';
+import { u as uuidv4 } from './bundle-uIqOEfCa.js';
 
 function MembersModal(_a) {
     var _this = this;
@@ -29,19 +30,17 @@ function MembersModal(_a) {
         var memberListQuery = channel === null || channel === void 0 ? void 0 : channel.createMemberListQuery({
             limit: 20,
         });
-        memberListQuery.next().then(function (members) {
+        memberListQuery === null || memberListQuery === void 0 ? void 0 : memberListQuery.next().then(function (members) {
             setMembers(members);
         });
-        setMemberQuery(memberListQuery);
+        setMemberQuery(memberListQuery !== null && memberListQuery !== void 0 ? memberListQuery : null);
     }, []);
     return (React__default.createElement("div", null,
         React__default.createElement(Modal, { isFullScreenOnMobile: true, hideFooter: true, onCancel: function () { return onCancel(); }, onSubmit: noop, titleText: stringSet.CHANNEL_SETTING__MEMBERS__SEE_ALL_MEMBERS },
             React__default.createElement("div", { className: "sendbird-more-members__popup-scroll", onScroll: useOnScrollPositionChangeDetector({
                     onReachedBottom: function () { return __awaiter(_this, void 0, void 0, function () {
-                        var hasNext;
                         return __generator(this, function (_a) {
-                            hasNext = memberQuery.hasNext;
-                            if (hasNext) {
+                            if (memberQuery && memberQuery.hasNext) {
                                 memberQuery.next().then(function (o) {
                                     setMembers(__spreadArray(__spreadArray([], members, true), o, true));
                                 });
@@ -57,12 +56,14 @@ function MembersModal(_a) {
                                 } },
                                 React__default.createElement(Icon, { width: "24px", height: "24px", type: IconTypes.MORE, fillColor: IconColors.CONTENT_INVERSE }))); }, menuItems: function (closeDropdown) { return (React__default.createElement(MenuItems, { parentContainRef: parentRef, parentRef: actionRef, closeDropdown: closeDropdown, openLeft: true },
                                 React__default.createElement(OperatorMenuItem, { channel: channel, user: member, disable: currentUserId === member.userId, onChange: function (_, member, isOperator) {
-                                        setMembers(members.map(function (m) {
-                                            if (m.userId === member.userId) {
-                                                return __assign(__assign({}, member), { role: isOperator ? Role.OPERATOR : Role.NONE });
+                                        var newMembers = __spreadArray([], members, true);
+                                        for (var _i = 0, newMembers_1 = newMembers; _i < newMembers_1.length; _i++) {
+                                            var newMember = newMembers_1[_i];
+                                            if (newMember.userId === member.userId) {
+                                                newMember.role = isOperator ? Role.OPERATOR : Role.NONE;
                                             }
-                                            return m;
-                                        }));
+                                        }
+                                        setMembers(newMembers);
                                         closeDropdown();
                                     }, onError: function () {
                                         // FIXME: handle error later
@@ -72,12 +73,14 @@ function MembersModal(_a) {
                                     : stringSet.CHANNEL_SETTING__MODERATION__UNREGISTER_OPERATOR),
                                 // No muted members in broadcast channel
                                 !(channel === null || channel === void 0 ? void 0 : channel.isBroadcast) && (React__default.createElement(MuteMenuItem, { channel: channel, user: member, onChange: function (_, member, isMuted) {
-                                        setMembers(members.map(function (m) {
-                                            if (m.userId === member.userId) {
-                                                return __assign(__assign({}, member), { isMuted: isMuted });
+                                        var newMembers = __spreadArray([], members, true);
+                                        for (var _i = 0, newMembers_2 = newMembers; _i < newMembers_2.length; _i++) {
+                                            var newMember = newMembers_2[_i];
+                                            if (newMember.userId === member.userId) {
+                                                newMember.isMuted = isMuted;
                                             }
-                                            return m;
-                                        }));
+                                        }
+                                        setMembers(newMembers);
                                         closeDropdown();
                                     }, onError: function () {
                                         // FIXME: handle error later
@@ -134,7 +137,7 @@ function InviteUsers(_a) {
             switch (_a.label) {
                 case 0:
                     userIdsToInvite = Object.keys(selectedUsers);
-                    if (!(typeof overrideInviteUser === 'function')) return [3 /*break*/, 1];
+                    if (!(channel && typeof overrideInviteUser === 'function')) return [3 /*break*/, 1];
                     overrideInviteUser({ users: userIdsToInvite, onClose: onCancel, channel: channel });
                     return [3 /*break*/, 3];
                 case 1: return [4 /*yield*/, (channel === null || channel === void 0 ? void 0 : channel.inviteWithUserIds(userIdsToInvite))];
@@ -160,9 +163,10 @@ function InviteUsers(_a) {
     };
     var membersMap = useMemo(function () {
         var _a;
+        var _b, _c;
         // UIKit policy: In a super or broadcast channel, do not check the members when inviting users.
         if ((channel === null || channel === void 0 ? void 0 : channel.isSuper) || (channel === null || channel === void 0 ? void 0 : channel.isBroadcast))
-            return _a = {}, _a[sdk.currentUser.userId] = sdk.currentUser, _a;
+            return _a = {}, _a[(_c = (_b = sdk.currentUser) === null || _b === void 0 ? void 0 : _b.userId) !== null && _c !== void 0 ? _c : ''] = sdk.currentUser, _a;
         return channel === null || channel === void 0 ? void 0 : channel.members.reduce(function (acc, cur) {
             acc[cur.userId] = cur;
             return acc;
@@ -193,7 +197,7 @@ function InviteUsers(_a) {
         React__default.createElement(Modal, { isFullScreenOnMobile: true, disabled: Object.keys(selectedUsers).length === 0, submitText: stringSet.BUTTON__INVITE, type: ButtonTypes.PRIMARY, onCancel: function () { return onCancel(); }, onSubmit: onInviteUsers, titleText: stringSet.CHANNEL_SETTING__MEMBERS__SELECT_TITLE },
             React__default.createElement("div", { className: "sendbird-more-members__popup-scroll", onScroll: onScroll },
                 React__default.createElement("div", { className: "sendbird-more-members__popup-scroll__inner" }, users.map(function (user) {
-                    var isMember = Boolean(membersMap[user.userId]);
+                    var isMember = Boolean(membersMap ? membersMap[user.userId] : false);
                     var isSelected = Boolean(selectedUsers[user.userId]);
                     return (React__default.createElement(UserListItem, { key: user.userId, checkBox: true, checked: isMember || isSelected, disabled: isMember, user: user, onChange: function () { return onSelectUser(user); } }));
                 }))))));
@@ -206,7 +210,7 @@ var MemberList = function () {
     var _f = useState(false), showAllMembers = _f[0], setShowAllMembers = _f[1];
     var _g = useState(false), showInviteUsers = _g[0], setShowInviteUsers = _g[1];
     var state = useSendbirdStateContext();
-    var channel = useChannelSettingsContext().channel;
+    var _h = useChannelSettingsContext(), channel = _h.channel, setChannelUpdateId = _h.setChannelUpdateId;
     var stringSet = useContext(LocalizationContext).stringSet;
     var sdk = (_b = (_a = state === null || state === void 0 ? void 0 : state.stores) === null || _a === void 0 ? void 0 : _a.sdkStore) === null || _b === void 0 ? void 0 : _b.sdk;
     var userId = (_c = state === null || state === void 0 ? void 0 : state.config) === null || _c === void 0 ? void 0 : _c.userId;
@@ -230,35 +234,39 @@ var MemberList = function () {
         memberUserListQuery.next().then(function (members) {
             setMembers(members);
             setHasNext(memberUserListQuery.hasNext);
+            setChannelUpdateId === null || setChannelUpdateId === void 0 ? void 0 : setChannelUpdateId(uuidv4());
         });
     }, [channel]);
     return (React__default.createElement("div", { className: "sendbird-channel-settings-member-list" },
-        members.map(function (member) { return (React__default.createElement(UserListItem$1, { key: member.userId, user: member, currentUser: sdk.currentUser.userId, action: ((channel === null || channel === void 0 ? void 0 : channel.myRole) === 'operator' && userId !== member.userId)
-                ? function (_a) {
-                    var actionRef = _a.actionRef, parentRef = _a.parentRef;
-                    return (React__default.createElement(ContextMenu, { menuTrigger: function (toggleDropdown) { return (React__default.createElement(IconButton, { className: "sendbird-user-message__more__menu", width: "32px", height: "32px", onClick: toggleDropdown },
-                            React__default.createElement(Icon, { width: "24px", height: "24px", type: IconTypes.MORE, fillColor: IconColors.CONTENT_INVERSE }))); }, menuItems: function (closeDropdown) { return (React__default.createElement(MenuItems, { parentContainRef: parentRef, parentRef: actionRef, closeDropdown: closeDropdown, openLeft: true },
-                            React__default.createElement(OperatorMenuItem, { channel: channel, user: member, onChange: function () {
-                                    refreshList();
-                                    closeDropdown();
-                                }, onError: noop, dataSbId: "channel_setting_member_context_menu_".concat((member.role !== 'operator') ? 'register_as_operator' : 'unregister_operator') }, member.role !== 'operator'
-                                ? stringSet.CHANNEL_SETTING__MODERATION__REGISTER_AS_OPERATOR
-                                : stringSet.CHANNEL_SETTING__MODERATION__UNREGISTER_OPERATOR),
-                            // No muted members in broadcast channel
-                            !(channel === null || channel === void 0 ? void 0 : channel.isBroadcast) && (React__default.createElement(MuteMenuItem, { channel: channel, user: member, onChange: function () {
-                                    refreshList();
-                                    closeDropdown();
-                                }, onError: noop, dataSbId: "channel_setting_member_context_menu_".concat(member.isMuted ? 'unmute' : 'mute') }, member.isMuted
-                                ? stringSet.CHANNEL_SETTING__MODERATION__UNMUTE
-                                : stringSet.CHANNEL_SETTING__MODERATION__MUTE)),
-                            React__default.createElement(MenuItem, { onClick: function () {
-                                    channel === null || channel === void 0 ? void 0 : channel.banUser(member, -1, '').then(function () {
+        members.map(function (member) {
+            var _a;
+            return (React__default.createElement(UserListItem$1, { key: member.userId, user: member, currentUser: (_a = sdk === null || sdk === void 0 ? void 0 : sdk.currentUser) === null || _a === void 0 ? void 0 : _a.userId, action: ((channel === null || channel === void 0 ? void 0 : channel.myRole) === 'operator' && userId !== member.userId)
+                    ? function (_a) {
+                        var actionRef = _a.actionRef, parentRef = _a.parentRef;
+                        return (React__default.createElement(ContextMenu, { menuTrigger: function (toggleDropdown) { return (React__default.createElement(IconButton, { className: "sendbird-user-message__more__menu", width: "32px", height: "32px", onClick: toggleDropdown },
+                                React__default.createElement(Icon, { width: "24px", height: "24px", type: IconTypes.MORE, fillColor: IconColors.CONTENT_INVERSE }))); }, menuItems: function (closeDropdown) { return (React__default.createElement(MenuItems, { parentContainRef: parentRef, parentRef: actionRef, closeDropdown: closeDropdown, openLeft: true },
+                                React__default.createElement(OperatorMenuItem, { channel: channel, user: member, onChange: function () {
                                         refreshList();
                                         closeDropdown();
-                                    });
-                                }, dataSbId: "channel_setting_member_context_menu_ban" }, stringSet.CHANNEL_SETTING__MODERATION__BAN))); } }));
-                }
-                : null })); }),
+                                    }, onError: noop, dataSbId: "channel_setting_member_context_menu_".concat((member.role !== 'operator') ? 'register_as_operator' : 'unregister_operator') }, member.role !== 'operator'
+                                    ? stringSet.CHANNEL_SETTING__MODERATION__REGISTER_AS_OPERATOR
+                                    : stringSet.CHANNEL_SETTING__MODERATION__UNREGISTER_OPERATOR),
+                                // No muted members in broadcast channel
+                                !(channel === null || channel === void 0 ? void 0 : channel.isBroadcast) && (React__default.createElement(MuteMenuItem, { channel: channel, user: member, onChange: function () {
+                                        refreshList();
+                                        closeDropdown();
+                                    }, onError: noop, dataSbId: "channel_setting_member_context_menu_".concat(member.isMuted ? 'unmute' : 'mute') }, member.isMuted
+                                    ? stringSet.CHANNEL_SETTING__MODERATION__UNMUTE
+                                    : stringSet.CHANNEL_SETTING__MODERATION__MUTE)),
+                                React__default.createElement(MenuItem, { onClick: function () {
+                                        channel === null || channel === void 0 ? void 0 : channel.banUser(member, -1, '').then(function () {
+                                            refreshList();
+                                            closeDropdown();
+                                        });
+                                    }, dataSbId: "channel_setting_member_context_menu_ban" }, stringSet.CHANNEL_SETTING__MODERATION__BAN))); } }));
+                    }
+                    : function () { return null; } }));
+        }),
         React__default.createElement("div", { className: "sendbird-channel-settings-accordion__footer" },
             hasNext && (React__default.createElement(Button, { type: ButtonTypes.SECONDARY, size: ButtonSizes.SMALL, onClick: function () { return setShowAllMembers(true); } }, stringSet.CHANNEL_SETTING__MEMBERS__SEE_ALL_MEMBERS)),
             React__default.createElement(Button, { type: ButtonTypes.SECONDARY, size: ButtonSizes.SMALL, onClick: function () { return setShowInviteUsers(true); } }, stringSet.CHANNEL_SETTING__MEMBERS__INVITE_MEMBER)),
@@ -273,4 +281,4 @@ var MemberList = function () {
 };
 
 export { MemberList as M };
-//# sourceMappingURL=bundle-BjrRhdgd.js.map
+//# sourceMappingURL=bundle-D5P54ZJi.js.map

package/chunks/{bundle-BjrRhdgd.js.map → bundle-D5P54ZJi.js.map}

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

package/chunks/{bundle-BHn3F_OF.js → bundle-D9dyuFq0.js}

@@ -1,18 +1,18 @@
 import React__default, { useContext } from 'react';
-import { M as Modal } from './bundle-C4Z-NWqF.js';
-import './bundle-7oF7KbGv.js';
-import './bundle-LYAWKk4n.js';
+import { M as Modal } from './bundle-CGmq3qGM.js';
+import './bundle-DKkCwVCs.js';
+import './bundle-prXB4t_m.js';
 import { ButtonTypes } from '../ui/Button.js';
-import { L as LocalizationContext } from './bundle-Bx5vhTbU.js';
+import { L as LocalizationContext } from './bundle-nfJ9J5Md.js';
 import { useThreadContext } from '../Thread/context.js';
-import { g as getModalDeleteMessageTitle } from './bundle-DzxiMlgV.js';
+import { g as getModalDeleteMessageTitle } from './bundle-DvNDJy8Z.js';
 
 var RemoveMessage = function (props) {
-    var _a;
+    var _a, _b;
     var onCancel = props.onCancel, onSubmit = props.onSubmit, message = props.message;
     var stringSet = useContext(LocalizationContext).stringSet;
     var deleteMessage = useThreadContext().deleteMessage;
-    return (React__default.createElement(Modal, { type: ButtonTypes.DANGER, disabled: ((_a = message === null || message === void 0 ? void 0 : message.threadInfo) === null || _a === void 0 ? void 0 : _a.replyCount) > 0, onCancel: onCancel, onSubmit: function () {
+    return (React__default.createElement(Modal, { type: ButtonTypes.DANGER, disabled: ((_b = (_a = message.threadInfo) === null || _a === void 0 ? void 0 : _a.replyCount) !== null && _b !== void 0 ? _b : 0) > 0, onCancel: onCancel, onSubmit: function () {
             deleteMessage(message).then(function () {
                 onCancel === null || onCancel === void 0 ? void 0 : onCancel();
                 onSubmit === null || onSubmit === void 0 ? void 0 : onSubmit();
@@ -21,4 +21,4 @@ var RemoveMessage = function (props) {
 };
 
 export { RemoveMessage as R };
-//# sourceMappingURL=bundle-BHn3F_OF.js.map
+//# sourceMappingURL=bundle-D9dyuFq0.js.map

package/chunks/bundle-D9dyuFq0.js.map

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

package/chunks/{bundle-7oF7KbGv.js → bundle-DKkCwVCs.js}

@@ -106,4 +106,4 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 export { __assign as _, __awaiter as a, __generator as b, __spreadArray as c, __extends as d, __rest as e };
-//# sourceMappingURL=bundle-7oF7KbGv.js.map
+//# sourceMappingURL=bundle-DKkCwVCs.js.map

package/chunks/{bundle-7oF7KbGv.js.map → bundle-DKkCwVCs.js.map}

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

package/chunks/{bundle-k3XccyCm.js → bundle-DKs8lowG.js}

@@ -1,7 +1,7 @@
-import React__default, { useCallback, useEffect, useContext, useMemo, useReducer } from 'react';
-import { p as pubSubTopics } from './bundle-BWuyd0AD.js';
+import React__default, { useCallback, useEffect, useContext, useReducer } from 'react';
+import { p as pubSubTopics } from './bundle-CriEArZn.js';
 import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
-import { _ as __assign, c as __spreadArray } from './bundle-7oF7KbGv.js';
+import { _ as __assign, c as __spreadArray } from './bundle-DKkCwVCs.js';
 
 var OpenChannelListFetchingStatus;
 (function (OpenChannelListFetchingStatus) {
@@ -97,7 +97,7 @@ function useFetchNextCallback(_a, _b) {
             });
             openChannelListQuery.next()
                 .then(function (channelList) {
-                callback(channelList, null);
+                callback(channelList, undefined);
                 logger.info('OpenChannelList|useFetchNextCallback: Succeeded fetching channels', channelList);
                 openChannelListDispatcher({
                     type: OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_SUCCESS,
@@ -105,7 +105,7 @@ function useFetchNextCallback(_a, _b) {
                 });
             })
                 .catch(function (err) {
-                callback(null, err);
+                callback(undefined, err);
                 logger.error('OpenChannelList|useFetchNextCallback: Failed fetching channels', err);
                 openChannelListDispatcher({
                     type: OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_FAILURE,
@@ -127,6 +127,7 @@ function createChannelListQuery(_a) {
     params.includeFrozen = true;
     if (openChannelListQuery) {
         Object.keys(openChannelListQuery).forEach(function (key) {
+            // @ts-ignore
             params[key] = openChannelListQuery[key];
         });
     }
@@ -143,46 +144,40 @@ function useSetupOpenChannelList(_a, _b) {
     var sdk = _a.sdk, sdkInitialized = _a.sdkInitialized, openChannelListQuery = _a.openChannelListQuery;
     var logger = _b.logger, openChannelListDispatcher = _b.openChannelListDispatcher;
     useEffect(function () {
-        var _a;
         if (sdkInitialized) {
             if (sdk === null || sdk === void 0 ? void 0 : sdk.openChannel) {
-                if ((_a = sdk === null || sdk === void 0 ? void 0 : sdk.openChannel) === null || _a === void 0 ? void 0 : _a.createOpenChannelListQuery) {
-                    logger.info('OpenChannelList|useSetupOpenChannelList: Setup OpenChannelList', { sdkInitialized: sdkInitialized });
-                    var channelListQuery = createChannelListQuery({
-                        sdk: sdk,
-                        logger: logger,
-                        openChannelListQuery: openChannelListQuery,
-                        openChannelListDispatcher: openChannelListDispatcher,
-                        logMessage: 'OpenChannelList|useSetupOpenChannelList: Succeeded create channelListQuery',
+                logger.info('OpenChannelList|useSetupOpenChannelList: Setup OpenChannelList', { sdkInitialized: sdkInitialized });
+                var channelListQuery = createChannelListQuery({
+                    sdk: sdk,
+                    logger: logger,
+                    openChannelListQuery: openChannelListQuery,
+                    openChannelListDispatcher: openChannelListDispatcher,
+                    logMessage: 'OpenChannelList|useSetupOpenChannelList: Succeeded create channelListQuery',
+                });
+                if (channelListQuery === null || channelListQuery === void 0 ? void 0 : channelListQuery.hasNext) {
+                    logger.info('OpenChannelList|useSetupOpenChannelList: Fetch channels');
+                    openChannelListDispatcher({
+                        type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_START,
+                        payload: null,
                     });
-                    if (channelListQuery === null || channelListQuery === void 0 ? void 0 : channelListQuery.hasNext) {
-                        logger.info('OpenChannelList|useSetupOpenChannelList: Fetch channels');
+                    channelListQuery.next()
+                        .then(function (channelList) {
+                        logger.info('OpenChannelList|useSetupOpenChannelList: Succeeded fetching channels', channelList);
                         openChannelListDispatcher({
-                            type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_START,
-                            payload: null,
+                            type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_SUCCESS,
+                            payload: channelList,
                         });
-                        channelListQuery.next()
-                            .then(function (channelList) {
-                            logger.info('OpenChannelList|useSetupOpenChannelList: Succeeded fetching channels', channelList);
-                            openChannelListDispatcher({
-                                type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_SUCCESS,
-                                payload: channelList,
-                            });
-                        })
-                            .catch(function (err) {
-                            logger.error('OpenChannelList|useSetupOpenChannelList: Failed fetching channels', err);
-                            openChannelListDispatcher({
-                                type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_FAILURE,
-                                payload: null,
-                            });
+                    })
+                        .catch(function (err) {
+                        logger.error('OpenChannelList|useSetupOpenChannelList: Failed fetching channels', err);
+                        openChannelListDispatcher({
+                            type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_FAILURE,
+                            payload: null,
                         });
-                    }
-                    else {
-                        logger.info('OpenChannelList|useSetupOpenChannelList: There is no more channels');
-                    }
+                    });
                 }
                 else {
-                    logger.warning('OpenChannelList|useSetupOpenChannelList: createOpenChannelListQuery is not included in the openChannel', sdk.openChannel);
+                    logger.info('OpenChannelList|useSetupOpenChannelList: There is no more channels');
                 }
             }
             else {
@@ -256,19 +251,11 @@ function useRefreshOpenChannelList(_a, _b) {
     }, [sdkInitialized, openChannelListQuery]);
 }
 
-var OpenChannelListContext = React__default.createContext({
-    onChannelSelected: null,
-    currentChannel: null,
-    allChannels: [],
-    fetchingStatus: OpenChannelListFetchingStatus.EMPTY,
-    customOpenChannelListQuery: {},
-    fetchNextChannels: null,
-    refreshOpenChannelList: null,
-    openChannelListDispatcher: null,
-    logger: null,
-});
+var OpenChannelListContext = React__default.createContext(null);
 function useOpenChannelListContext() {
     var context = useContext(OpenChannelListContext);
+    if (!context)
+        throw new Error('OpenChannelListContext not found. Use within the OpenChannelList module.');
     return context;
 }
 var OpenChannelListProvider = function (_a) {
@@ -279,9 +266,7 @@ var OpenChannelListProvider = function (_a) {
     var logger = config.logger, pubSub = config.pubSub;
     var sdk = ((_b = stores === null || stores === void 0 ? void 0 : stores.sdkStore) === null || _b === void 0 ? void 0 : _b.sdk) || null;
     var sdkInitialized = ((_c = stores === null || stores === void 0 ? void 0 : stores.sdkStore) === null || _c === void 0 ? void 0 : _c.initialized) || false;
-    var customOpenChannelListQuery = useMemo(function () {
-        return (queries === null || queries === void 0 ? void 0 : queries.openChannelListQuery) || null;
-    }, [queries === null || queries === void 0 ? void 0 : queries.openChannelListQuery]);
+    var customOpenChannelListQuery = queries === null || queries === void 0 ? void 0 : queries.openChannelListQuery;
     // dux
     var _e = useReducer(reducer, openChannelListInitialState), openChannelListStore = _e[0], openChannelListDispatcher = _e[1];
     var allChannels = openChannelListStore.allChannels, currentChannel = openChannelListStore.currentChannel, fetchingStatus = openChannelListStore.fetchingStatus, channelListQuery = openChannelListStore.channelListQuery;
@@ -296,22 +281,15 @@ var OpenChannelListProvider = function (_a) {
     });
     // Events & PubSub
     useEffect(function () {
-        var subscriber = (pubSub === null || pubSub === void 0 ? void 0 : pubSub.subscribe) ? new Map() : null;
-        subscriber === null || subscriber === void 0 ? void 0 : subscriber.set(pubSubTopics.UPDATE_OPEN_CHANNEL, pubSub === null || pubSub === void 0 ? void 0 : pubSub.subscribe(pubSubTopics.UPDATE_OPEN_CHANNEL, function (channel) {
+        var subscriber = new Map();
+        subscriber.set(pubSubTopics.UPDATE_OPEN_CHANNEL, pubSub.subscribe(pubSubTopics.UPDATE_OPEN_CHANNEL, function (channel) {
             openChannelListDispatcher({
                 type: OpenChannelListActionTypes$1.UPDATE_OPEN_CHANNEL,
                 payload: channel,
             });
         }));
         return function () {
-            subscriber === null || subscriber === void 0 ? void 0 : subscriber.forEach(function (s) {
-                try {
-                    s.remove();
-                }
-                catch (_a) {
-                    //
-                }
-            });
+            subscriber.forEach(function (it) { return it.remove(); });
         };
     }, [sdkInitialized, pubSub]);
     // Fetch next channels by scroll event
@@ -352,4 +330,4 @@ var OpenChannelListProvider$1 = {
 };
 
 export { OpenChannelListProvider as O, OpenChannelListFetchingStatus as a, OpenChannelListActionTypes$1 as b, OpenChannelListProvider$1 as c, useOpenChannelListContext as u };
-//# sourceMappingURL=bundle-k3XccyCm.js.map
+//# sourceMappingURL=bundle-DKs8lowG.js.map

package/{cjs/chunks/bundle-D6E8Fmnl.js.map → chunks/bundle-DKs8lowG.js.map}

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

package/chunks/{bundle-oCSRGy9i.js → bundle-DQZG-uS3.js}

@@ -4,31 +4,31 @@ var LOG_PRESET = 'useToggleReactionCallback:';
 function useToggleReactionCallback(currentChannel, logger) {
     return useCallback(function (message, key, isReacted) {
         if (!currentChannel) {
-            logger.warning("".concat(LOG_PRESET, " currentChannel doesn't exist"), currentChannel);
+            logger === null || logger === void 0 ? void 0 : logger.warning("".concat(LOG_PRESET, " currentChannel doesn't exist"), currentChannel);
             return;
         }
         if (isReacted) {
             currentChannel
                 .deleteReaction(message, key)
                 .then(function (res) {
-                logger.info("".concat(LOG_PRESET, " Delete reaction success"), res);
+                logger === null || logger === void 0 ? void 0 : logger.info("".concat(LOG_PRESET, " Delete reaction success"), res);
             })
                 .catch(function (err) {
-                logger.warning("".concat(LOG_PRESET, " Delete reaction failed"), err);
+                logger === null || logger === void 0 ? void 0 : logger.warning("".concat(LOG_PRESET, " Delete reaction failed"), err);
             });
         }
         else {
             currentChannel
                 .addReaction(message, key)
                 .then(function (res) {
-                logger.info("".concat(LOG_PRESET, " Add reaction success"), res);
+                logger === null || logger === void 0 ? void 0 : logger.info("".concat(LOG_PRESET, " Add reaction success"), res);
             })
                 .catch(function (err) {
-                logger.warning("".concat(LOG_PRESET, " Add reaction failed"), err);
+                logger === null || logger === void 0 ? void 0 : logger.warning("".concat(LOG_PRESET, " Add reaction failed"), err);
             });
         }
     }, [currentChannel]);
 }
 
 export { useToggleReactionCallback as u };
-//# sourceMappingURL=bundle-oCSRGy9i.js.map
+//# sourceMappingURL=bundle-DQZG-uS3.js.map

package/chunks/bundle-DQZG-uS3.js.map

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