@sendbird/uikit-react 3.14.5 → 3.14.7-rc-1

package/chunks/{bundle-BA5xmpyI.js → bundle-C4S7QhVI.js}

@@ -1,7 +1,7 @@
-import React__default, { useCallback, useEffect, useContext, useMemo, useReducer } from 'react';
-import { p as pubSubTopics } from './bundle-CtgXJZJt.js';
+import React__default, { useCallback, useEffect, useContext, useReducer } from 'react';
+import { p as pubSubTopics } from './bundle-Dub0HHFi.js';
 import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
-import { _ as __assign, c as __spreadArray } from './bundle-CDy_GVNR.js';
+import { _ as __assign, c as __spreadArray } from './bundle-zAvvLMA9.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-BA5xmpyI.js.map
+//# sourceMappingURL=bundle-C4S7QhVI.js.map

package/chunks/{bundle-BA5xmpyI.js.map → bundle-C4S7QhVI.js.map}

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

package/chunks/{bundle-iA2l_iD3.js → bundle-CEP8HgMT.js}

@@ -9,7 +9,7 @@ var CHANNEL_TYPE;
     CHANNEL_TYPE["BROADCAST"] = "broadcast";
 })(CHANNEL_TYPE || (CHANNEL_TYPE = {}));
 
-var CreateChannelContext = React__default.createContext(undefined);
+var CreateChannelContext = React__default.createContext(null);
 var CreateChannelProvider = function (props) {
     var _a;
     var children = props.children, onCreateChannelClick = props.onCreateChannelClick, onBeforeCreateChannel = props.onBeforeCreateChannel, onChannelCreated = props.onChannelCreated, userListQuery = props.userListQuery, onCreateChannel = props.onCreateChannel, overrideInviteUser = props.overrideInviteUser;
@@ -18,6 +18,7 @@ var CreateChannelProvider = function (props) {
     var _b = useState(0), step = _b[0], setStep = _b[1];
     var _c = useState(CHANNEL_TYPE.GROUP), type = _c[0], setType = _c[1];
     return (React__default.createElement(CreateChannelContext.Provider, { value: {
+            sdk: store.stores.sdkStore.sdk,
             createChannel: getCreateGroupChannel(store),
             onCreateChannelClick: onCreateChannelClick,
             onBeforeCreateChannel: onBeforeCreateChannel,
@@ -31,7 +32,12 @@ var CreateChannelProvider = function (props) {
             overrideInviteUser: overrideInviteUser,
         } }, children));
 };
-var useCreateChannelContext = function () { return (React__default.useContext(CreateChannelContext)); };
+var useCreateChannelContext = function () {
+    var context = React__default.useContext(CreateChannelContext);
+    if (!context)
+        throw new Error('CreateChannelContext not found. Use within the CreateChannel module.');
+    return context;
+};
 
 export { CreateChannelProvider as C, CHANNEL_TYPE as a, useCreateChannelContext as u };
-//# sourceMappingURL=bundle-iA2l_iD3.js.map
+//# sourceMappingURL=bundle-CEP8HgMT.js.map

package/chunks/bundle-CEP8HgMT.js.map

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

package/chunks/{bundle-BXXtOrta.js → bundle-CGLOlBwH.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-CDy_GVNR.js';
+import { c as __spreadArray, a as __awaiter, b as __generator, e as __rest } from './bundle-zAvvLMA9.js';
 import { Role } from '@sendbird/chat';
-import { M as Modal } from './bundle-DiVyB2HD.js';
+import { M as Modal } from './bundle-DEcnZTr9.js';
 import UserListItem from '../ui/UserListItem.js';
-import { n as noop } from './bundle-DhJuLwLJ.js';
+import { n as noop } from './bundle-Dl6p5CcR.js';
 import { useChannelSettingsContext } from '../ChannelSettings/context.js';
 import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
-import { L as LocalizationContext, u as useLocalization } from './bundle-CAdxJnio.js';
-import { u as useOnScrollPositionChangeDetector } from './bundle-BGTq2aZA.js';
-import './bundle-q3jyuKU7.js';
+import { L as LocalizationContext, u as useLocalization } from './bundle-4r7ZPzcx.js';
+import { u as useOnScrollPositionChangeDetector } from './bundle-BIKxhuE6.js';
+import './bundle-DyVURRtM.js';
+import { u as uuidv4 } from './bundle-sq0c8UmG.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,32 +56,36 @@ 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
                                         closeDropdown();
-                                    }, dataSbId: "channel_setting_member_context_menu_".concat((member.role !== 'operator') ? 'register_as_operator' : 'unregister_operator') }, member.role !== 'operator'
+                                    }, testID: "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 (_, 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
                                         closeDropdown();
