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

package/chunks/bundle-Xq25cpwP.js.map

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

package/chunks/bundle-Y6TqPszM.js

@@ -1,97 +0,0 @@
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
-
-var extendStatics = function(d, b) {
-    extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-    return extendStatics(d, b);
-};
-
-function __extends(d, b) {
-    if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
-
-function __spreadArray(to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-export { __assign as _, __spreadArray as a, __awaiter as b, __generator as c, __extends as d };
-//# sourceMappingURL=bundle-Y6TqPszM.js.map

package/chunks/bundle-Y6TqPszM.js.map

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

package/chunks/bundle-YQkYq090.js

@@ -1,13 +0,0 @@
-var PREV_RESULT_SIZE = 30;
-var NEXT_RESULT_SIZE = 15;
-var MAX_USER_MENTION_COUNT = 10;
-var MAX_USER_SUGGESTION_COUNT = 15;
-var USER_MENTION_TEMP_CHAR = '@';
-var ThreadReplySelectType;
-(function (ThreadReplySelectType) {
-    ThreadReplySelectType["PARENT"] = "PARENT";
-    ThreadReplySelectType["THREAD"] = "THREAD";
-})(ThreadReplySelectType || (ThreadReplySelectType = {}));
-
-export { MAX_USER_MENTION_COUNT as M, NEXT_RESULT_SIZE as N, PREV_RESULT_SIZE as P, ThreadReplySelectType as T, USER_MENTION_TEMP_CHAR as U, MAX_USER_SUGGESTION_COUNT as a };
-//# sourceMappingURL=bundle-YQkYq090.js.map

package/chunks/bundle-YQkYq090.js.map

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

package/chunks/bundle-YdRy5sj8.js

@@ -1,355 +0,0 @@
-import React__default, { useCallback, useEffect, useContext, useMemo, useReducer } from 'react';
-import { p as pubSubTopics } from './bundle-7x4clnC7.js';
-import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
-import { _ as __assign, a as __spreadArray } from './bundle-Y6TqPszM.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-YdRy5sj8.js.map

package/chunks/bundle-YdRy5sj8.js.map

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

package/chunks/bundle-ZNwxfYJx.js

@@ -1,24 +0,0 @@
-import React__default, { useContext } from 'react';
-import { M as Modal } from './bundle-5JvP07dI.js';
-import './bundle-Y6TqPszM.js';
-import './bundle-0IelBspE.js';
-import { ButtonTypes } from '../ui/Button.js';
-import { L as LocalizationContext } from './bundle-Xly_X4hP.js';
-import { useThreadContext } from '../Thread/context.js';
-import { g as getModalDeleteMessageTitle } from './bundle-JSlDfYOF.js';
-
-var RemoveMessage = function (props) {
-    var _a;
-    var onCancel = props.onCancel, onSubmit = props.onSubmit, message = props.message;
-    var stringSet = useContext(LocalizationContext).stringSet;
-    var deleteMessage = useThreadContext().deleteMessage;
-    return (React__default.createElement(Modal, { type: ButtonTypes.DANGER, disabled: ((_a = message === null || message === void 0 ? void 0 : message.threadInfo) === null || _a === void 0 ? void 0 : _a.replyCount) > 0, onCancel: onCancel, onSubmit: function () {
-            deleteMessage(message).then(function () {
-                onCancel === null || onCancel === void 0 ? void 0 : onCancel();
-                onSubmit === null || onSubmit === void 0 ? void 0 : onSubmit();
-            });
-        }, submitText: stringSet.MESSAGE_MENU__DELETE, titleText: getModalDeleteMessageTitle(stringSet, message) }));
-};
-
-export { RemoveMessage as R };
-//# sourceMappingURL=bundle-ZNwxfYJx.js.map

package/chunks/bundle-ZNwxfYJx.js.map

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