@sendbird/uikit-react 3.9.1-rc-2 → 3.9.1

package/chunks/bundle-DB4PuqmB.js

@@ -0,0 +1,176 @@
+import { _ as __assign } from './bundle-c5jegKUx.js';
+import React__default, { useLayoutEffect, useCallback, useRef, useContext } from 'react';
+import { createPortal } from 'react-dom';
+import { L as LocalizationContext } from './bundle-ZSLOjQvb.js';
+import '../hooks/useModal.js';
+import { b as isMultipleFilesMessage, d as isFileMessage, e as isSupportedFileView, f as isVideo$1, c as isImage$1 } from './bundle-CQMOLj5V.js';
+import { n as noop } from './bundle-XtwZ5oLQ.js';
+import { A as Avatar } from './bundle-HbEA73mt.js';
+import { L as Label, a as LabelTypography, b as LabelColors } from './bundle-u2CeAx57.js';
+import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
+import { h as SLIDER_BUTTON_ICON_SIDE_LENGTH } from './bundle-EQ2jMcm0.js';
+import { a as MODAL_ROOT } from './bundle-vUampZQQ.js';
+
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Complete_list_of_MIME_types
+var SUPPORTED_MIMES = {
+    IMAGE: [
+        'image/jpeg',
+        'image/jpg',
+        'image/png',
+        'image/gif',
+        'image/svg+xml',
+        'image/webp',
+    ],
+    VIDEO: [
+        'video/mpeg',
+        'video/ogg',
+        'video/webm',
+        'video/mp4',
+    ],
+};
+var isImage = function (type) { return SUPPORTED_MIMES.IMAGE.indexOf(type) >= 0; };
+var isVideo = function (type) { return SUPPORTED_MIMES.VIDEO.indexOf(type) >= 0; };
+__assign({}, SUPPORTED_MIMES);
+var ViewerTypes = {
+    SINGLE: 'SINGLE',
+    MULTI: 'MULTI',
+};
+
+function useKeyDown(_a) {
+    var props = _a.props, ref = _a.ref;
+    var onClose = props.onClose;
+    var onClickLeft = noop;
+    var onClickRight = noop;
+    if (props.viewerType === ViewerTypes.MULTI) {
+        onClickLeft = props.onClickLeft;
+        onClickRight = props.onClickRight;
+    }
+    useLayoutEffect(function () {
+        var _a;
+        (_a = ref.current) === null || _a === void 0 ? void 0 : _a.focus();
+    }, [ref.current]);
+    // this usecallback is not super necessary
+    // discuss with others and remove it if it's not needed
+    var onKeyDown = useCallback(function (event) {
+        switch (event.key) {
+            case 'Escape':
+                // @ts-ignore
+                onClose(event);
+                break;
+            case 'ArrowLeft':
+                onClickLeft();
+                break;
+            case 'ArrowRight':
+                onClickRight();
+                break;
+        }
+        event.stopPropagation();
+    }, [onClose, onClickLeft, onClickRight]);
+    return {
+        onKeyDown: onKeyDown,
+    };
+}
+
+function mapFileViewerComponentProps(_a) {
+    var props = _a.props;
+    if (props.viewerType === ViewerTypes.MULTI) {
+        var _b = props, fileInfoList = _b.fileInfoList, currentIndex = _b.currentIndex;
+        return fileInfoList[currentIndex];
+    }
+    var fileInfo = props;
+    return {
+        name: fileInfo.name,
+        type: fileInfo.type,
+        url: fileInfo.url,
+    };
+}
+
+function DeleteButton(props) {
+    if (props.viewerType !== ViewerTypes.MULTI) {
+        var onDelete_1 = props.onDelete, isByMe = props.isByMe, disableDelete_1 = props.disableDelete, className = props.className;
+        return (isByMe)
+            ? (React__default.createElement("div", { className: "sendbird-fileviewer__header__right__actions__delete ".concat(className) },
+                React__default.createElement(Icon, { className: disableDelete_1 ? 'disabled' : '', type: IconTypes.DELETE, fillColor: disableDelete_1 ? IconColors.GRAY : IconColors.ON_BACKGROUND_1, height: "24px", width: "24px", onClick: function (e) { if (!disableDelete_1) {
+                        onDelete_1 === null || onDelete_1 === void 0 ? void 0 : onDelete_1(e);
+                    } } })))
+            : React__default.createElement(React__default.Fragment, null);
+    }
+    return React__default.createElement(React__default.Fragment, null);
+}
+
+// this is a slider component that is used to navigate between images
+function Slider(props) {
+    if (props.viewerType === ViewerTypes.MULTI) {
+        var onClickLeft_1 = props.onClickLeft, onClickRight_1 = props.onClickRight;
+        return (React__default.createElement("div", { className: "sendbird-file-viewer-slider" },
+            React__default.createElement("div", { className: "sendbird-file-viewer-arrow--left" },
+                React__default.createElement(Icon, { type: IconTypes.SLIDE_LEFT, fillColor: IconColors.ON_BACKGROUND_1, height: SLIDER_BUTTON_ICON_SIDE_LENGTH, width: SLIDER_BUTTON_ICON_SIDE_LENGTH, onClick: function (e) {
+                        onClickLeft_1 === null || onClickLeft_1 === void 0 ? void 0 : onClickLeft_1();
+                        e.stopPropagation();
+                    } })),
+            React__default.createElement("div", { className: "sendbird-file-viewer-arrow--right" },
+                React__default.createElement(Icon, { type: IconTypes.SLIDE_LEFT, fillColor: IconColors.ON_BACKGROUND_1, height: SLIDER_BUTTON_ICON_SIDE_LENGTH, width: SLIDER_BUTTON_ICON_SIDE_LENGTH, onClick: function (e) {
+                        e.stopPropagation();
+                        onClickRight_1 === null || onClickRight_1 === void 0 ? void 0 : onClickRight_1();
+                    } }))));
+    }
+    // return empty fragment if viewerType is not ViewerTypes.MULTI
+    return React__default.createElement(React__default.Fragment, null);
+}
+
+var FileViewerComponent = function (props) {
+    var ref = useRef(null);
+    var profileUrl = props.profileUrl, nickname = props.nickname, onClose = props.onClose;
+    var onKeyDown = useKeyDown({ props: props, ref: ref }).onKeyDown;
+    var _a = mapFileViewerComponentProps({ props: props }), name = _a.name, type = _a.type, url = _a.url;
+    var stringSet = useContext(LocalizationContext).stringSet;
+    return (React__default.createElement("div", { className: "sendbird-fileviewer", onKeyDown: onKeyDown, 
+        // to focus
+        tabIndex: 1, ref: ref },
+        React__default.createElement("div", { className: "sendbird-fileviewer__header" },
+            React__default.createElement("div", { className: "sendbird-fileviewer__header__left" },
+                React__default.createElement("div", { className: "sendbird-fileviewer__header__left__avatar" },
+                    React__default.createElement(Avatar, { height: "32px", width: "32px", src: profileUrl })),
+                React__default.createElement(Label, { className: "sendbird-fileviewer__header__left__filename", type: LabelTypography.H_2, color: LabelColors.ONBACKGROUND_1 }, name),
+                React__default.createElement(Label, { className: "sendbird-fileviewer__header__left__sender-name", type: LabelTypography.BODY_1, color: LabelColors.ONBACKGROUND_2 }, nickname)),
+            React__default.createElement("div", { className: "sendbird-fileviewer__header__right" },
+                isSupportedFileView(type) && (React__default.createElement("div", { className: "sendbird-fileviewer__header__right__actions" },
+                    React__default.createElement("a", { className: "sendbird-fileviewer__header__right__actions__download", rel: "noopener noreferrer", href: url, target: "_blank" },
+                        React__default.createElement(Icon, { type: IconTypes.DOWNLOAD, fillColor: IconColors.ON_BACKGROUND_1, height: "24px", width: "24px" })),
+                    React__default.createElement(DeleteButton, __assign({ className: 'sendbird-fileviewer__header__right__actions__delete' }, props)))),
+                React__default.createElement("div", { className: "sendbird-fileviewer__header__right__actions__close" },
+                    React__default.createElement(Icon, { type: IconTypes.CLOSE, fillColor: IconColors.ON_BACKGROUND_1, height: "24px", width: "24px", onClick: function (e) { return onClose === null || onClose === void 0 ? void 0 : onClose(e); } })))),
+        React__default.createElement("div", { className: "sendbird-fileviewer__content" },
+            isVideo$1(type) && (React__default.createElement("video", { controls: true, className: "sendbird-fileviewer__content__video" },
+                React__default.createElement("source", { src: url, type: type }))),
+            isImage$1(type) && (React__default.createElement("img", { src: url, alt: name, className: props.viewerType === ViewerTypes.MULTI
+                    ? 'sendbird-fileviewer__content__img__multi'
+                    : 'sendbird-fileviewer__content__img' })),
+            !isSupportedFileView(type) && (React__default.createElement("div", { className: "sendbird-fileviewer__content__unsupported" },
+                React__default.createElement(Label, { type: LabelTypography.H_1, color: LabelColors.ONBACKGROUND_1 }, (stringSet === null || stringSet === void 0 ? void 0 : stringSet.UI__FILE_VIEWER__UNSUPPORT) || 'Unsupported message'))),
+            React__default.createElement(Slider, __assign({}, props)))));
+};
+function FileViewer(_a) {
+    var _b, _c, _d;
+    var message = _a.message, _e = _a.statefulFileInfoList, statefulFileInfoList = _e === void 0 ? [] : _e, onClose = _a.onClose, _f = _a.isByMe, isByMe = _f === void 0 ? false : _f, onDelete = _a.onDelete, currentIndex = _a.currentIndex, onClickLeft = _a.onClickLeft, onClickRight = _a.onClickRight;
+    if (isMultipleFilesMessage(message)) {
+        var castedMessage = message;
+        return (React__default.createElement(FileViewerComponent, { profileUrl: castedMessage.sender.profileUrl, nickname: castedMessage.sender.nickname, viewerType: ViewerTypes.MULTI, fileInfoList: statefulFileInfoList.filter(function (fileInfo) {
+                return fileInfo.url; // Caution: This assumes that defined url means file upload has completed.
+            }).map(function (fileInfo) {
+                return {
+                    name: fileInfo.fileName || '',
+                    type: fileInfo.mimeType || '',
+                    url: fileInfo.url,
+                };
+            }), currentIndex: currentIndex || 0, onClickLeft: onClickLeft || noop, onClickRight: onClickRight || noop, onClose: onClose }));
+    }
+    else if (isFileMessage(message)) {
+        var castedMessage = message;
+        return createPortal((React__default.createElement(FileViewerComponent, { profileUrl: (_b = castedMessage.sender) === null || _b === void 0 ? void 0 : _b.profileUrl, nickname: (_c = castedMessage.sender) === null || _c === void 0 ? void 0 : _c.nickname, name: castedMessage.name, type: castedMessage.type, url: castedMessage === null || castedMessage === void 0 ? void 0 : castedMessage.url, isByMe: isByMe, disableDelete: (((_d = castedMessage.threadInfo) === null || _d === void 0 ? void 0 : _d.replyCount) || 0) > 0, onClose: onClose, onDelete: onDelete || noop })), document.getElementById(MODAL_ROOT));
+    }
+    return React__default.createElement(React__default.Fragment, null);
+}
+
+export { FileViewer as F, isVideo as a, FileViewerComponent as b, isImage as i };
+//# sourceMappingURL=bundle-DB4PuqmB.js.map