-                                    }, dataSbId: "channel_setting_member_context_menu_".concat((member.isMuted) ? 'unmute' : 'mute') }, member.isMuted
+                                    }, testID: "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 () {
@@ -92,7 +95,7 @@ function MembersModal(_a) {
                                                 return userId !== member.userId;
                                             }));
                                         });
-                                    }, dataSbId: "channel_setting_member_context_menu_ban" }, stringSet.CHANNEL_SETTING__MODERATION__BAN))); } }))));
+                                    }, testID: "channel_setting_member_context_menu_ban" }, stringSet.CHANNEL_SETTING__MODERATION__BAN))); } }))));
                     } }));
             })))));
 }
@@ -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, testID: "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, testID: "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();
+                                        });
+                                    }, testID: "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-BXXtOrta.js.map
+//# sourceMappingURL=bundle-CGLOlBwH.js.map

package/chunks/{bundle-BXXtOrta.js.map → bundle-CGLOlBwH.js.map}

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

package/chunks/{bundle-Y_WIAHds.js → bundle-CIGhx4QE.js}

@@ -3,7 +3,7 @@ import { GroupChannelListHeader } from '../GroupChannelList/components/GroupChan
 import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
 import EditUserProfile from '../EditUserProfile.js';
 import PlaceHolder, { PlaceHolderTypes } from '../ui/PlaceHolder.js';
