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

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

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

package/cjs/chunks/bundle-_gWcsZfN.js

@@ -0,0 +1,360 @@
+'use strict';
+
+var React = require('react');
+var pubSub_topics = require('./bundle-P1tJL1VF.js');
+var useSendbirdStateContext = require('../useSendbirdStateContext.js');
+var _tslib = require('./bundle-crXcinmk.js');
+
+exports.OpenChannelListFetchingStatus = void 0;
+(function (OpenChannelListFetchingStatus) {
+    OpenChannelListFetchingStatus["EMPTY"] = "EMPTY";
+    OpenChannelListFetchingStatus["FETCHING"] = "FETCHING";
+    OpenChannelListFetchingStatus["DONE"] = "DONE";
+    OpenChannelListFetchingStatus["ERROR"] = "ERROR";
+})(exports.OpenChannelListFetchingStatus || (exports.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 _tslib.__assign(_tslib.__assign({}, state), { fetchingStatus: exports.OpenChannelListFetchingStatus.FETCHING });
+        }
+        case OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_SUCCESS: {
+            var channelList = action.payload;
+            return _tslib.__assign(_tslib.__assign({}, state), { allChannels: channelList, fetchingStatus: channelList.length > 0
+                    ? exports.OpenChannelListFetchingStatus.DONE
+                    : exports.OpenChannelListFetchingStatus.EMPTY });
+        }
+        case OpenChannelListActionTypes$1.INIT_OPEN_CHANNEL_LIST_FAILURE: {
+            return _tslib.__assign(_tslib.__assign({}, state), { allChannels: [], fetchingStatus: exports.OpenChannelListFetchingStatus.ERROR });
+        }
+        case OpenChannelListActionTypes$1.RESET_OPEN_CHANNEL_LIST: {
+            return _tslib.__assign(_tslib.__assign({}, state), { allChannels: [], fetchingStatus: exports.OpenChannelListFetchingStatus.EMPTY });
+        }
+        case OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_START: {
+            return state;
+        }
+        case OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_SUCCESS: {
+            return _tslib.__assign(_tslib.__assign({}, state), { allChannels: _tslib.__spreadArray(_tslib.__spreadArray([], state.allChannels, true), action.payload, true) });
+        }
+        case OpenChannelListActionTypes$1.FETCH_OPEN_CHANNEL_LIST_FAILURE: {
+            return state;
+        }
+        case OpenChannelListActionTypes$1.CREATE_OPEN_CHANNEL: {
+            return _tslib.__assign(_tslib.__assign({}, state), { currentChannel: action.payload, allChannels: _tslib.__spreadArray([action.payload], state.allChannels, true) });
+        }
+        case OpenChannelListActionTypes$1.SET_CURRENT_OPEN_CHANNEL: {
+            return _tslib.__assign(_tslib.__assign({}, state), { currentChannel: action.payload });
+        }
+        case OpenChannelListActionTypes$1.UPDATE_OPEN_CHANNEL_LIST_QUERY: {
+            return _tslib.__assign(_tslib.__assign({}, state), { channelListQuery: action === null || action === void 0 ? void 0 : action.payload });
+        }
+        case OpenChannelListActionTypes$1.UPDATE_OPEN_CHANNEL: {
+            return _tslib.__assign(_tslib.__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: exports.OpenChannelListFetchingStatus.EMPTY,
+    channelListQuery: null,
+};
+
+function useFetchNextCallback(_a, _b) {
+    var sdkInitialized = _a.sdkInitialized, openChannelListQuery = _a.openChannelListQuery;
+    var logger = _b.logger, openChannelListDispatcher = _b.openChannelListDispatcher;
+    return React.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;
+    React.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 React.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.createContext({
+    onChannelSelected: null,
+    currentChannel: null,
+    allChannels: [],
+    fetchingStatus: exports.OpenChannelListFetchingStatus.EMPTY,
+    customOpenChannelListQuery: {},
+    fetchNextChannels: null,
+    refreshOpenChannelList: null,
+    openChannelListDispatcher: null,
+    logger: null,
+});
+function useOpenChannelListContext() {
+    var context = React.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.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 = React.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 = React.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
+    React.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(pubSub_topics.pubSubTopics.UPDATE_OPEN_CHANNEL, pubSub === null || pubSub === void 0 ? void 0 : pubSub.subscribe(pubSub_topics.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.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.createElement("div", { className: "sendbird-open-channel-list ".concat(className) }, children)));
+};
+var OpenChannelListProvider$1 = {
+    OpenChannelListProvider: OpenChannelListProvider,
+    useOpenChannelListContext: useOpenChannelListContext,
+};
+
+exports.OpenChannelListActionTypes = OpenChannelListActionTypes$1;
+exports.OpenChannelListProvider = OpenChannelListProvider;
+exports.OpenChannelListProvider$1 = OpenChannelListProvider$1;
+exports.useOpenChannelListContext = useOpenChannelListContext;
+//# sourceMappingURL=bundle-_gWcsZfN.js.map

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

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

package/cjs/chunks/bundle-aNw5UWgi.js

@@ -0,0 +1,114 @@
+'use strict';
+
+var _tslib = require('./bundle-crXcinmk.js');
+var pxToNumber = require('./bundle-af-Vhz_F.js');
+
+var compressImage = function (_a) {
+    var imageFile = _a.imageFile, compressionRate = _a.compressionRate, resizingWidth = _a.resizingWidth, resizingHeight = _a.resizingHeight;
+    var image = document.createElement('img');
+    return new Promise(function (resolve, reject) {
+        image.src = URL.createObjectURL(imageFile);
+        image.onerror = reject;
+        image.onload = function () {
+            URL.revokeObjectURL(image.src);
+            var canvas = document.createElement('canvas');
+            var originWidth = image.width;
+            var originHeight = image.height;
+            var widthRatio = originWidth / (resizingWidth || originWidth);
+            var heightRatio = originHeight / (resizingHeight || originHeight);
+            var targetResizingWidth = resizingWidth || originWidth;
+            var targetResizingHeight = resizingHeight || originHeight;
+            // Use the more impactful value, so the original images' ratio won't be broken
+            if (widthRatio > heightRatio) {
+                targetResizingHeight = originHeight / (resizingWidth ? widthRatio : 1);
+            }
+            else if (heightRatio > widthRatio) {
+                targetResizingWidth = originWidth / (resizingHeight ? heightRatio : 1);
+            }
+            canvas.width = targetResizingWidth;
+            canvas.height = targetResizingHeight;
+            var ctx = canvas.getContext('2d');
+            if (!ctx) {
+                reject(new Error('Failed to get canvas 2d context'));
+                return;
+            }
+            ctx.drawImage(image, 0, 0, targetResizingWidth, targetResizingHeight);
+            ctx.canvas.toBlob(function (blob) {
+                if (blob) {
+                    var file = new File([blob], imageFile.name, { type: imageFile.type });
+                    resolve(file);
+                }
+                else {
+                    reject(new Error('Failed to compress image'));
+                }
+            }, imageFile.type, compressionRate);
+        };
+    });
+};
+var compressImages = function (_a) {
+    var files = _a.files, logger = _a.logger, imageCompression = _a.imageCompression;
+    return _tslib.__awaiter(void 0, void 0, void 0, function () {
+        var compressionRate, resizingWidth, resizingHeight, result;
+        return _tslib.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    compressionRate = imageCompression.compressionRate;
+                    resizingWidth = pxToNumber.pxToNumber(imageCompression.resizingWidth);
+                    resizingHeight = pxToNumber.pxToNumber(imageCompression.resizingHeight);
+                    result = {
+                        failedIndexes: [],
+                        compressedFiles: [],
+                    };
+                    if (!(Array.isArray(files) && files.length > 0)) {
+                        logger.warning('utils - compressImages: There are no files.', files);
+                        return [2 /*return*/, result];
+                    }
+                    if (compressionRate < 0 || 1 < compressionRate) {
+                        logger.warning('utils - compressImages: The compressionRate is not acceptable.', compressionRate);
+                        return [2 /*return*/, result];
+                    }
+                    return [4 /*yield*/, Promise.all(files
+                            .map(function (file, index) { return _tslib.__awaiter(void 0, void 0, void 0, function () {
+                            var compressedImage, err_1;
+                            return _tslib.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!(file.type === 'image/jpg' || file.type === 'image/png' || file.type === 'image/jpeg')) {
+                                            logger.warning('utils - compressImages: The fileType is not compressible.', { file: file, index: index });
+                                            result.failedIndexes.push(index);
+                                            result.compressedFiles.push(file);
+                                            return [2 /*return*/];
+                                        }
+                                        _a.label = 1;
+                                    case 1:
+                                        _a.trys.push([1, 3, , 4]);
+                                        return [4 /*yield*/, compressImage({
+                                                imageFile: file,
+                                                compressionRate: compressionRate,
+                                                resizingWidth: resizingWidth,
+                                                resizingHeight: resizingHeight,
+                                            })];
+                                    case 2:
+                                        compressedImage = _a.sent();
+                                        result.compressedFiles.push(compressedImage);
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        err_1 = _a.sent();
+                                        result.failedIndexes.push(index);
+                                        logger.warning('utils - compressImages: Failed to compress image file', { file: file, err: err_1 });
+                                        return [3 /*break*/, 4];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); }))];
+                case 1:
+                    _b.sent();
+                    logger.info('utils - compressImages: Finished compressing images', result);
+                    return [2 /*return*/, result];
+            }
+        });
+    });
+};
+
+exports.compressImages = compressImages;
+//# sourceMappingURL=bundle-aNw5UWgi.js.map

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

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

