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

package/cjs/chunks/{bundle-B1uXZFKP.js → bundle-DxUpLiXa.js}

@@ -1,20 +1,20 @@
 'use strict';
 
 var React = require('react');
-var _tslib = require('./bundle-C-r9vRgc.js');
+var _tslib = require('./bundle-BGmEoqIq.js');
 var message = require('@sendbird/chat/message');
 var useSendbirdStateContext = require('../useSendbirdStateContext.js');
 var ui_Icon = require('../ui/Icon.js');
 var ui_ImageRenderer = require('../ui/ImageRenderer.js');
-var index = require('./bundle-Cw7xe6J1.js');
-var ui_FileViewer = require('./bundle-IZLtKe6R.js');
+var index = require('./bundle-CRjV-DLM.js');
+var ui_FileViewer = require('./bundle-CvkPNwGA.js');
 
 function ImageGrid(_a) {
     var _b;
     var children = _a.children, className = _a.className, message = _a.message, isReactionEnabled = _a.isReactionEnabled;
     return (React.createElement("div", { className: 'sendbird-image-grid-wrap' },
         React.createElement("div", { className: index.getClassName([
-                className,
+                className !== null && className !== void 0 ? className : '',
                 'sendbird-image-grid',
                 (isReactionEnabled && ((_b = message === null || message === void 0 ? void 0 : message.reactions) === null || _b === void 0 ? void 0 : _b.length) > 0) ? 'reactions' : '',
             ]) }, children)));
@@ -70,16 +70,15 @@ function MultipleFilesMessageItemBody(_a) {
     function onClickRight() {
         setCurrentFileViewerIndex(currentFileViewerIndex === statefulFileInfoList.length - 1 ? 0 : currentFileViewerIndex + 1);
     }
-    return (threadMessageKindKey && (React.createElement(React.Fragment, null,
+    return (threadMessageKindKey ? (React.createElement(React.Fragment, null,
         currentFileViewerIndex > -1 && (React.createElement(ui_FileViewer.FileViewer, { message: message$1, statefulFileInfoList: statefulFileInfoList, currentIndex: currentFileViewerIndex, onClickLeft: onClickLeft, onClickRight: onClickRight, onClose: onClose, onDownloadClick: function (e) { return _tslib.__awaiter(_this, void 0, void 0, function () {
                 var allowDownload, err_1;
                 var _a, _b;
                 return _tslib.__generator(this, function (_c) {
                     switch (_c.label) {
                         case 0:
-                            if (!onBeforeDownloadFileMessage) {
-                                return [2 /*return*/, null];
-                            }
+                            if (!onBeforeDownloadFileMessage)
+                                return [2 /*return*/];
                             _c.label = 1;
                         case 1:
                             _c.trys.push([1, 3, , 4]);
@@ -100,15 +99,15 @@ function MultipleFilesMessageItemBody(_a) {
                 });
             }); } })),
         React.createElement(ImageGrid, { className: className, message: message$1, isReactionEnabled: isReactionEnabled }, statefulFileInfoList.map(function (fileInfo, index$1) {
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             return (React.createElement("div", { className: "sendbird-multiple-files-image-renderer-wrapper", onClick: message$1.sendingStatus === message.SendingStatus.SUCCEEDED ? function () { return setCurrentFileViewerIndex(index$1); } : undefined, key: "sendbird-multiple-files-image-renderer-".concat(index$1, "-").concat(fileInfo.url) },
-                React.createElement(ui_ImageRenderer.default, { url: (_c = (_b = (_a = fileInfo.thumbnails) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.url) !== null && _c !== void 0 ? _c : fileInfo.url, fixedSize: false, width: MULTIPLE_FILES_IMAGE_SIDE_LENGTH[threadMessageKindKey], maxSideLength: MULTIPLE_FILES_IMAGE_SIDE_LENGTH.CHAT_WEB, height: MULTIPLE_FILES_IMAGE_SIDE_LENGTH[threadMessageKindKey], borderRadius: ui_ImageRenderer.getBorderRadiusForMultipleImageRenderer(MULTIPLE_FILES_IMAGE_BORDER_RADIUS[threadMessageKindKey], index$1, statefulFileInfoList.length), shadeOnHover: true, isUploaded: !!fileInfo.isUploaded, placeHolder: function (_a) {
+                React.createElement(ui_ImageRenderer.default, { url: (_d = (_c = (_b = (_a = fileInfo.thumbnails) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.url) !== null && _c !== void 0 ? _c : fileInfo.url) !== null && _d !== void 0 ? _d : '', fixedSize: false, width: MULTIPLE_FILES_IMAGE_SIDE_LENGTH[threadMessageKindKey], maxSideLength: MULTIPLE_FILES_IMAGE_SIDE_LENGTH.CHAT_WEB, height: MULTIPLE_FILES_IMAGE_SIDE_LENGTH[threadMessageKindKey], borderRadius: ui_ImageRenderer.getBorderRadiusForMultipleImageRenderer(MULTIPLE_FILES_IMAGE_BORDER_RADIUS[threadMessageKindKey], index$1, statefulFileInfoList.length), shadeOnHover: true, isUploaded: !!fileInfo.isUploaded, placeHolder: function (_a) {
                         var style = _a.style;
-                        if (index.isGif(fileInfo.mimeType))
+                        if (fileInfo.mimeType && index.isGif(fileInfo.mimeType))
                             return React.createElement(ImagePlaceholder.GIF, { style: style });
                         return React.createElement(ImagePlaceholder.Default, { style: style });
                     }, defaultComponent: React.createElement(ImagePlaceholder.LoadError, null) })));
-        })))));
+        })))) : React.createElement(React.Fragment, null));
 }
 var ImagePlaceholder = {
     Default: function (_a) {
@@ -146,6 +145,7 @@ function useThreadMessageKindKeySelector(_a) {
 // SendingStatus.SCHEDULED is currently not covered in UIKit
 //  So we can ignore for now, but for future, it is better to explicitly use PENDING, FAILED, or CANCELED.
 var useFileInfoListWithUploaded = function (message$1) {
+    var _a, _b;
     var blobHandler = React.useRef(new Map());
     var getObjectURL = function (index, blob) {
         if (!blobHandler.current.has(index) && blob)
@@ -166,13 +166,16 @@ var useFileInfoListWithUploaded = function (message$1) {
     }
     else if (message$1.sendingStatus === message.SendingStatus.SUCCEEDED) {
         revokeURLs();
-        return message$1.fileInfoList.map(function (it) { return (_tslib.__assign(_tslib.__assign({}, it), { url: it.url, isUploaded: true })); });
+        return message$1.fileInfoList.map(function (it) {
+            var _a, _b;
+            return (_tslib.__assign(_tslib.__assign({}, it), { url: it.url, isUploaded: true, mimeType: (_a = it.mimeType) !== null && _a !== void 0 ? _a : undefined, fileName: (_b = it.fileName) !== null && _b !== void 0 ? _b : undefined }));
+        });
     }
     else {
-        return message$1.messageParams.fileInfoList.map(function (it, index) {
+        return (_b = (_a = message$1 === null || message$1 === void 0 ? void 0 : message$1.messageParams) === null || _a === void 0 ? void 0 : _a.fileInfoList.map(function (it, index) {
             var _a, _b;
             return (_tslib.__assign(_tslib.__assign({}, it), { url: (_b = (_a = getObjectURL(index)) !== null && _a !== void 0 ? _a : it.fileUrl) !== null && _b !== void 0 ? _b : (it.file instanceof Blob ? getObjectURL(index, it.file) : undefined), isUploaded: !it.file && typeof it.fileUrl === 'string' && it.fileUrl.length > 0 }));
-        });
+        })) !== null && _b !== void 0 ? _b : [];
     }
 };
 
@@ -180,4 +183,4 @@ exports.MultipleFilesMessageItemBody = MultipleFilesMessageItemBody;
 exports.ThreadMessageKind = ThreadMessageKind;
 exports.useFileInfoListWithUploaded = useFileInfoListWithUploaded;
 exports.useThreadMessageKindKeySelector = useThreadMessageKindKeySelector;
-//# sourceMappingURL=bundle-B1uXZFKP.js.map
+//# sourceMappingURL=bundle-DxUpLiXa.js.map

package/cjs/chunks/{bundle-B1uXZFKP.js.map → bundle-DxUpLiXa.js.map}

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

package/cjs/chunks/{bundle-BAqFIbKr.js → bundle-DzkRFA4-.js}

@@ -1,8 +1,8 @@
 'use strict';
 
 var React = require('react');
-var _tslib = require('./bundle-C-r9vRgc.js');
-var consts = require('./bundle-Ca7xeBTO.js');
+var _tslib = require('./bundle-BGmEoqIq.js');
+var consts = require('./bundle-B9KKI197.js');
 var useSendbirdStateContext = require('../useSendbirdStateContext.js');
 
 var INITIALIZE_AUDIO_UNIT = 'INITIALIZE_AUDIO_UNIT';
@@ -111,24 +111,29 @@ var VoicePlayerProvider = function (_a) {
         }
     };
     var pause = function (groupKey) {
-        if (currentGroupKey === groupKey && currentPlayer !== null) {
-            logger.info('VoicePlayer: Pause playing(by group key).');
-            currentPlayer === null || currentPlayer === void 0 ? void 0 : currentPlayer.pause();
+        if (currentPlayer) {
+            if (groupKey === currentGroupKey) {
+                logger.info('VoicePlayer: Pause playing(by group key).');
+                currentPlayer.pause();
+            }
+            else if (groupKey === ALL) {
+                logger.info('VoicePlayer: Pause playing(all).');
+                currentPlayer.pause();
+            }
         }
-        if (groupKey === ALL) {
-            logger.info('VoicePlayer: Pause playing(all).');
-            currentPlayer === null || currentPlayer === void 0 ? void 0 : currentPlayer.pause();
+        else {
+            logger.warning('VoicePlayer: No currentPlayer to pause.');
         }
     };
     var play = function (_a) {
-        var groupKey = _a.groupKey, _b = _a.audioFile, audioFile = _b === void 0 ? null : _b, _c = _a.audioFileUrl, audioFileUrl = _c === void 0 ? '' : _c;
+        var groupKey = _a.groupKey, audioFile = _a.audioFile, _b = _a.audioFileUrl, audioFileUrl = _b === void 0 ? '' : _b;
         if (groupKey !== currentGroupKey) {
             pause(currentGroupKey);
         }
         // Clear the previous AudioPlayer element
         var voicePlayerRoot = document.getElementById(consts.VOICE_PLAYER_ROOT_ID);
         var voicePlayerAudioElement = document.getElementById(consts.VOICE_PLAYER_AUDIO_ID);
-        if (voicePlayerAudioElement) {
+        if (voicePlayerRoot && voicePlayerAudioElement) {
             voicePlayerRoot.removeChild(voicePlayerAudioElement);
         }
         logger.info('VoicePlayer: Start getting audio file.');
@@ -249,4 +254,4 @@ exports.AudioUnitDefaultValue = AudioUnitDefaultValue;
 exports.VOICE_PLAYER_STATUS = VOICE_PLAYER_STATUS;
 exports.VoicePlayerProvider = VoicePlayerProvider;
 exports.useVoicePlayerContext = useVoicePlayerContext;
-//# sourceMappingURL=bundle-BAqFIbKr.js.map
+//# sourceMappingURL=bundle-DzkRFA4-.js.map

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

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

package/cjs/chunks/{bundle-CLte647H.js → bundle-FcnFNV4V.js}

@@ -41,4 +41,4 @@ exports.deleteNullish = deleteNullish;
 exports.isMobileIOS = isMobileIOS;
 exports.noop = noop;
 exports.openURL = openURL;
-//# sourceMappingURL=bundle-CLte647H.js.map
+//# sourceMappingURL=bundle-FcnFNV4V.js.map

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

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

package/cjs/chunks/{bundle-CHXLIlQ1.js → bundle-J_QbGDEm.js}

@@ -1,16 +1,16 @@
 'use strict';
 
-var _tslib = require('./bundle-C-r9vRgc.js');
+var _tslib = require('./bundle-BGmEoqIq.js');
 var React = require('react');
 var groupChannel = require('@sendbird/chat/groupChannel');
-var pubSub_topics = require('./bundle-DpK1fr1j.js');
-var uuid = require('./bundle-Ub33KGva.js');
-var utils = require('./bundle-CLte647H.js');
-var consts = require('./bundle-Ca7xeBTO.js');
-var UserProfileContext = require('./bundle-D7v4i_Ae.js');
+var pubSub_topics = require('./bundle-C9goSwm_.js');
+var uuid = require('./bundle-nJ_H0gk1.js');
+var utils = require('./bundle-FcnFNV4V.js');
+var consts = require('./bundle-B9KKI197.js');
+var UserProfileContext = require('./bundle-Ch54AIEU.js');
 var useSendbirdStateContext = require('../useSendbirdStateContext.js');
-var index = require('./bundle-Cw7xe6J1.js');
-var useReconnectOnIdle = require('./bundle-OCHWYrfg.js');
+var index = require('./bundle-CRjV-DLM.js');
+var useReconnectOnIdle = require('./bundle-CVlZ1O84.js');
 
 var RESET_CHANNEL_LIST = 'RESET_CHANNEL_LIST';
 var CREATE_CHANNEL = 'CREATE_CHANNEL';
@@ -99,7 +99,8 @@ var createEventHandler = function (_a) {
             }
         },
         onMessageUpdated: function (channel, message) {
-            if (channel.isGroupChannel() && channel.lastMessage.isEqual(message)) {
+            var _a;
+            if (channel.isGroupChannel() && ((_a = channel.lastMessage) === null || _a === void 0 ? void 0 : _a.isEqual(message))) {
                 logger.info('ChannelList: onMessageUpdated', channel);
                 channelListDispatcher({
                     type: ON_LAST_MESSAGE_UPDATED,
@@ -145,6 +146,7 @@ var createChannelListQuery = function (_a) {
     };
     if (userFilledChannelListQuery) {
         Object.keys(userFilledChannelListQuery).forEach(function (key) {
+            // @ts-ignore
             params[key] = userFilledChannelListQuery[key];
         });
     }
@@ -242,8 +244,8 @@ var pubSubHandler = function (pubSub, channelListDispatcher) {
     var subscriber = new Map();
     if (!pubSub)
         return subscriber;
-    subscriber.set(pubSub_topics.pubSubTopics.CREATE_CHANNEL, pubSub.subscribe(pubSub_topics.pubSubTopics.CREATE_CHANNEL, function (msg) {
-        var channel = msg.channel;
+    subscriber.set(pubSub_topics.pubSubTopics.CREATE_CHANNEL, pubSub.subscribe(pubSub_topics.pubSubTopics.CREATE_CHANNEL, function (_a) {
+        var channel = _a.channel;
         channelListDispatcher({
             type: CREATE_CHANNEL,
             payload: channel,
@@ -698,27 +700,7 @@ function useHandleReconnectForChannelList(_a) {
     }, [shouldReconnect]);
 }
 
-var ChannelListContext = React.createContext({
-    disableUserProfile: true,
-    allowProfileEdit: true,
-    onBeforeCreateChannel: null,
-    onThemeChange: null,
-    onProfileEditSuccess: null,
-    onChannelSelect: null,
-    queries: {},
-    className: null,
-    initialized: false,
-    loading: false,
-    allChannels: [],
-    currentChannel: null,
-    channelListQuery: {},
-    currentUserId: null,
-    channelListDispatcher: null,
-    channelSource: null,
-    typingChannels: [],
-    fetchChannelList: utils.noop,
-    reconnectOnIdle: true,
-});
+var ChannelListContext = React.createContext(null);
 var ChannelListProvider = function (props) {
     var _a, _b;
     // destruct props
@@ -739,7 +721,7 @@ var ChannelListProvider = function (props) {
     // enable if it is true at least once(both are false by default)
     var userDefinedDisableUserProfile = disableUserProfile !== null && disableUserProfile !== void 0 ? disableUserProfile : !config.common.enableUsingDefaultUserProfile;
     var userDefinedRenderProfile = config === null || config === void 0 ? void 0 : config.renderUserProfile;
-    var enableEditProfile = allowProfileEdit || (config === null || config === void 0 ? void 0 : config.allowProfileEdit);
+    var enableEditProfile = allowProfileEdit || config.allowProfileEdit;
     var userFilledChannelListQuery = queries === null || queries === void 0 ? void 0 : queries.channelListQuery;
     var userFilledApplicationUserListQuery = queries === null || queries === void 0 ? void 0 : queries.applicationUserListQuery;
     var sdkIntialized = sdkStore === null || sdkStore === void 0 ? void 0 : sdkStore.initialized;
@@ -764,7 +746,7 @@ var ChannelListProvider = function (props) {
                 channelListDispatcher: channelListDispatcher,
                 setChannelSource: setChannelSource,
                 onChannelSelect: onChannelSelect,
-                userFilledChannelListQuery: userFilledChannelListQuery,
+                userFilledChannelListQuery: _tslib.__assign({}, userFilledChannelListQuery),
                 logger: logger,
                 sortChannelList: sortChannelList,
                 disableAutoSelect: disableAutoSelect,
@@ -938,6 +920,8 @@ var ChannelListProvider = function (props) {
 };
 function useChannelListContext() {
     var context = React.useContext(ChannelListContext);
+    if (!context)
+        throw new Error('ChannelListContext not found. Use within the ChannelList module.');
     return context;
 }
 
@@ -945,4 +929,4 @@ exports.ChannelListProvider = ChannelListProvider;
 exports.LEAVE_CHANNEL_SUCCESS = LEAVE_CHANNEL_SUCCESS;
 exports.SET_CURRENT_CHANNEL = SET_CURRENT_CHANNEL;
 exports.useChannelListContext = useChannelListContext;
-//# sourceMappingURL=bundle-CHXLIlQ1.js.map
+//# sourceMappingURL=bundle-J_QbGDEm.js.map

package/cjs/chunks/{bundle-CHXLIlQ1.js.map → bundle-J_QbGDEm.js.map}

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

package/cjs/chunks/{bundle-cl2q8NwQ.js → bundle-JqwDNyBE.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var _tslib = require('./bundle-C-r9vRgc.js');
-var pxToNumber = require('./bundle-CxNGVWIy.js');
+var _tslib = require('./bundle-BGmEoqIq.js');
+var pxToNumber = require('./bundle-Ca2fr0Kb.js');
 
 var compressImage = function (_a) {
     var imageFile = _a.imageFile, compressionRate = _a.compressionRate, resizingWidth = _a.resizingWidth, resizingHeight = _a.resizingHeight, outputFormat = _a.outputFormat;
@@ -61,8 +61,8 @@ var compressImages = function (_a) { return _tslib.__awaiter(void 0, [_a], void
         switch (_d.label) {
             case 0:
                 compressionRate = imageCompression.compressionRate, _c = imageCompression.outputFormat, outputFormat = _c === void 0 ? 'preserve' : _c;
-                resizingWidth = pxToNumber.pxToNumber(imageCompression.resizingWidth);
-                resizingHeight = pxToNumber.pxToNumber(imageCompression.resizingHeight);
+                resizingWidth = imageCompression.resizingWidth ? pxToNumber.pxToNumber(imageCompression.resizingWidth) : undefined;
+                resizingHeight = imageCompression.resizingHeight ? pxToNumber.pxToNumber(imageCompression.resizingHeight) : undefined;
                 result = {
                     failedIndexes: [],
                     compressedFiles: [],
@@ -71,7 +71,7 @@ var compressImages = function (_a) { return _tslib.__awaiter(void 0, [_a], void
                     logger === null || logger === void 0 ? void 0 : logger.warning('utils - compressImages: There are no files.', files);
                     return [2 /*return*/, result];
                 }
-                if (compressionRate < 0 || 1 < compressionRate) {
+                if (!compressionRate || compressionRate < 0 || 1 < compressionRate) {
                     logger === null || logger === void 0 ? void 0 : logger.warning('utils - compressImages: The compressionRate is not acceptable.', compressionRate);
                     return [2 /*return*/, result];
                 }
@@ -103,6 +103,7 @@ var compressImages = function (_a) { return _tslib.__awaiter(void 0, [_a], void
                                     return [3 /*break*/, 4];
                                 case 3:
                                     err_1 = _a.sent();
+                                    result.compressedFiles.push(file);
                                     result.failedIndexes.push(index);
                                     logger === null || logger === void 0 ? void 0 : logger.warning('utils - compressImages: Failed to compress image file', { file: file, err: err_1 });
                                     return [3 /*break*/, 4];
@@ -119,4 +120,4 @@ var compressImages = function (_a) { return _tslib.__awaiter(void 0, [_a], void
 }); };
 
 exports.compressImages = compressImages;
-//# sourceMappingURL=bundle-cl2q8NwQ.js.map
+//# sourceMappingURL=bundle-JqwDNyBE.js.map

package/{chunks/bundle-CDMcNani.js.map → cjs/chunks/bundle-JqwDNyBE.js.map}

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

package/cjs/chunks/{bundle-Bpy7IQta.js → bundle-K2UuTY_r.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var _tslib = require('./bundle-C-r9vRgc.js');
+var _tslib = require('./bundle-BGmEoqIq.js');
 var React = require('react');
 var reactDom = require('react-dom');
 
@@ -68,7 +68,7 @@ var MenuItems = /** @class */ (function (_super) {
             return menuStyle;
         };
         _this.state = {
-            menuStyle: {},
+            menuStyle: { top: 0, left: 0 },
             handleClickOutside: function () { },
         };
         return _this;
@@ -81,15 +81,17 @@ var MenuItems = /** @class */ (function (_super) {
         this.cleanUpEvents();
     };
     MenuItems.prototype.render = function () {
-        var _a;
+        var portalElement = document.getElementById('sendbird-dropdown-portal');
+        if (!portalElement)
+            return React.createElement(React.Fragment, null);
         var menuStyle = this.state.menuStyle;
-        var _b = this.props, children = _b.children, style = _b.style, _c = _b.className, className = _c === void 0 ? '' : _c;
-        return (reactDom.createPortal((React.createElement("div", { className: (_a = this.props) === null || _a === void 0 ? void 0 : _a.className },
+        var _a = this.props, children = _a.children, style = _a.style, _b = _a.className, className = _b === void 0 ? '' : _b, testID = _a.testID;
+        return (reactDom.createPortal((React.createElement("div", { className: className, "data-testid": testID },
             React.createElement("div", { className: "sendbird-dropdown__menu-backdrop" }),
-            React.createElement("ul", { className: "".concat(className, " sendbird-dropdown__menu"), ref: this.menuRef, style: _tslib.__assign({ display: 'inline-block', position: 'fixed', left: "".concat(Math.round(menuStyle.left), "px"), top: "".concat(Math.round(menuStyle.top), "px") }, style) }, children))), document.getElementById('sendbird-dropdown-portal')));
+            React.createElement("ul", { className: "".concat(className, " sendbird-dropdown__menu"), ref: this.menuRef, style: _tslib.__assign({ display: 'inline-block', position: 'fixed', left: "".concat(Math.round(menuStyle.left), "px"), top: "".concat(Math.round(menuStyle.top), "px") }, style), "data-testid": "sendbird-dropdown-menu" }, children))), portalElement));
     };
     return MenuItems;
 }(React.Component));
 
 exports.MenuItems = MenuItems;
-//# sourceMappingURL=bundle-Bpy7IQta.js.map
+//# sourceMappingURL=bundle-K2UuTY_r.js.map

package/cjs/chunks/{bundle-DGJX80zy.js.map → bundle-K2UuTY_r.js.map}

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

package/cjs/chunks/{bundle-hVU-fzqu.js → bundle-LO8nBYJf.js}

@@ -6,16 +6,17 @@ var ui_IconButton = require('../ui/IconButton.js');
 var ui_Icon = require('../ui/Icon.js');
 var ui_ContextMenu = require('../ui/ContextMenu.js');
 var ChannelSettings_components_UserListItem = require('../ChannelSettings/components/UserListItem.js');
-var _tslib = require('./bundle-C-r9vRgc.js');
+var _tslib = require('./bundle-BGmEoqIq.js');
 var SendbirdChat = require('@sendbird/chat');
-var ui_Modal = require('./bundle-DJ9gapN2.js');
+var ui_Modal = require('./bundle-CkSDsWpR.js');
 var ui_UserListItem = require('../ui/UserListItem.js');
-var utils = require('./bundle-CLte647H.js');
+var utils = require('./bundle-FcnFNV4V.js');
 var ChannelSettings_context = require('../ChannelSettings/context.js');
 var useSendbirdStateContext = require('../useSendbirdStateContext.js');
-var LocalizationContext = require('./bundle-B7wJ4Hqk.js');
-var index = require('./bundle-hXD0NDZt.js');
-require('./bundle-Deao1Upp.js');
+var LocalizationContext = require('./bundle-u9XWE6Rm.js');
+var index = require('./bundle-DjFJYSI3.js');
+require('./bundle-DgWaY7S0.js');
+var uuid = require('./bundle-nJ_H0gk1.js');
 
 function MembersModal(_a) {
     var _this = this;
@@ -31,19 +32,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.createElement("div", null,
         React.createElement(ui_Modal.Modal, { isFullScreenOnMobile: true, hideFooter: true, onCancel: function () { return onCancel(); }, onSubmit: utils.noop, titleText: stringSet.CHANNEL_SETTING__MEMBERS__SEE_ALL_MEMBERS },
             React.createElement("div", { className: "sendbird-more-members__popup-scroll", onScroll: index.useOnScrollPositionChangeDetector({
                     onReachedBottom: function () { return _tslib.__awaiter(_this, void 0, void 0, function () {
-                        var hasNext;
                         return _tslib.__generator(this, function (_a) {
-                            hasNext = memberQuery.hasNext;
-                            if (hasNext) {
+                            if (memberQuery && memberQuery.hasNext) {
                                 memberQuery.next().then(function (o) {
                                     setMembers(_tslib.__spreadArray(_tslib.__spreadArray([], members, true), o, true));
                                 });
@@ -59,32 +58,36 @@ function MembersModal(_a) {
                                 } },
                                 React.createElement(ui_Icon.default, { width: "24px", height: "24px", type: ui_Icon.IconTypes.MORE, fillColor: ui_Icon.IconColors.CONTENT_INVERSE }))); }, menuItems: function (closeDropdown) { return (React.createElement(ui_ContextMenu.MenuItems, { parentContainRef: parentRef, parentRef: actionRef, closeDropdown: closeDropdown, openLeft: true },
                                 React.createElement(ui_ContextMenu.OperatorMenuItem, { channel: channel, user: member, disable: currentUserId === member.userId, onChange: function (_, member, isOperator) {
-                                        setMembers(members.map(function (m) {
-                                            if (m.userId === member.userId) {
-                                                return _tslib.__assign(_tslib.__assign({}, member), { role: isOperator ? SendbirdChat.Role.OPERATOR : SendbirdChat.Role.NONE });
+                                        var newMembers = _tslib.__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 ? SendbirdChat.Role.OPERATOR : SendbirdChat.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.createElement(ui_ContextMenu.MuteMenuItem, { channel: channel, user: member, onChange: function (_, member, isMuted) {
-                                        setMembers(members.map(function (m) {
-                                            if (m.userId === member.userId) {
-                                                return _tslib.__assign(_tslib.__assign({}, member), { isMuted: isMuted });
+                                        var newMembers = _tslib.__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.createElement(ui_ContextMenu.MenuItem, { onClick: function () {
@@ -94,7 +97,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))); } }))));
                     } }));
             })))));
 }
@@ -136,7 +139,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))];
@@ -162,9 +165,10 @@ function InviteUsers(_a) {
     };
     var membersMap = React.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;
@@ -195,7 +199,7 @@ function InviteUsers(_a) {
         React.createElement(ui_Modal.Modal, { isFullScreenOnMobile: true, disabled: Object.keys(selectedUsers).length === 0, submitText: stringSet.BUTTON__INVITE, type: ui_Button.ButtonTypes.PRIMARY, onCancel: function () { return onCancel(); }, onSubmit: onInviteUsers, titleText: stringSet.CHANNEL_SETTING__MEMBERS__SELECT_TITLE },
             React.createElement("div", { className: "sendbird-more-members__popup-scroll", onScroll: onScroll },
                 React.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.createElement(ui_UserListItem, { key: user.userId, checkBox: true, checked: isMember || isSelected, disabled: isMember, user: user, onChange: function () { return onSelectUser(user); } }));
                 }))))));
@@ -208,7 +212,7 @@ var MemberList = function () {
     var _f = React.useState(false), showAllMembers = _f[0], setShowAllMembers = _f[1];
     var _g = React.useState(false), showInviteUsers = _g[0], setShowInviteUsers = _g[1];
     var state = useSendbirdStateContext.useSendbirdStateContext();
-    var channel = ChannelSettings_context.useChannelSettingsContext().channel;
+    var _h = ChannelSettings_context.useChannelSettingsContext(), channel = _h.channel, setChannelUpdateId = _h.setChannelUpdateId;
     var stringSet = React.useContext(LocalizationContext.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;
@@ -232,35 +236,39 @@ var MemberList = function () {
         memberUserListQuery.next().then(function (members) {
             setMembers(members);
             setHasNext(memberUserListQuery.hasNext);
+            setChannelUpdateId === null || setChannelUpdateId === void 0 ? void 0 : setChannelUpdateId(uuid.uuidv4());
         });
     }, [channel]);
     return (React.createElement("div", { className: "sendbird-channel-settings-member-list" },
-        members.map(function (member) { return (React.createElement(ChannelSettings_components_UserListItem, { 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.createElement(ui_ContextMenu.default, { menuTrigger: function (toggleDropdown) { return (React.createElement(ui_IconButton, { className: "sendbird-user-message__more__menu", width: "32px", height: "32px", onClick: toggleDropdown },
-                            React.createElement(ui_Icon.default, { width: "24px", height: "24px", type: ui_Icon.IconTypes.MORE, fillColor: ui_Icon.IconColors.CONTENT_INVERSE }))); }, menuItems: function (closeDropdown) { return (React.createElement(ui_ContextMenu.MenuItems, { parentContainRef: parentRef, parentRef: actionRef, closeDropdown: closeDropdown, openLeft: true },
-                            React.createElement(ui_ContextMenu.OperatorMenuItem, { channel: channel, user: member, onChange: function () {
-                                    refreshList();
-                                    closeDropdown();
-                                }, onError: utils.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.createElement(ui_ContextMenu.MuteMenuItem, { channel: channel, user: member, onChange: function () {
-                                    refreshList();
-                                    closeDropdown();
-                                }, onError: utils.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.createElement(ui_ContextMenu.MenuItem, { onClick: function () {
-                                    channel === null || channel === void 0 ? void 0 : channel.banUser(member, -1, '').then(function () {
+        members.map(function (member) {
+            var _a;
+            return (React.createElement(ChannelSettings_components_UserListItem, { 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.createElement(ui_ContextMenu.default, { menuTrigger: function (toggleDropdown) { return (React.createElement(ui_IconButton, { className: "sendbird-user-message__more__menu", width: "32px", height: "32px", onClick: toggleDropdown },
+                                React.createElement(ui_Icon.default, { width: "24px", height: "24px", type: ui_Icon.IconTypes.MORE, fillColor: ui_Icon.IconColors.CONTENT_INVERSE }))); }, menuItems: function (closeDropdown) { return (React.createElement(ui_ContextMenu.MenuItems, { parentContainRef: parentRef, parentRef: actionRef, closeDropdown: closeDropdown, openLeft: true },
+                                React.createElement(ui_ContextMenu.OperatorMenuItem, { channel: channel, user: member, onChange: function () {
                                         refreshList();
                                         closeDropdown();
-                                    });
-                                }, dataSbId: "channel_setting_member_context_menu_ban" }, stringSet.CHANNEL_SETTING__MODERATION__BAN))); } }));
-                }
-                : null })); }),
+                                    }, onError: utils.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.createElement(ui_ContextMenu.MuteMenuItem, { channel: channel, user: member, onChange: function () {
+                                        refreshList();
+                                        closeDropdown();
+                                    }, onError: utils.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.createElement(ui_ContextMenu.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.createElement("div", { className: "sendbird-channel-settings-accordion__footer" },
             hasNext && (React.createElement(ui_Button.default, { type: ui_Button.ButtonTypes.SECONDARY, size: ui_Button.ButtonSizes.SMALL, onClick: function () { return setShowAllMembers(true); } }, stringSet.CHANNEL_SETTING__MEMBERS__SEE_ALL_MEMBERS)),
             React.createElement(ui_Button.default, { type: ui_Button.ButtonTypes.SECONDARY, size: ui_Button.ButtonSizes.SMALL, onClick: function () { return setShowInviteUsers(true); } }, stringSet.CHANNEL_SETTING__MEMBERS__INVITE_MEMBER)),
@@ -275,4 +283,4 @@ var MemberList = function () {
 };
 
 exports.MemberList = MemberList;
-//# sourceMappingURL=bundle-hVU-fzqu.js.map
+//# sourceMappingURL=bundle-LO8nBYJf.js.map

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

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