package/chunks/bundle-DB4PuqmB.js.map

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

package/chunks/bundle-DGEj-Zfy.js

@@ -0,0 +1,8 @@
+var USER_ACTIONS = {
+    INIT_USER: 'INIT_USER',
+    RESET_USER: 'RESET_USER',
+    UPDATE_USER_INFO: 'UPDATE_USER_INFO',
+};
+
+export { USER_ACTIONS as U };
+//# sourceMappingURL=bundle-DGEj-Zfy.js.map

package/chunks/bundle-DGEj-Zfy.js.map

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

package/chunks/bundle-EQ2jMcm0.js

@@ -0,0 +1,31 @@
+var ONE_MiB = 1024 * 1024;
+var SCROLL_BUFFER = 10;
+// voice message record
+var VOICE_RECORDER_CLICK_BUFFER_TIME = 250;
+var VOICE_RECORDER_DEFAULT_MIN = 1000; // 1 seconds
+var VOICE_RECORDER_DEFAULT_MAX = 600000; // 10 minutes
+var VOICE_RECORDER_AUDIO_BIT_RATE = 12000;
+var VOICE_RECORDER_AUDIO_SAMPLE_RATE = 11025;
+var BROWSER_SUPPORT_MIME_TYPE_LIST = ['audio/webm', 'audio/mp4', 'audio/mpeg', 'audio/ogg'];
+/**
+ * Append Audio element to the root
+ * because I can't get the Audio element in the useEffect unmount scope
+ */
+var VOICE_PLAYER_ROOT_ID = 'sendbird-voice-player-provider-root';
+var VOICE_PLAYER_AUDIO_ID = 'sendbird-global-audio-player-id';
+// voice message file
+var VOICE_MESSAGE_FILE_NAME = 'Voice_message.mp3';
+var VOICE_MESSAGE_MIME_TYPE = 'audio/mp3;sbu_type=voice';
+// meta array
+var META_ARRAY_VOICE_DURATION_KEY = 'KEY_VOICE_MESSAGE_DURATION';
+var META_ARRAY_MESSAGE_TYPE_KEY = 'KEY_INTERNAL_MESSAGE_TYPE';
+var META_ARRAY_MESSAGE_TYPE_VALUE__VOICE = 'voice/mp3';
+// delivery receipt in feature list
+var DELIVERY_RECEIPT = 'delivery_receipt';
+// file viewer slider
+var SLIDER_BUTTON_ICON_SIDE_LENGTH = '32px';
+// multiple files message file info count limit
+var DEFAULT_MULTIPLE_FILES_MESSAGE_LIMIT = 10;
+
+export { BROWSER_SUPPORT_MIME_TYPE_LIST as B, DELIVERY_RECEIPT as D, META_ARRAY_VOICE_DURATION_KEY as M, ONE_MiB as O, SCROLL_BUFFER as S, VOICE_RECORDER_AUDIO_BIT_RATE as V, VOICE_MESSAGE_FILE_NAME as a, VOICE_MESSAGE_MIME_TYPE as b, VOICE_RECORDER_DEFAULT_MIN as c, VOICE_RECORDER_AUDIO_SAMPLE_RATE as d, VOICE_PLAYER_AUDIO_ID as e, VOICE_RECORDER_CLICK_BUFFER_TIME as f, VOICE_PLAYER_ROOT_ID as g, SLIDER_BUTTON_ICON_SIDE_LENGTH as h, META_ARRAY_MESSAGE_TYPE_KEY as i, META_ARRAY_MESSAGE_TYPE_VALUE__VOICE as j, DEFAULT_MULTIPLE_FILES_MESSAGE_LIMIT as k, VOICE_RECORDER_DEFAULT_MAX as l };
+//# sourceMappingURL=bundle-EQ2jMcm0.js.map

