@sendbird/uikit-react 3.11.1 → 3.12.0-rc.0

package/cjs/chunks/bundle-MF7Mgc0Z.js

@@ -1,204 +0,0 @@
-'use strict';
-
-var React = require('react');
-var useSendbirdStateContext = require('../useSendbirdStateContext.js');
-var LocalizationContext = require('./bundle-om7V4Kmd.js');
-var ChannelList_context = require('./bundle-Eq5GnDnz.js');
-var ui_MessageStatus = require('./bundle-4QpLkquA.js');
-var _tslib = require('./bundle-H3iUL9jU.js');
-var groupChannel = require('@sendbird/chat/groupChannel');
-var uikitTools = require('@sendbird/uikit-tools');
-var UserProfileContext = require('./bundle-uubJJzRW.js');
-var useMarkAsDeliveredScheduler = require('./bundle-KloNxGOC.js');
-var utils = require('./bundle-Kwa0c8dM.js');
-var useLongPress = require('./bundle-mk0LQISG.js');
-var MediaQueryContext = require('./bundle-lHnGN-3L.js');
-var index = require('./bundle-eG-yFfLY.js');
-var TypingIndicator = require('./bundle-jI1VVAdg.js');
-var ui_Badge = require('../ui/Badge.js');
-var ui_ChannelAvatar = require('../ui/ChannelAvatar.js');
-var ui_Icon = require('../ui/Icon.js');
-var ui_Label = require('./bundle-WWYVAaVT.js');
-var ui_MentionUserLabel = require('../ui/MentionUserLabel.js');
-var ui_Modal = require('./bundle--t70CDfb.js');
-var ui_TextButton = require('../ui/TextButton.js');
-
-var GroupChannelListContext = React.createContext(null);
-var GroupChannelListProvider = function (props) {
-    var 
-    // Default
-    children = props.children, _a = props.className, className = _a === void 0 ? '' : _a, selectedChannelUrl = props.selectedChannelUrl, 
-    // Flags
-    _b = props.allowProfileEdit, 
-    // Flags
-    allowProfileEdit = _b === void 0 ? true : _b, _c = props.disableAutoSelect, disableAutoSelect = _c === void 0 ? false : _c, _d = props.isTypingIndicatorEnabled, isTypingIndicatorEnabled = _d === void 0 ? false : _d, _e = props.isMessageReceiptStatusEnabled, isMessageReceiptStatusEnabled = _e === void 0 ? false : _e, 
-    // Custom
-    channelListQueryParams = props.channelListQueryParams, onThemeChange = props.onThemeChange, _f = props.onChannelSelect, onChannelSelect = _f === void 0 ? utils.noop : _f, _g = props.onChannelCreated, onChannelCreated = _g === void 0 ? utils.noop : _g, onCreateChannelClick = props.onCreateChannelClick, onBeforeCreateChannel = props.onBeforeCreateChannel, onUserProfileUpdated = props.onUserProfileUpdated, 
-    // UserProfile
-    disableUserProfile = props.disableUserProfile, renderUserProfile = props.renderUserProfile, onUserProfileMessage = props.onUserProfileMessage;
-    var globalStore = useSendbirdStateContext.useSendbirdStateContext();
-    var config = globalStore.config, stores = globalStore.stores;
-    var sdkStore = stores.sdkStore;
-    var _h = config.isTypingIndicatorEnabledOnChannelList, isTypingIndicatorEnabledOnChannelList = _h === void 0 ? false : _h, _j = config.isMessageReceiptStatusEnabledOnChannelList, isMessageReceiptStatusEnabledOnChannelList = _j === void 0 ? false : _j;
-    var sdk = sdkStore.sdk;
-    var isConnected = useMarkAsDeliveredScheduler.useOnlineStatus(sdk, config.logger);
-    var scheduler = useMarkAsDeliveredScheduler.useMarkAsDeliveredScheduler({ isConnected: isConnected }, config);
-    var channelListDataSource = uikitTools.useGroupChannelList(sdk, {
-        collectionCreator: getCollectionCreator(sdk, channelListQueryParams),
-        markAsDelivered: function (channels) { return channels.forEach(scheduler.push); },
-        onChannelsDeleted: function (channelUrls) {
-            channelUrls.forEach(function (url) {
-                if (url === selectedChannelUrl)
-                    onChannelSelect(null);
-            });
-        },
-    });
-    var refreshing = channelListDataSource.refreshing, initialized = channelListDataSource.initialized, groupChannels = channelListDataSource.groupChannels, refresh = channelListDataSource.refresh, loadMore = channelListDataSource.loadMore;
-    // SideEffect: Auto select channel
-    React.useEffect(function () {
-        var _a;
-        if (!disableAutoSelect && stores.sdkStore.initialized && initialized) {
-            if (!selectedChannelUrl)
-                onChannelSelect((_a = groupChannels[0]) !== null && _a !== void 0 ? _a : null);
-        }
-    }, [disableAutoSelect, stores.sdkStore.initialized, initialized, selectedChannelUrl]);
-    var _k = React.useState([]), typingChannelUrls = _k[0], setTypingChannelUrls = _k[1];
-    uikitTools.useGroupChannelHandler(sdk, {
-        onTypingStatusUpdated: function (channel) {
-            var _a;
-            var channelList = typingChannelUrls.filter(function (channelUrl) { return channelUrl !== channel.url; });
-            if (((_a = channel.getTypingUsers()) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-                setTypingChannelUrls(channelList.concat(channel.url));
-            }
-            else {
-                setTypingChannelUrls(channelList);
-            }
-        },
-    });
-    return (React.createElement(GroupChannelListContext.Provider, { value: {
-            // Default
-            className: className,
-            selectedChannelUrl: selectedChannelUrl,
-            // Flags
-            allowProfileEdit: allowProfileEdit !== null && allowProfileEdit !== void 0 ? allowProfileEdit : config === null || config === void 0 ? void 0 : config.allowProfileEdit,
-            disableAutoSelect: disableAutoSelect,
-            isTypingIndicatorEnabled: isTypingIndicatorEnabled !== null && isTypingIndicatorEnabled !== void 0 ? isTypingIndicatorEnabled : isTypingIndicatorEnabledOnChannelList,
-            isMessageReceiptStatusEnabled: isMessageReceiptStatusEnabled !== null && isMessageReceiptStatusEnabled !== void 0 ? isMessageReceiptStatusEnabled : isMessageReceiptStatusEnabledOnChannelList,
-            // Essential
-            onChannelSelect: onChannelSelect,
-            onChannelCreated: onChannelCreated,
-            // Partial props
-            onThemeChange: onThemeChange,
-            onCreateChannelClick: onCreateChannelClick,
-            onBeforeCreateChannel: onBeforeCreateChannel,
-            onUserProfileUpdated: onUserProfileUpdated,
-            // Internal
-            typingChannelUrls: typingChannelUrls,
-            // ReturnType<UseGroupChannelList>
-            refreshing: refreshing,
-            initialized: initialized,
-            groupChannels: groupChannels,
-            refresh: refresh,
-            loadMore: loadMore,
-        } },
-        React.createElement(UserProfileContext.UserProfileProvider, { disableUserProfile: disableUserProfile !== null && disableUserProfile !== void 0 ? disableUserProfile : config === null || config === void 0 ? void 0 : config.disableUserProfile, renderUserProfile: renderUserProfile !== null && renderUserProfile !== void 0 ? renderUserProfile : config === null || config === void 0 ? void 0 : config.renderUserProfile, onUserProfileMessage: onUserProfileMessage !== null && onUserProfileMessage !== void 0 ? onUserProfileMessage : config === null || config === void 0 ? void 0 : config.onUserProfileMessage },
-            React.createElement("div", { className: "sendbird-channel-list ".concat(className) }, children))));
-};
-var useGroupChannelListContext = function () {
-    var context = React.useContext(GroupChannelListContext);
-    if (!context)
-        throw new Error('GroupChannelListContext not found. Use within the GroupChannelList module.');
-    return context;
-};
-function getCollectionCreator(sdk, channelListQueryParams) {
-    return function (defaultParams) {
-        var params = _tslib.__assign(_tslib.__assign({}, defaultParams), channelListQueryParams);
-        return sdk.groupChannel.createGroupChannelCollection(_tslib.__assign(_tslib.__assign({}, params), { filter: new groupChannel.GroupChannelFilter(params) }));
-    };
-}
-
-var GroupChannelListItemView = function (_a) {
-    var channel = _a.channel, tabIndex = _a.tabIndex, isTyping = _a.isTyping, isSelected = _a.isSelected, channelName = _a.channelName, _b = _a.isMessageStatusEnabled, isMessageStatusEnabled = _b === void 0 ? true : _b, _c = _a.onClick, onClick = _c === void 0 ? utils.noop : _c, _d = _a.onLeaveChannel, onLeaveChannel = _d === void 0 ? utils.noop : _d, renderChannelAction = _a.renderChannelAction;
-    var config = useSendbirdStateContext.useSendbirdStateContext().config;
-    var theme = config.theme, isMentionEnabled = config.isMentionEnabled, userId = config.userId;
-    var _e = LocalizationContext.useLocalization(), dateLocale = _e.dateLocale, stringSet = _e.stringSet;
-    var isMobile = MediaQueryContext.useMediaQueryContext().isMobile;
-    var _f = React.useState(false), showMobileLeave = _f[0], setShowMobileLeave = _f[1];
-    var onLongPress = useLongPress.useLongPress({
-        onLongPress: function () {
-            if (isMobile) {
-                setShowMobileLeave(true);
-            }
-        },
-        onClick: onClick,
-    }, {
-        delay: 1000,
-    });
-    return (React.createElement(React.Fragment, null,
-        React.createElement("div", _tslib.__assign({ className: [
-                'sendbird-channel-preview',
-                isSelected ? 'sendbird-channel-preview--active' : '',
-            ].join(' '), role: "link", tabIndex: tabIndex }, (isMobile ? _tslib.__assign({}, onLongPress) : { onClick: onClick })),
-            React.createElement("div", { className: "sendbird-channel-preview__avatar" },
-                React.createElement(ui_ChannelAvatar, { channel: channel, userId: userId, theme: theme })),
-            React.createElement("div", { className: "sendbird-channel-preview__content" },
-                React.createElement("div", { className: "sendbird-channel-preview__content__upper" },
-                    React.createElement("div", { className: "sendbird-channel-preview__content__upper__header" },
-                        (channel.isBroadcast || false) && (React.createElement("div", { className: "sendbird-channel-preview__content__upper__header__broadcast-icon" },
-                            React.createElement(ui_Icon.default, { type: ui_Icon.IconTypes.BROADCAST, fillColor: ui_Icon.IconColors.SECONDARY, height: "16px", width: "16px" }))),
-                        React.createElement(ui_Label.Label, { className: "sendbird-channel-preview__content__upper__header__channel-name", type: ui_Label.LabelTypography.SUBTITLE_2, color: ui_Label.LabelColors.ONBACKGROUND_1 }, channelName),
-                        React.createElement(ui_Label.Label, { className: "sendbird-channel-preview__content__upper__header__total-members", type: ui_Label.LabelTypography.CAPTION_2, color: ui_Label.LabelColors.ONBACKGROUND_2 }, ui_MessageStatus.getTotalMembers(channel)),
-                        (channel.isFrozen) && (React.createElement("div", { title: "Frozen", className: "sendbird-channel-preview__content__upper__header__frozen-icon" },
-                            React.createElement(ui_Icon.default, { type: ui_Icon.IconTypes.FREEZE, fillColor: ui_Icon.IconColors.PRIMARY, height: 12, width: 12 })))),
-                    !channel.isEphemeral && isMessageStatusEnabled && (React.createElement(ui_MessageStatus.MessageStatus, { className: "sendbird-channel-preview__content__upper__last-message-at", channel: channel, message: channel.lastMessage, isDateSeparatorConsidered: false })),
-                    !channel.isEphemeral && !isMessageStatusEnabled && (React.createElement(ui_Label.Label, { className: "sendbird-channel-preview__content__upper__last-message-at", type: ui_Label.LabelTypography.CAPTION_3, color: ui_Label.LabelColors.ONBACKGROUND_2 }, ui_MessageStatus.getLastMessageCreatedAt({
-                        channel: channel,
-                        locale: dateLocale,
-                        stringSet: stringSet,
-                    })))),
-                React.createElement("div", { className: "sendbird-channel-preview__content__lower" },
-                    React.createElement(ui_Label.Label, { className: "sendbird-channel-preview__content__lower__last-message", type: ui_Label.LabelTypography.BODY_2, color: ui_Label.LabelColors.ONBACKGROUND_3 },
-                        isTyping && (React.createElement(TypingIndicator.TypingIndicatorText, { members: channel.getTypingUsers() })),
-                        !isTyping
-                            && !index.isVoiceMessage(channel.lastMessage)
-                            && ui_MessageStatus.getLastMessage(channel, stringSet),
-                        !isTyping
-                            && index.isVoiceMessage(channel.lastMessage)
-                            && stringSet.VOICE_MESSAGE),
-                    /**
-                     * Do not show unread count for focused channel. This is because of the limitation where
-                     * isScrollBottom and hasNext states needs to be added globally but they are from channel context
-                     * so channel list cannot see them with the current architecture.
-                     */
-                    !isSelected && !channel.isEphemeral && (React.createElement("div", { className: "sendbird-channel-preview__content__lower__unread-message-count" },
-                        isMentionEnabled && channel.unreadMentionCount > 0 ? (React.createElement(ui_MentionUserLabel, { className: "sendbird-channel-preview__content__lower__unread-message-count__mention", color: "purple" }, '@')) : null,
-                        ui_MessageStatus.getChannelUnreadMessageCount(channel) ? ( // return number
-                        React.createElement(ui_Badge, { count: ui_MessageStatus.getChannelUnreadMessageCount(channel) })) : null)))),
-            !isMobile && (React.createElement("div", { className: "sendbird-channel-preview__action" }, renderChannelAction({ channel: channel })))),
-        showMobileLeave && isMobile && (React.createElement(ui_Modal.Modal, { className: "sendbird-channel-preview__leave--mobile", titleText: channelName, hideFooter: true, isCloseOnClickOutside: true, onCancel: function () { return setShowMobileLeave(false); } },
-            React.createElement(ui_TextButton, { onClick: function () {
-                    onLeaveChannel();
-                    setShowMobileLeave(false);
-                }, className: "sendbird-channel-preview__leave-label--mobile" },
-                React.createElement(ui_Label.Label, { type: ui_Label.LabelTypography.SUBTITLE_1, color: ui_Label.LabelColors.ONBACKGROUND_1 }, stringSet.CHANNEL_PREVIEW_MOBILE_LEAVE))))));
-};
-
-var ChannelPreview = function (_a) {
-    var _b, _c, _d, _e, _f, _g, _h;
-    var channel = _a.channel, _j = _a.isActive, isActive = _j === void 0 ? false : _j, _k = _a.isTyping, isTyping = _k === void 0 ? false : _k, renderChannelAction = _a.renderChannelAction, onLeaveChannel = _a.onLeaveChannel, onClick = _a.onClick, tabIndex = _a.tabIndex;
-    var sbState = useSendbirdStateContext.useSendbirdStateContext();
-    var _l = ChannelList_context.useChannelListContext(), _m = _l.isTypingIndicatorEnabled, isTypingIndicatorEnabled = _m === void 0 ? false : _m, _o = _l.isMessageReceiptStatusEnabled, isMessageReceiptStatusEnabled = _o === void 0 ? false : _o;
-    var stringSet = LocalizationContext.useLocalization().stringSet;
-    var userId = (_d = (_c = (_b = sbState === null || sbState === void 0 ? void 0 : sbState.stores) === null || _b === void 0 ? void 0 : _b.userStore) === null || _c === void 0 ? void 0 : _c.user) === null || _d === void 0 ? void 0 : _d.userId;
-    var isMessageStatusEnabled = isMessageReceiptStatusEnabled
-        && (((_e = channel === null || channel === void 0 ? void 0 : channel.lastMessage) === null || _e === void 0 ? void 0 : _e.messageType) === 'user' || ((_f = channel === null || channel === void 0 ? void 0 : channel.lastMessage) === null || _f === void 0 ? void 0 : _f.messageType) === 'file')
-        && ((_h = (_g = channel === null || channel === void 0 ? void 0 : channel.lastMessage) === null || _g === void 0 ? void 0 : _g.sender) === null || _h === void 0 ? void 0 : _h.userId) === userId;
-    var channelName = ui_MessageStatus.getChannelTitle(channel, userId, stringSet);
-    return (React.createElement(GroupChannelListItemView, { channel: channel, tabIndex: tabIndex, isTyping: isTypingIndicatorEnabled && isTyping, isSelected: isActive, channelName: channelName, isMessageStatusEnabled: isMessageStatusEnabled, onClick: onClick, onLeaveChannel: onLeaveChannel, renderChannelAction: renderChannelAction }));
-};
-
-exports.ChannelPreview = ChannelPreview;
-exports.GroupChannelListItemView = GroupChannelListItemView;
-exports.GroupChannelListProvider = GroupChannelListProvider;
-exports.useGroupChannelListContext = useGroupChannelListContext;
-//# sourceMappingURL=bundle-MF7Mgc0Z.js.map

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

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

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

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

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

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

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

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

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

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

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

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

package/cjs/chunks/bundle-Rs2C3Gv0.js

@@ -1,123 +0,0 @@
-'use strict';
-
-var React = require('react');
-var ChannelList_components_ChannelPreview = require('./bundle-MF7Mgc0Z.js');
-var ChannelList_components_ChannelPreviewAction = require('./bundle-dSLJZu7j.js');
-var ChannelList_context = require('./bundle-Eq5GnDnz.js');
-var useSendbirdStateContext = require('../useSendbirdStateContext.js');
-var index = require('./bundle-W789Mnl2.js');
-var EditUserProfile = require('../EditUserProfile.js');
-var ui_PlaceHolder = require('../ui/PlaceHolder.js');
-var index$1 = require('./bundle-QU7zbepl.js');
-var ChannelList_components_AddChannel = require('./bundle-Dy4KUUCa.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;
-    var _b = React.useState(false), showProfileEdit = _b[0], setShowProfileEdit = _b[1];
-    var stores = useSendbirdStateContext.useSendbirdStateContext().stores;
-    var renderer = {
-        addChannel: renderAddChannel,
-        channel: renderChannel,
-        placeholder: {
-            loading: function () {
-                if (initialized)
-                    return null;
-                if (renderPlaceHolderLoading)
-                    return renderPlaceHolderLoading();
-                return React.createElement(ui_PlaceHolder.default, { type: ui_PlaceHolder.PlaceHolderTypes.LOADING });
-            },
-            empty: function () {
-                if (!initialized)
-                    return null;
-                if (renderPlaceHolderEmptyList)
-                    return renderPlaceHolderEmptyList();
-                return React.createElement(ui_PlaceHolder.default, { type: ui_PlaceHolder.PlaceHolderTypes.NO_CHANNELS });
-            },
-            error: function () {
-                if (!initialized || !stores.sdkStore.error)
-                    return null;
-                if (renderPlaceHolderError)
-                    return renderPlaceHolderError();
-                return React.createElement(ui_PlaceHolder.default, { type: ui_PlaceHolder.PlaceHolderTypes.WRONG });
-            },
-        },
-    };
-    return (React.createElement(React.Fragment, null,
-        React.createElement("div", { className: "sendbird-channel-list__header" }, (renderHeader === null || renderHeader === void 0 ? void 0 : renderHeader()) || (React.createElement(index.GroupChannelListHeader, { onEdit: function () { return allowProfileEdit && setShowProfileEdit(true); }, allowProfileEdit: allowProfileEdit, renderIconButton: function () { return renderer.addChannel(); } }))),
-        showProfileEdit && (React.createElement(EditUserProfile, { onThemeChange: onChangeTheme, onCancel: function () { return setShowProfileEdit(false); }, onEditProfile: function (user) {
-                setShowProfileEdit(false);
-                onUserProfileUpdated(user);
-            } })),
-        React.createElement(ChannelListComponent, { data: channels, renderItem: renderer.channel, onLoadMore: onLoadMore, placeholderLoading: renderer.placeholder.loading(), placeholderEmpty: renderer.placeholder.empty(), placeholderError: renderer.placeholder.error() })));
-};
-/**
- * To do: Implement windowing
- * Implement windowing if you are dealing with large number of messages/channels
- * https://github.com/bvaughn/react-window -> recommendation
- * We hesitate to bring one more dependency to our library,
- * we are planning to implement it inside the library
- * */
-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 = index$1.useOnScrollPositionChangeDetector({
-        onReachedBottom: function () { return onLoadMore(); },
-    });
-    return (React.createElement("div", { className: 'sendbird-channel-list__body', onScroll: onScroll },
-        placeholderError,
-        React.createElement("div", null, data.map(function (item, index) { return renderItem({ item: item, index: index }); })),
-        placeholderLoading,
-        data.length === 0 && placeholderEmpty));
-};
-
-var ChannelListUI = function (props) {
-    var renderHeader = props.renderHeader, renderChannelPreview = props.renderChannelPreview, renderPlaceHolderError = props.renderPlaceHolderError, renderPlaceHolderLoading = props.renderPlaceHolderLoading, renderPlaceHolderEmptyList = props.renderPlaceHolderEmptyList;
-    var _a = ChannelList_context.useChannelListContext(), onThemeChange = _a.onThemeChange, allowProfileEdit = _a.allowProfileEdit, allChannels = _a.allChannels, currentChannel = _a.currentChannel, channelListDispatcher = _a.channelListDispatcher, typingChannels = _a.typingChannels, initialized = _a.initialized, fetchChannelList = _a.fetchChannelList, onProfileEditSuccess = _a.onProfileEditSuccess;
-    var _b = useSendbirdStateContext.useSendbirdStateContext(), stores = _b.stores, config = _b.config;
-    var logger = config.logger, _c = config.isOnline, isOnline = _c === void 0 ? false : _c;
-    var sdk = stores.sdkStore.sdk;
-    var renderListItem = function (props) {
-        var channel = props.item, index = props.index;
-        var onLeaveChannel = function (channel, cb) {
-            logger.info('ChannelList: Leaving channel', channel);
-            channel
-                .leave()
-                .then(function (res) {
-                logger.info('ChannelList: Leaving channel success', res);
-                if (cb && typeof cb === 'function')
-                    cb(channel, null);
-                channelListDispatcher({
-                    type: ChannelList_context.LEAVE_CHANNEL_SUCCESS,
-                    payload: channel.url,
-                });
-            })
-                .catch(function (err) {
-                logger.error('ChannelList: Leaving channel failed', err);
-                if (cb && typeof cb === 'function')
-                    cb(channel, err);
-            });
-        };
-        var onClickChannel = function () {
-            if (!isOnline && !(sdk === null || sdk === void 0 ? void 0 : sdk.isCacheEnabled)) {
-                logger.warning('ChannelList: Inactivated clicking channel item during offline.');
-                return;
-            }
-            logger.info('ChannelList: Clicked on channel:', channel);
-            channelListDispatcher({
-                type: ChannelList_context.SET_CURRENT_CHANNEL,
-                payload: channel,
-            });
-        };
-        if (renderChannelPreview) {
-            return (React.createElement("div", { key: channel === null || channel === void 0 ? void 0 : channel.url, onClick: onClickChannel }, renderChannelPreview({ channel: channel, onLeaveChannel: onLeaveChannel })));
-        }
-        return (React.createElement(ChannelList_components_ChannelPreview.ChannelPreview, { key: channel === null || channel === void 0 ? void 0 : channel.url, tabIndex: index, onClick: onClickChannel, channel: channel, onLeaveChannel: function () { return onLeaveChannel(channel, null); }, isActive: (channel === null || channel === void 0 ? void 0 : channel.url) === (currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.url), isTyping: typingChannels === null || typingChannels === void 0 ? void 0 : typingChannels.some(function (_a) {
-                var url = _a.url;
-                return url === (channel === null || channel === void 0 ? void 0 : channel.url);
-            }), renderChannelAction: function () { return (React.createElement(ChannelList_components_ChannelPreviewAction.ChannelPreviewAction, { channel: channel, disabled: !isOnline, onLeaveChannel: function () { return onLeaveChannel(channel, null); } })); } }));
-    };
-    return (React.createElement(GroupChannelListUIView, { renderHeader: renderHeader, renderChannel: renderListItem, renderPlaceHolderError: renderPlaceHolderError, renderPlaceHolderLoading: renderPlaceHolderLoading, renderPlaceHolderEmptyList: renderPlaceHolderEmptyList, onChangeTheme: onThemeChange, allowProfileEdit: allowProfileEdit, onUserProfileUpdated: onProfileEditSuccess, channels: allChannels, onLoadMore: fetchChannelList, initialized: initialized, renderAddChannel: function () { return React.createElement(ChannelList_components_AddChannel.AddChannel, null); } }));
-};
-
-exports.ChannelListUI = ChannelListUI;
-exports.GroupChannelListUIView = GroupChannelListUIView;
-//# sourceMappingURL=bundle-Rs2C3Gv0.js.map

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/cjs/chunks/bundle-jP-1bn23.js.map

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

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

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

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

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

package/cjs/chunks/bundle-lHnGN-3L.js.map

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

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

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

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

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

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

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

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

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

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

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

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

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