package/cjs/chunks/bundle-af-Vhz_F.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var pxToNumber = function (px) {
+    if (typeof px === 'number') {
+        return px;
+    }
+    if (typeof px === 'string') {
+        var parsed = Number.parseFloat(px);
+        if (!Number.isNaN(parsed)) {
+            return parsed;
+        }
+    }
+    return NaN;
+};
+
+exports.pxToNumber = pxToNumber;
+//# sourceMappingURL=bundle-af-Vhz_F.js.map

package/cjs/chunks/bundle-af-Vhz_F.js.map

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

package/cjs/chunks/bundle-crXcinmk.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/******************************************************************************
+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 __());
+}
+
+exports.__assign = function() {
+    exports.__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 exports.__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;
+};
+
+exports.__awaiter = __awaiter;
+exports.__extends = __extends;
+exports.__generator = __generator;
+exports.__spreadArray = __spreadArray;
+//# sourceMappingURL=bundle-crXcinmk.js.map

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

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

package/cjs/chunks/bundle-dwV-KMKC.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var USER_ACTIONS = {
+    INIT_USER: 'INIT_USER',
+    RESET_USER: 'RESET_USER',
+    UPDATE_USER_INFO: 'UPDATE_USER_INFO',
+};
+
+exports.USER_ACTIONS = USER_ACTIONS;
+//# sourceMappingURL=bundle-dwV-KMKC.js.map

package/cjs/chunks/bundle-dwV-KMKC.js.map

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

package/cjs/chunks/bundle-dyoIaPov.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var ui_Label = require('./bundle-GBjPe_zz.js');
+
+var getChannelTitle = function (channel, currentUserId, stringSet) {
+    var _a;
+    var LABEL_STRING_SET = stringSet || ui_Label.LabelStringSet;
+    if (!(channel === null || channel === void 0 ? void 0 : channel.name) && !(channel === null || channel === void 0 ? void 0 : channel.members)) {
+        return LABEL_STRING_SET.NO_TITLE;
+    }
+    if ((channel === null || channel === void 0 ? void 0 : channel.name) && channel.name !== 'Group Channel') {
+        return channel.name;
+    }
+    if (((_a = channel === null || channel === void 0 ? void 0 : channel.members) === null || _a === void 0 ? void 0 : _a.length) === 1) {
+        return LABEL_STRING_SET.NO_MEMBERS;
+    }
+    return channel === null || channel === void 0 ? void 0 : channel.members.filter(function (_a) {
+        var userId = _a.userId;
+        return userId !== currentUserId;
+    }).map(function (_a) {
+        var nickname = _a.nickname;
+        return (nickname || LABEL_STRING_SET.NO_NAME);
+    }).join(', ');
+};
+
+exports.getChannelTitle = getChannelTitle;
+//# sourceMappingURL=bundle-dyoIaPov.js.map

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

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