-import { u as useOnScrollPositionChangeDetector } from './bundle-BGTq2aZA.js';
+import { u as useOnScrollPositionChangeDetector } from './bundle-BIKxhuE6.js';
 
 var GroupChannelListUIView = function (_a) {
     var renderHeader = _a.renderHeader, renderPlaceHolderError = _a.renderPlaceHolderError, renderPlaceHolderLoading = _a.renderPlaceHolderLoading, renderPlaceHolderEmptyList = _a.renderPlaceHolderEmptyList, onChangeTheme = _a.onChangeTheme, onUserProfileUpdated = _a.onUserProfileUpdated, allowProfileEdit = _a.allowProfileEdit, channels = _a.channels, onLoadMore = _a.onLoadMore, initialized = _a.initialized, renderChannel = _a.renderChannel, renderAddChannel = _a.renderAddChannel;
@@ -54,7 +54,7 @@ var GroupChannelListUIView = function (_a) {
 var ChannelListComponent = function (props) {
     var data = props.data, renderItem = props.renderItem, onLoadMore = props.onLoadMore, placeholderLoading = props.placeholderLoading, placeholderError = props.placeholderError, placeholderEmpty = props.placeholderEmpty;
     var onScroll = useOnScrollPositionChangeDetector({
-        onReachedBottom: function () { return onLoadMore(); },
+        onReachedBottom: function () { return onLoadMore === null || onLoadMore === void 0 ? void 0 : onLoadMore(); },
     });
     return (React__default.createElement("div", { className: 'sendbird-channel-list__body', onScroll: onScroll },
         placeholderError,
@@ -64,4 +64,4 @@ var ChannelListComponent = function (props) {
 };
 
 export { GroupChannelListUIView as G };
-//# sourceMappingURL=bundle-Y_WIAHds.js.map
+//# sourceMappingURL=bundle-CIGhx4QE.js.map

package/chunks/bundle-CIGhx4QE.js.map

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

package/chunks/{bundle-BEbribQZ.js → bundle-CJRugtlL.js}

@@ -1,8 +1,8 @@
 import { useCallback } from 'react';
-import { p as pubSubTopics, s as shouldPubSubPublishToChannel, a as shouldPubSubPublishToThread } from './bundle-CtgXJZJt.js';
-import { s as scrollIntoLast$1 } from './bundle-CDMcNani.js';
+import { p as pubSubTopics, s as shouldPubSubPublishToChannel, a as shouldPubSubPublishToThread } from './bundle-Dub0HHFi.js';
+import { s as scrollIntoLast$1 } from './bundle-V1KP3Yq2.js';
 import '../utils/message/getOutgoingMessageState.js';
-import { b as SCROLL_BOTTOM_DELAY_FOR_SEND } from './bundle-thdxvFU8.js';
+import { b as SCROLL_BOTTOM_DELAY_FOR_SEND } from './bundle-DaqQkuav.js';
 
 var getNicknamesMapFromMembers = function (members) {
     if (members === void 0) { members = []; }
@@ -58,7 +58,9 @@ var scrollIntoLast = function (intialTry) {
     try {
         var scrollDOM = document.querySelector('.sendbird-thread-ui--scroll');
         // eslint-disable-next-line no-multi-assign
-        scrollDOM.scrollTop = scrollDOM.scrollHeight;
+        if (scrollDOM) {
+            scrollDOM.scrollTop = scrollDOM.scrollHeight;
+        }
     }
     catch (error) {
         setTimeout(function () {
@@ -101,8 +103,7 @@ var useSendMultipleFilesMessage = function (_a, _b) {
             }
             logger.info('Channel: Start sending MFM', { messageParams: messageParams });
             try {
-                currentChannel.sendMultipleFilesMessage(messageParams)
-                    .onFileUploaded(function (requestId, index, uploadableFileInfo, error) {
+                currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.sendMultipleFilesMessage(messageParams).onFileUploaded(function (requestId, index, uploadableFileInfo, error) {
                     logger.info('Channel: onFileUploaded during sending MFM', {
                         requestId: requestId,
                         index: index,
@@ -119,8 +120,7 @@ var useSendMultipleFilesMessage = function (_a, _b) {
                         },
                         publishingModules: publishingModules,
                     });
-                })
-                    .onPending(function (pendingMessage) {
+                }).onPending(function (pendingMessage) {
                     logger.info('Channel: in progress of sending MFM', { pendingMessage: pendingMessage, fileInfoList: messageParams.fileInfoList });
                     pubSub.publish(pubSubTopics.SEND_MESSAGE_START, {
                         message: pendingMessage,
@@ -135,8 +135,7 @@ var useSendMultipleFilesMessage = function (_a, _b) {
                             scrollIntoLast(0);
                         }
                     }, SCROLL_BOTTOM_DELAY_FOR_SEND);
-                })
-                    .onFailed(function (error, failedMessage) {
+                }).onFailed(function (error, failedMessage) {
                     logger.error('Channel: Sending MFM failed.', { error: error, failedMessage: failedMessage });
                     pubSub.publish(pubSubTopics.SEND_MESSAGE_FAILED, {
                         channel: currentChannel,
@@ -144,8 +143,7 @@ var useSendMultipleFilesMessage = function (_a, _b) {
                         publishingModules: publishingModules,
                     });
                     reject(error);
-                })
-                    .onSucceeded(function (succeededMessage) {
+                }).onSucceeded(function (succeededMessage) {
                     logger.info('Channel: Sending voice message success!', { succeededMessage: succeededMessage });
                     pubSub.publish(pubSubTopics.SEND_FILE_MESSAGE, {
                         channel: currentChannel,
@@ -169,4 +167,4 @@ var useSendMultipleFilesMessage = function (_a, _b) {
 };
 
 export { getNicknamesMapFromMembers as a, compareIds as c, getParentMessageFrom as g, isAboutSame as i, scrollIntoLast as s, useSendMultipleFilesMessage as u };
-//# sourceMappingURL=bundle-BEbribQZ.js.map
+//# sourceMappingURL=bundle-CJRugtlL.js.map

package/chunks/{bundle-BUMKThPh.js.map → bundle-CJRugtlL.js.map}

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

package/chunks/{bundle-klvZ-YE5.js → bundle-CKqOIeLq.js}

@@ -31,4 +31,4 @@ var isDisabledBecauseMuted = function (groupChannel) {
 };
 
 export { isDisabledBecauseMuted as a, isContextMenuClosed as b, getMessageTopOffset as c, getComponentKeyFromMessage as g, isDisabledBecauseFrozen as i };
-//# sourceMappingURL=bundle-klvZ-YE5.js.map
+//# sourceMappingURL=bundle-CKqOIeLq.js.map

package/chunks/bundle-CKqOIeLq.js.map

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

package/chunks/{bundle-BH5EGLxi.js → bundle-CMOqM33u.js}

@@ -1,4 +1,4 @@
-import { _ as __assign, c as __spreadArray } from './bundle-CDy_GVNR.js';
+import { _ as __assign, c as __spreadArray } from './bundle-zAvvLMA9.js';
 import { GroupChannelListOrder } from '@sendbird/chat/groupChannel';
 import { OutgoingMessageStates, getOutgoingMessageState } from '../utils/message/getOutgoingMessageState.js';
 
@@ -177,7 +177,7 @@ var isAdminMessage = function (message) { return (message && (message['isAdminMe
 var isUserMessage = function (message) { return (message && (message['isUserMessage'] && typeof message.isUserMessage === 'function'
     ? message.isUserMessage()
     : (message === null || message === void 0 ? void 0 : message.messageType) === 'user')); };
-var isFileMessage = function (message) { return (message && (message['isFileMessage'] && typeof message.isFileMessage === 'function'
+var isFileMessage = function (message) { return (!!message && (message['isFileMessage'] && typeof message.isFileMessage === 'function'
     ? message.isFileMessage()
     : (message === null || message === void 0 ? void 0 : message.messageType) === 'file')); };
 var isMultipleFilesMessage = function (message) { return (message && (message['isMultipleFilesMessage'] && typeof message.isMultipleFilesMessage === 'function'
@@ -213,7 +213,7 @@ var getMessageContentMiddleClassNameByContainerType = function (_a) {
 var isOGMessage = function (message) {
     if (!message || !isUserMessage(message))
         return false;
-    return (message.ogMetaData
+    return (!!message.ogMetaData
         && !!(message.ogMetaData.url || message.ogMetaData.title || message.ogMetaData.description || message.ogMetaData.defaultImage));
 };
 var isTextMessage = function (message) {
@@ -247,7 +247,7 @@ var isAudioMessage = function (message) {
 var isImageFileInfo = function (fileInfo) {
     if (!fileInfo)
         return false;
-    return (isImage(fileInfo.mimeType) || isGif(fileInfo.mimeType));
+    return !!fileInfo.mimeType && (isImage(fileInfo.mimeType) || isGif(fileInfo.mimeType));
 };
 var isAudioMessageMimeType = function (type) { return (/^audio\//.test(type)); };
 var isVoiceMessageMimeType = function (type) { return (/^voice\//.test(type)); };
@@ -325,7 +325,7 @@ var getEmojiTooltipString = function (reaction, userId, memberNicknamesMap, stri
 };
 function getSuggestedReplies(message) {
     var _a;
-    if (Array.isArray((_a = message === null || message === void 0 ? void 0 : message.extendedMessagePayload) === null || _a === void 0 ? void 0 : _a.suggested_replies)) {
+    if ((message === null || message === void 0 ? void 0 : message.extendedMessagePayload) && Array.isArray((_a = message === null || message === void 0 ? void 0 : message.extendedMessagePayload) === null || _a === void 0 ? void 0 : _a.suggested_replies)) {
         return message.extendedMessagePayload.suggested_replies;
     }
     else {
@@ -661,7 +661,7 @@ var getChannelsWithUpsertedChannel = function (_channels, channel, order) {
     else {
         channels.push(channel);
     }
-    return sortChannelList(channels, order);
+    return sortChannelList(channels, order !== null && order !== void 0 ? order : GroupChannelListOrder.LATEST_LAST_MESSAGE);
 };
 var StringObjType;
 (function (StringObjType) {
@@ -736,4 +736,4 @@ var isSendableMessage = function (message) {
 };
 
 export { filterChannelListParams as $, isGif as A, convertWordToStringObj as B, isTemplateMessage as C, isAudio as D, isVoiceMessageMimeType as E, isSentStatus as F, arrayEqual as G, getMimeTypesUIKitAccepts as H, isImageMessage as I, isImageFileInfo as J, K, isAudioMessage as L, isOGMessage as M, isTextMessage as N, isThreadMessage as O, getMessageContentMiddleClassNameByContainerType as P, isAdminMessage as Q, UI_CONTAINER_TYPES as R, StringObjType as S, TypingIndicatorType as T, UIKitMessageTypes as U, getEmojiUrl as V, isReactedBy as W, getEmojiTooltipString as X, getEmojiMapAll as Y, startsWithAtAndEndsWithBraces as Z, removeAtAndBraces as _, isReadMessage as a, getChannelsWithUpsertedChannel as a0, S as a1, filterMessageListParams as a2, isTextuallyNull as a3, isFileMessage as b, isMultipleFilesMessage as c, isEditedMessage as d, isSendableMessage as e, getSenderName as f, getSuggestedReplies as g, isSupportedFileView as h, isVoiceMessage as i, isVideo as j, isImage as k, isUserMessage as l, getUIKitMessageType as m, getUIKitMessageTypes as n, getUIKitFileType as o, isThumbnailMessage as p, isSentMessage as q, isVideoMessage as r, isGifMessage as s, truncateString as t, isFailedMessage as u, isPendingMessage as v, getClassName as w, copyToClipboard as x, getEmojiListAll as y, getUIKitFileTypes as z };
-//# sourceMappingURL=bundle-BH5EGLxi.js.map
+//# sourceMappingURL=bundle-CMOqM33u.js.map