package/chunks/bundle-EQ2jMcm0.js.map

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

package/chunks/bundle-FZryn4bz.js

@@ -0,0 +1,355 @@
+import React__default, { useCallback, useEffect, useContext, useMemo, useReducer } from 'react';
+import { p as pubSubTopics } from './bundle-OwUIW9B_.js';
+import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
+import { _ as __assign, a as __spreadArray } from './bundle-c5jegKUx.js';
+
+var OpenChannelListFetchingStatus;
+(function (OpenChannelListFetchingStatus) {
+    OpenChannelListFetchingStatus["EMPTY"] = "EMPTY";
+    OpenChannelListFetchingStatus["FETCHING"] = "FETCHING";
+    OpenChannelListFetchingStatus["DONE"] = "DONE";
+    OpenChannelListFetchingStatus["ERROR"] = "ERROR";
+})(OpenChannelListFetchingStatus || (OpenChannelListFetchingStatus = {}));
+
+var OpenChannelListActionTypes;
+(function (OpenChannelListActionTypes) {
+    // actions
+    OpenChannelListActionTypes["INIT_OPEN_CHANNEL_LIST_START"] = "INIT_OPEN_CHANNEL_LIST_START";
+    OpenChannelListActionTypes["INIT_OPEN_CHANNEL_LIST_SUCCESS"] = "INIT_OPEN_CHANNEL_LIST_SUCCESS";
+    OpenChannelListActionTypes["INIT_OPEN_CHANNEL_LIST_FAILURE"] = "INIT_OPEN_CHANNEL_LIST_FAILURE";
+    OpenChannelListActionTypes["RESET_OPEN_CHANNEL_LIST"] = "RESET_OPEN_CHANNEL_LIST";
+    OpenChannelListActionTypes["FETCH_OPEN_CHANNEL_LIST_START"] = "FETCH_OPEN_CHANNEL_LIST_START";
+    OpenChannelListActionTypes["FETCH_OPEN_CHANNEL_LIST_SUCCESS"] = "FETCH_OPEN_CHANNEL_LIST_SUCCESS";
+    OpenChannelListActionTypes["FETCH_OPEN_CHANNEL_LIST_FAILURE"] = "FETCH_OPEN_CHANNEL_LIST_FAILURE";
+    OpenChannelListActionTypes["CREATE_OPEN_CHANNEL"] = "CREATE_OPEN_CHANNEL";
+    OpenChannelListActionTypes["SET_CURRENT_OPEN_CHANNEL"] = "SET_CURRENT_OPEN_CHANNEL";
+    OpenChannelListActionTypes["UPDATE_OPEN_CHANNEL_LIST_QUERY"] = "UPDATE_OPEN_CHANNEL_LIST_QUERY";
+    OpenChannelListActionTypes["UPDATE_OPEN_CHANNEL"] = "UPDATE_OPEN_CHANNEL";
+})(OpenChannelListActionTypes || (OpenChannelListActionTypes = {}));
+var OpenChannelListActionTypes$1 = OpenChannelListActionTypes;
+
+function reducer(state, action) {
+    var _a, _b;
+    switch (action.type) {
+        case OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_START: {
+            return __assign(__assign({}, state), { fetchingStatus: OpenChannelListFetchingStatus.FETCHING });
+        }
+        case OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_SUCCESS: {
+            var channelList = action.payload;
+            return __assign(__assign({}, state), { allChannels: channelList, fetchingStatus: channelList.length > 0
+                    ? OpenChannelListFetchingStatus.DONE
+                    : OpenChannelListFetchingStatus.EMPTY });
+        }
+        case OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_FAILURE: {
+            return __assign(__assign({}, state), { allChannels: [], fetchingStatus: OpenChannelListFetchingStatus.ERROR });
+        }
+        case OpenChannelListActionTypes$1.RESET_OPEN_CHANNEL_LIST: {
+            return __assign(__assign({}, state), { allChannels: [], fetchingStatus: OpenChannelListFetchingStatus.EMPTY });
+        }
+        case OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_START: {
+            return state;
+        }
+        case OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_SUCCESS: {
+            return __assign(__assign({}, state), { allChannels: __spreadArray(__spreadArray([], state.allChannels, true), action.payload, true) });
+        }
+        case OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_FAILURE: {
+            return state;
+        }
+        case OpenChannelListActionTypes$1.CREATE_OPEN_CHANNEL: {
+            return __assign(__assign({}, state), { currentChannel: action.payload, allChannels: __spreadArray([action.payload], state.allChannels, true) });
+        }
+        case OpenChannelListActionTypes$1.SET_CURRENT_OPEN_CHANNEL: {
+            return __assign(__assign({}, state), { currentChannel: action.payload });
+        }
+        case OpenChannelListActionTypes$1.UPDATE_OPEN_CHANNEL_LIST_QUERY: {
+            return __assign(__assign({}, state), { channelListQuery: action === null || action === void 0 ? void 0 : action.payload });
+        }
+        case OpenChannelListActionTypes$1.UPDATE_OPEN_CHANNEL: {
+            return __assign(__assign({}, state), { allChannels: state.allChannels.map(function (channel) {
+                    var _a;
+                    return ((channel === null || channel === void 0 ? void 0 : channel.url) === ((_a = action.payload) === null || _a === void 0 ? void 0 : _a.url) ? action.payload : channel);
+                }), currentChannel: (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) === ((_b = action === null || action === void 0 ? void 0 : action.payload) === null || _b === void 0 ? void 0 : _b.url))
+                    ? state.currentChannel
+                    : action.payload });
+        }
+        default: {
+            return state;
+        }
+    }
+}
+
+var openChannelListInitialState = {
+    allChannels: [],
+    currentChannel: null,
+    fetchingStatus: OpenChannelListFetchingStatus.EMPTY,
+    channelListQuery: null,
+};
+
+function useFetchNextCallback(_a, _b) {
+    var sdkInitialized = _a.sdkInitialized, openChannelListQuery = _a.openChannelListQuery;
+    var logger = _b.logger, openChannelListDispatcher = _b.openChannelListDispatcher;
+    return useCallback(function (callback) {
+        if (sdkInitialized && (openChannelListQuery === null || openChannelListQuery === void 0 ? void 0 : openChannelListQuery.hasNext)) {
+            logger.info('OpenChannelList|useFetchNextCallback : Fetch channels');
+            openChannelListDispatcher({
+                type: OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_START,
+                payload: null,
+            });
+            openChannelListQuery.next()
+                .then(function (channelList) {
+                callback(channelList, null);
+                logger.info('OpenChannelList|useFetchNextCallback: Succeeded fetching channels', channelList);
+                openChannelListDispatcher({
+                    type: OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_SUCCESS,
+                    payload: channelList,
+                });
+            })
+                .catch(function (err) {
+                callback(null, err);
+                logger.error('OpenChannelList|useFetchNextCallback: Failed fetching channels', err);
+                openChannelListDispatcher({
+                    type: OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_FAILURE,
+                    payload: null,
+                });
+            });
+        }
+        else {
+            logger.info('OpenChannelList|useFetchNextCallback : There is no more channels');
+        }
+    }, [sdkInitialized, openChannelListQuery]);
+}
+
+function createChannelListQuery(_a) {
+    var _b, _c;
+    var sdk = _a.sdk, logMessage = _a.logMessage, openChannelListQuery = _a.openChannelListQuery, logger = _a.logger, openChannelListDispatcher = _a.openChannelListDispatcher;
+    var params = {};
+    params.limit = 20;
+    params.includeFrozen = true;
+    if (openChannelListQuery) {
+        Object.keys(openChannelListQuery).forEach(function (key) {
+            params[key] = openChannelListQuery[key];
+        });
+    }
+    var channelListQuery = (_c = (_b = sdk === null || sdk === void 0 ? void 0 : sdk.openChannel) === null || _b === void 0 ? void 0 : _b.createOpenChannelListQuery) === null || _c === void 0 ? void 0 : _c.call(_b, params);
+    logger.info(logMessage, channelListQuery);
+    openChannelListDispatcher({
+        type: OpenChannelListActionTypes$1.UPDATE_OPEN_CHANNEL_LIST_QUERY,
+        payload: channelListQuery,
+    });
+    return channelListQuery;
+}
+
+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',
+                    });
+                    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,
+                        });
+                        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,
+                            });
+                        });
+                    }
+                    else {
+                        logger.info('OpenChannelList|useSetupOpenChannelList: There is no more channels');
+                    }
+                }
+                else {
+                    logger.warning('OpenChannelList|useSetupOpenChannelList: createOpenChannelListQuery is not included in the openChannel', sdk.openChannel);
+                }
+            }
+            else {
+                logger.warning('OpenChannelList|useSetupOpenChannelList: openChannel is not included in the Chat SDK', sdk);
+            }
+        }
+        else {
+            logger.info('OpenChannelList|useSetupOpenChannelList: Reset OpenChannelList', { sdkInitialized: sdkInitialized });
+            openChannelListDispatcher({
+                type: OpenChannelListActionTypes$1.RESET_OPEN_CHANNEL_LIST,
+                payload: null,
+            });
+        }
+    }, [sdkInitialized, openChannelListQuery]);
+}
+
+function useRefreshOpenChannelList(_a, _b) {
+    var sdk = _a.sdk, sdkInitialized = _a.sdkInitialized, openChannelListQuery = _a.openChannelListQuery;
+    var logger = _b.logger, openChannelListDispatcher = _b.openChannelListDispatcher;
+    return useCallback(function () {
+        var _a;
+        if (!sdkInitialized) {
+            logger.info('OpenChannelList|useRefreshOpenChannelList: Reset OpenChannelList', { sdkInitialized: sdkInitialized });
+            openChannelListDispatcher({
+                type: OpenChannelListActionTypes$1.RESET_OPEN_CHANNEL_LIST,
+                payload: null,
+            });
+            return;
+        }
+        if (!(sdk === null || sdk === void 0 ? void 0 : sdk.openChannel)) {
+            logger.warning('OpenChannelList|useRefreshOpenChannelList: openChannel is not included in the Chat SDK', sdk);
+            return;
+        }
+        if (!((_a = sdk === null || sdk === void 0 ? void 0 : sdk.openChannel) === null || _a === void 0 ? void 0 : _a.createOpenChannelListQuery)) {
+            logger.warning('OpenChannelList|useRefreshOpenChannelList: createOpenChannelListQuery is not included in the openChannel', sdk.openChannel);
+            return;
+        }
+        logger.info('OpenChannelList|useRefreshOpenChannelList: Setup OpenChannelList', { sdkInitialized: sdkInitialized });
+        var channelListQuery = createChannelListQuery({
+            sdk: sdk,
+            logger: logger,
+            openChannelListQuery: openChannelListQuery,
+            openChannelListDispatcher: openChannelListDispatcher,
+            logMessage: 'OpenChannelList|useRefreshOpenChannelList: Succeeded create channelListQuery',
+        });
+        if (channelListQuery.hasNext) {
+            logger.info('OpenChannelList|useRefreshOpenChannelList: Fetch channels');
+            openChannelListDispatcher({
+                type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_START,
+                payload: null,
+            });
+            channelListQuery.next()
+                .then(function (channelList) {
+                logger.info('OpenChannelList|useRefreshOpenChannelList: Succeeded fetching channels', channelList);
+                openChannelListDispatcher({
+                    type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_SUCCESS,
+                    payload: channelList,
+                });
+            })
+                .catch(function (err) {
+                logger.error('OpenChannelList|useRefreshOpenChannelList: Failed fetching channels', err);
+                openChannelListDispatcher({
+                    type: OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_FAILURE,
+                    payload: null,
+                });
+            });
+        }
+        else {
+            logger.info('OpenChannelList|useRefreshOpenChannelList: There is no more channels');
+        }
+    }, [sdkInitialized, openChannelListQuery]);
+}
+
+var OpenChannelListContext = React__default.createContext({
+    onChannelSelected: null,
+    currentChannel: null,
+    allChannels: [],
+    fetchingStatus: OpenChannelListFetchingStatus.EMPTY,
+    customOpenChannelListQuery: {},
+    fetchNextChannels: null,
+    refreshOpenChannelList: null,
+    openChannelListDispatcher: null,
+    logger: null,
+});
+function useOpenChannelListContext() {
+    var context = useContext(OpenChannelListContext);
+    return context;
+}
+var OpenChannelListProvider = function (_a) {
+    var _b, _c;
+    var className = _a.className, children = _a.children, queries = _a.queries, onChannelSelected = _a.onChannelSelected;
+    // props
+    var _d = useSendbirdStateContext(), stores = _d.stores, config = _d.config;
+    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]);
+    // 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;
+    // Initialize
+    useSetupOpenChannelList({
+        sdk: sdk,
+        sdkInitialized: sdkInitialized,
+        openChannelListQuery: customOpenChannelListQuery,
+    }, {
+        logger: logger,
+        openChannelListDispatcher: openChannelListDispatcher,
+    });
+    // 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) {
+            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) {
+                    //
+                }
+            });
+        };
+    }, [sdkInitialized, pubSub]);
+    // Fetch next channels by scroll event
+    var fetchNextChannels = useFetchNextCallback({
+        sdkInitialized: sdkInitialized,
+        openChannelListQuery: channelListQuery,
+    }, {
+        logger: logger,
+        openChannelListDispatcher: openChannelListDispatcher,
+    });
+    // Refresh channel list by click event of 'refresh button'
+    var refreshOpenChannelList = useRefreshOpenChannelList({
+        sdk: sdk,
+        sdkInitialized: sdkInitialized,
+        openChannelListQuery: customOpenChannelListQuery,
+    }, {
+        logger: logger,
+        openChannelListDispatcher: openChannelListDispatcher,
+    });
+    return (React__default.createElement(OpenChannelListContext.Provider, { value: {
+            // props
+            onChannelSelected: onChannelSelected,
+            customOpenChannelListQuery: customOpenChannelListQuery,
+            // interface
+            logger: logger,
+            currentChannel: currentChannel,
+            allChannels: allChannels,
+            fetchingStatus: fetchingStatus,
+            fetchNextChannels: fetchNextChannels,
+            refreshOpenChannelList: refreshOpenChannelList,
+            openChannelListDispatcher: openChannelListDispatcher,
+        } },
+        React__default.createElement("div", { className: "sendbird-open-channel-list ".concat(className) }, children)));
+};
+var OpenChannelListProvider$1 = {
+    OpenChannelListProvider: OpenChannelListProvider,
+    useOpenChannelListContext: useOpenChannelListContext,
+};
+
+export { OpenChannelListProvider as O, OpenChannelListFetchingStatus as a, OpenChannelListActionTypes$1 as b, OpenChannelListProvider$1 as c, useOpenChannelListContext as u };
+//# sourceMappingURL=bundle-FZryn4bz.js.map

package/chunks/bundle-FZryn4bz.js.map

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