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

package/chunks/bundle-Ku1a64TD.js

@@ -1,230 +0,0 @@
-import React__default, { createContext, useReducer, useContext } from 'react';
-import { _ as __assign } from './bundle-Y6TqPszM.js';
-import { g as VOICE_PLAYER_ROOT_ID, e as VOICE_PLAYER_AUDIO_ID, a as VOICE_MESSAGE_FILE_NAME, b as VOICE_MESSAGE_MIME_TYPE } from './bundle-Sk3SXXP7.js';
-import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
-
-var INITIALIZE_AUDIO_UNIT = 'INITIALIZE_AUDIO_UNIT';
-var SET_CURRENT_PLAYER = 'SET_CURRENT_PLAYER';
-var ON_VOICE_PLAYER_PLAY = 'ON_VOICE_PLAYER_PLAY';
-var ON_VOICE_PLAYER_PAUSE = 'ON_VOICE_PLAYER_PAUSE';
-var ON_CURRENT_TIME_UPDATE = 'ON_CURRENT_TIME_UPDATE';
-
-var VOICE_PLAYER_STATUS = {
-    IDLE: 'IDLE',
-    PREPARING: 'PREPARING',
-    PLAYING: 'PLAYING',
-    PAUSED: 'PAUSED',
-    COMPLETED: 'COMPLETED',
-};
-var AudioUnitDefaultValue = function () { return ({
-    audioFile: null,
-    playbackTime: 0,
-    duration: 1000,
-    playingStatus: VOICE_PLAYER_STATUS.IDLE,
-}); };
-var voicePlayerInitialState = {
-    currentPlayer: null,
-    currentGroupKey: '',
-    audioStorage: {},
-};
-
-function voicePlayerReducer(state, action) {
-    var _a, _b, _c, _d;
-    var _e, _f, _g, _h;
-    switch (action.type) {
-        case INITIALIZE_AUDIO_UNIT: {
-            var groupKey = action.payload.groupKey;
-            var audioUnit = (((_e = state.audioStorage) === null || _e === void 0 ? void 0 : _e[groupKey]) ? state.audioStorage[groupKey] : AudioUnitDefaultValue());
-            audioUnit.playingStatus = VOICE_PLAYER_STATUS.PREPARING;
-            return __assign(__assign({}, state), { audioStorage: __assign(__assign({}, state.audioStorage), (_a = {}, _a[groupKey] = audioUnit, _a)) });
-        }
-        case SET_CURRENT_PLAYER: {
-            var _j = action.payload, audioPlayer = _j.audioPlayer, groupKey = _j.groupKey;
-            return __assign(__assign({}, state), { currentPlayer: audioPlayer, currentGroupKey: groupKey });
-        }
-        case ON_VOICE_PLAYER_PLAY: {
-            var _k = action.payload, groupKey = _k.groupKey, audioFile = _k.audioFile;
-            var audioUnit = (((_f = state.audioStorage) === null || _f === void 0 ? void 0 : _f[groupKey]) ? state.audioStorage[groupKey] : AudioUnitDefaultValue());
-            audioUnit.audioFile = audioFile;
-            audioUnit.playingStatus = VOICE_PLAYER_STATUS.PLAYING;
-            return __assign(__assign({}, state), { audioStorage: __assign(__assign({}, state.audioStorage), (_b = {}, _b[groupKey] = audioUnit, _b)) });
-        }
-        case ON_VOICE_PLAYER_PAUSE: {
-            var groupKey = action.payload.groupKey;
-            var audioUnit = (((_g = state.audioStorage) === null || _g === void 0 ? void 0 : _g[groupKey]) ? state.audioStorage[groupKey] : AudioUnitDefaultValue());
-            audioUnit.playingStatus = VOICE_PLAYER_STATUS.PAUSED;
-            var _l = state.currentPlayer, currentTime = _l.currentTime, duration = _l.duration;
-            if (audioUnit.playbackTime === audioUnit.duration) {
-                audioUnit.playbackTime = 0;
-            }
-            else if (currentTime > 0 && duration > 0) {
-                audioUnit.playbackTime = currentTime;
-                audioUnit.duration = duration;
-            }
-            return __assign(__assign({}, state), { audioStorage: __assign(__assign({}, state.audioStorage), (_c = {}, _c[groupKey] = audioUnit, _c)) });
-        }
-        case ON_CURRENT_TIME_UPDATE: {
-            var groupKey = action.payload.groupKey;
-            var _m = state.currentPlayer, currentTime = _m.currentTime, duration = _m.duration;
-            var audioUnit = (((_h = state.audioStorage) === null || _h === void 0 ? void 0 : _h[groupKey]) ? state.audioStorage[groupKey] : AudioUnitDefaultValue());
-            if (currentTime > 0 && duration > 0) {
-                audioUnit.playbackTime = currentTime;
-                audioUnit.duration = duration;
-            }
-            return __assign(__assign({}, state), { audioStorage: __assign(__assign({}, state.audioStorage), (_d = {}, _d[groupKey] = audioUnit, _d)) });
-        }
-        default:
-            return state;
-    }
-}
-
-var ALL = 'ALL';
-var noop = function () { };
-var VoicePlayerStoreDefaultValue = {
-    currentGroupKey: '',
-    currentPlayer: null,
-    audioStorage: {},
-};
-var Context = createContext({
-    play: noop,
-    pause: noop,
-    stop: noop,
-    voicePlayerStore: VoicePlayerStoreDefaultValue,
-});
-var VoicePlayerProvider = function (_a) {
-    var children = _a.children;
-    var _b = useReducer(voicePlayerReducer, voicePlayerInitialState), voicePlayerStore = _b[0], voicePlayerDispatcher = _b[1];
-    var currentGroupKey = voicePlayerStore.currentGroupKey, currentPlayer = voicePlayerStore.currentPlayer, audioStorage = voicePlayerStore.audioStorage;
-    var config = useSendbirdStateContext().config;
-    var logger = config.logger;
-    var stop = function (text) {
-        if (text === void 0) { text = ''; }
-        if (currentGroupKey.includes(text)) {
-            logger.info('VoicePlayer: Pause playing(by text).');
-            pause(currentGroupKey);
-        }
-    };
-    var pause = function (groupKey) {
-        if (currentGroupKey === groupKey && currentPlayer !== null) {
-            logger.info('VoicePlayer: Pause playing(by group key).');
-            currentPlayer === null || currentPlayer === void 0 ? void 0 : currentPlayer.pause();
-        }
-        if (groupKey === ALL) {
-            logger.info('VoicePlayer: Pause playing(all).');
-            currentPlayer === null || currentPlayer === void 0 ? void 0 : currentPlayer.pause();
-        }
-    };
-    var play = function (_a) {
-        var groupKey = _a.groupKey, _b = _a.audioFile, audioFile = _b === void 0 ? null : _b, _c = _a.audioFileUrl, audioFileUrl = _c === void 0 ? '' : _c;
-        if (groupKey !== currentGroupKey) {
-            pause(currentGroupKey);
-        }
-        // Clear the previous AudioPlayer element
-        var voicePlayerRoot = document.getElementById(VOICE_PLAYER_ROOT_ID);
-        var voicePlayerAudioElement = document.getElementById(VOICE_PLAYER_AUDIO_ID);
-        if (voicePlayerAudioElement) {
-            voicePlayerRoot.removeChild(voicePlayerAudioElement);
-        }
-        logger.info('VoicePlayer: Start getting audio file.');
-        new Promise(function (resolve) {
-            var _a;
-            voicePlayerDispatcher({
-                type: INITIALIZE_AUDIO_UNIT,
-                payload: { groupKey: groupKey },
-            });
-            // audio file passed as a parameter
-            if (audioFile) {
-                logger.info('VoicePlayer: Use the audioFile instance.');
-                resolve(audioFile);
-                return;
-            }
-            // audio file from the audioStorage
-            var cachedAudioFile = (_a = audioStorage === null || audioStorage === void 0 ? void 0 : audioStorage[groupKey]) === null || _a === void 0 ? void 0 : _a.audioFile;
-            if (cachedAudioFile) {
-                logger.info('VoicePlayer: Get from the audioStorage.');
-                resolve(cachedAudioFile);
-                return;
-            }
-            // fetch the audio file from URL
-            fetch(audioFileUrl)
-                .then(function (res) { return res.blob(); })
-                .then(function (blob) {
-                var audioFile = new File([blob], VOICE_MESSAGE_FILE_NAME, {
-                    lastModified: new Date().getTime(),
-                    type: VOICE_MESSAGE_MIME_TYPE,
-                });
-                resolve(audioFile);
-                logger.info('VoicePlayer: Get the audioFile from URL.');
-            });
-        }).then(function (audioFile) {
-            var _a;
-            var voicePlayerRoot = document.getElementById(VOICE_PLAYER_ROOT_ID);
-            logger.info('VoicePlayer: Succeeded getting audio file.', { audioFile: audioFile });
-            var currentAudioUnit = audioStorage[groupKey] || AudioUnitDefaultValue();
-            var audioPlayer = new Audio((_a = URL === null || URL === void 0 ? void 0 : URL.createObjectURL) === null || _a === void 0 ? void 0 : _a.call(URL, audioFile));
-            audioPlayer.id = VOICE_PLAYER_AUDIO_ID;
-            audioPlayer.currentTime = currentAudioUnit.playbackTime;
-            audioPlayer.volume = 1;
-            audioPlayer.loop = false;
-            audioPlayer.onplaying = function () {
-                logger.info('VoicePlayer: OnPlaying event is called from audioPlayer', { groupKey: groupKey, audioPlayer: audioPlayer });
-                voicePlayerDispatcher({
-                    type: ON_VOICE_PLAYER_PLAY,
-                    payload: { groupKey: groupKey, audioFile: audioFile },
-                });
-            };
-            audioPlayer.onpause = function () {
-                logger.info('VoicePlayer: OnPause event is called from audioPlayer', { groupKey: groupKey, audioPlayer: audioPlayer });
-                voicePlayerDispatcher({
-                    type: ON_VOICE_PLAYER_PAUSE,
-                    payload: { groupKey: groupKey },
-                });
-            };
-            audioPlayer.ontimeupdate = function () {
-                voicePlayerDispatcher({
-                    type: ON_CURRENT_TIME_UPDATE,
-                    payload: { groupKey: groupKey },
-                });
-            };
-            audioPlayer.dataset.sbGroupId = groupKey;
-            // clean up the previous audio player
-            try {
-                voicePlayerRoot === null || voicePlayerRoot === void 0 ? void 0 : voicePlayerRoot.childNodes.forEach(function (node) {
-                    var _a, _b;
-                    var element = node;
-                    var thisGroupKey = (_a = element.dataset) === null || _a === void 0 ? void 0 : _a.sbGroupKey;
-                    if (thisGroupKey !== groupKey) {
-                        (_b = element === null || element === void 0 ? void 0 : element.pause) === null || _b === void 0 ? void 0 : _b.call(element);
-                        voicePlayerDispatcher({
-                            type: ON_VOICE_PLAYER_PAUSE,
-                            payload: { groupKey: groupKey },
-                        });
-                        voicePlayerRoot.removeChild(element);
-                        logger.info('VoicePlayer: Removed other player.', { element: element });
-                    }
-                });
-            }
-            finally {
-                audioPlayer === null || audioPlayer === void 0 ? void 0 : audioPlayer.play();
-                voicePlayerRoot === null || voicePlayerRoot === void 0 ? void 0 : voicePlayerRoot.appendChild(audioPlayer);
-                voicePlayerDispatcher({
-                    type: SET_CURRENT_PLAYER,
-                    payload: { groupKey: groupKey, audioPlayer: audioPlayer },
-                });
-                logger.info('VoicePlayer: Succeeded playing audio player.', { groupKey: groupKey, audioPlayer: audioPlayer });
-            }
-        });
-    };
-    return (React__default.createElement(Context.Provider, { value: {
-            play: play,
-            pause: pause,
-            stop: stop,
-            voicePlayerStore: voicePlayerStore,
-        } },
-        React__default.createElement("div", { id: VOICE_PLAYER_ROOT_ID, style: { display: 'none' } }),
-        children));
-};
-var useVoicePlayerContext = function () { return useContext(Context); };
-
-export { AudioUnitDefaultValue as A, VOICE_PLAYER_STATUS as V, ALL as a, VoicePlayerProvider as b, useVoicePlayerContext as u };
-//# sourceMappingURL=bundle-Ku1a64TD.js.map

package/chunks/bundle-Ku1a64TD.js.map

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

package/chunks/bundle-LTnLzJFb.js

@@ -1,176 +0,0 @@
-import { _ as __assign } from './bundle-Y6TqPszM.js';
-import React__default, { useLayoutEffect, useCallback, useRef, useContext } from 'react';
-import { createPortal } from 'react-dom';
-import { L as LocalizationContext } from './bundle-Xly_X4hP.js';
-import '../hooks/useModal.js';
-import { b as isMultipleFilesMessage, c as isFileMessage, d as isSupportedFileView, e as isVideo$1, f as isImage$1 } from './bundle-ZT6XnGSN.js';
-import { n as noop } from './bundle-JhG5BHdE.js';
-import { A as Avatar } from './bundle-Tep20T57.js';
-import { L as Label, a as LabelTypography, b as LabelColors } from './bundle-0IelBspE.js';
-import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
-import { h as SLIDER_BUTTON_ICON_SIDE_LENGTH } from './bundle-Sk3SXXP7.js';
-import { a as MODAL_ROOT } from './bundle-5JvP07dI.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-LTnLzJFb.js.map

package/chunks/bundle-LTnLzJFb.js.map

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

package/chunks/bundle-LhtrqZSE.js

@@ -1,26 +0,0 @@
-var Colors;
-(function (Colors) {
-    Colors["ONBACKGROUND_1"] = "ONBACKGROUND_1";
-    Colors["ONBACKGROUND_2"] = "ONBACKGROUND_2";
-    Colors["ONBACKGROUND_3"] = "ONBACKGROUND_3";
-    Colors["ONBACKGROUND_4"] = "ONBACKGROUND_4";
-    Colors["ONCONTENT_1"] = "ONCONTENT_1";
-    Colors["ONCONTENT_2"] = "ONCONTENT_2";
-    Colors["PRIMARY"] = "PRIMARY";
-    Colors["ERROR"] = "ERROR";
-})(Colors || (Colors = {}));
-var changeColorToClassName = function (color) {
-    switch (color) {
-        case Colors.ONBACKGROUND_1: return 'sendbird-color--onbackground-1';
-        case Colors.ONBACKGROUND_2: return 'sendbird-color--onbackground-2';
-        case Colors.ONBACKGROUND_3: return 'sendbird-color--onbackground-3';
-        case Colors.ONBACKGROUND_4: return 'sendbird-color--onbackground-4';
-        case Colors.ONCONTENT_1: return 'sendbird-color--oncontent-1';
-        case Colors.PRIMARY: return 'sendbird-color--primary';
-        case Colors.ERROR: return 'sendbird-color--error';
-        default: return null;
-    }
-};
-
-export { Colors as C, changeColorToClassName as c };
-//# sourceMappingURL=bundle-LhtrqZSE.js.map

package/chunks/bundle-LhtrqZSE.js.map

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

package/chunks/bundle-Mn36ivpf.js

@@ -1,76 +0,0 @@
-import React__default, { useState, useEffect } from 'react';
-
-var DEFAULT_MOBILE = false;
-// const DEFAULT_MOBILE = '768px';
-var MOBILE_CLASSNAME = 'sendbird--mobile-mode';
-var MediaQueryContext = React__default.createContext({
-    breakpoint: DEFAULT_MOBILE,
-    isMobile: false,
-});
-var addClassNameToBody = function () {
-    try {
-        var body = document.querySelector('body');
-        body === null || body === void 0 ? void 0 : body.classList.add(MOBILE_CLASSNAME);
-    }
-    catch (_a) {
-        // noop
-    }
-};
-var removeClassNameFromBody = function () {
-    try {
-        var body = document.querySelector('body');
-        body === null || body === void 0 ? void 0 : body.classList.remove(MOBILE_CLASSNAME);
-    }
-    catch (_a) {
-        // noop
-    }
-};
-var MediaQueryProvider = function (props) {
-    var children = props.children, logger = props.logger;
-    var breakpoint = (props === null || props === void 0 ? void 0 : props.breakpoint) || false;
-    var _a = useState(false), isMobile = _a[0], setIsMobile = _a[1];
-    useEffect(function () {
-        var _a;
-        var updateSize = function () {
-            var _a, _b, _c, _d, _e;
-            if (typeof breakpoint === 'boolean') {
-                setIsMobile(breakpoint);
-                if (breakpoint) {
-                    (_a = logger === null || logger === void 0 ? void 0 : logger.info) === null || _a === void 0 ? void 0 : _a.call(logger, 'MediaQueryProvider: isMobile: true');
-                    addClassNameToBody();
-                }
-                else {
-                    (_b = logger === null || logger === void 0 ? void 0 : logger.info) === null || _b === void 0 ? void 0 : _b.call(logger, 'MediaQueryProvider: isMobile: false');
-                    removeClassNameFromBody();
-                }
-            }
-            else {
-                var mq = window.matchMedia("(max-width: ".concat(breakpoint, ")"));
-                (_c = logger === null || logger === void 0 ? void 0 : logger.info) === null || _c === void 0 ? void 0 : _c.call(logger, "MediaQueryProvider: Screensize updated to ".concat(breakpoint));
-                if (mq.matches) {
-                    setIsMobile(true);
-                    addClassNameToBody();
-                    (_d = logger === null || logger === void 0 ? void 0 : logger.info) === null || _d === void 0 ? void 0 : _d.call(logger, 'MediaQueryProvider: isMobile: true');
-                }
-                else {
-                    setIsMobile(false);
-                    removeClassNameFromBody();
-                    (_e = logger === null || logger === void 0 ? void 0 : logger.info) === null || _e === void 0 ? void 0 : _e.call(logger, 'MediaQueryProvider: isMobile: false');
-                }
-            }
-        };
-        updateSize();
-        window.addEventListener('resize', updateSize);
-        (_a = logger === null || logger === void 0 ? void 0 : logger.info) === null || _a === void 0 ? void 0 : _a.call(logger, 'MediaQueryProvider: addEventListener', { updateSize: updateSize });
-        return function () {
-            var _a;
-            window.removeEventListener('resize', updateSize);
-            (_a = logger === null || logger === void 0 ? void 0 : logger.info) === null || _a === void 0 ? void 0 : _a.call(logger, 'MediaQueryProvider: removeEventListener', { updateSize: updateSize });
-        };
-    }, [breakpoint]);
-    return (React__default.createElement(MediaQueryContext.Provider, { value: { breakpoint: breakpoint, isMobile: isMobile } }, children));
-};
-var useMediaQueryContext = function () { return React__default.useContext(MediaQueryContext); };
-
-export { MediaQueryProvider as M, useMediaQueryContext as u };
-//# sourceMappingURL=bundle-Mn36ivpf.js.map

package/chunks/bundle-Mn36ivpf.js.map

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

package/chunks/bundle-Nv1SlZSC.js

@@ -1,72 +0,0 @@
-import { useRef, useEffect, useCallback } from 'react';
-import { S as SCROLL_BUFFER } from './bundle-Sk3SXXP7.js';
-
-function useDebounce(callback, delay) {
-    var timeoutRef = useRef(null);
-    useEffect(function () {
-        // Cleanup the timeout on unmount
-        return function () {
-            if (timeoutRef.current) {
-                clearTimeout(timeoutRef.current);
-            }
-        };
-    }, []);
-    function debounceFunction() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        if (timeoutRef.current) {
-            clearTimeout(timeoutRef.current);
-        }
-        timeoutRef.current = setTimeout(function () {
-            callback.apply(void 0, args);
-        }, delay);
-    }
-    return debounceFunction;
-}
-
-var DELAY = 500;
-function calcScrollBottom(scrollHeight, scrollTop) {
-    return scrollHeight - scrollTop;
-}
-function useHandleOnScrollCallback(_a) {
-    var hasMore = _a.hasMore, hasNext = _a.hasNext, onScroll = _a.onScroll, scrollRef = _a.scrollRef, setShowScrollDownButton = _a.setShowScrollDownButton;
-    var scrollCb = useCallback(function () {
-        var element = scrollRef === null || scrollRef === void 0 ? void 0 : scrollRef.current;
-        if (element == null) {
-            return;
-        }
-        var scrollTop = element.scrollTop, scrollHeight = element.scrollHeight, clientHeight = element.clientHeight;
-        // https://sendbird.atlassian.net/browse/SBISSUE-11759
-        // the edge case where channel is inside a page that already has scroll
-        // scrollintoView will move the whole page, which we dont want
-        var scrollBottom = calcScrollBottom(scrollHeight, scrollTop);
-        // even if there is more to fetch or not,
-        // we still have to show the scroll to bottom button
-        if (typeof setShowScrollDownButton === 'function') {
-            setShowScrollDownButton(scrollHeight > scrollTop + clientHeight + 1);
-        }
-        if (hasMore && scrollTop < SCROLL_BUFFER) {
-            onScroll(function () {
-                // sets the scroll position to the bottom of the new messages
-                element.scrollTop = element.scrollHeight - scrollBottom;
-            });
-        }
-        if (hasNext) {
-            onScroll(function () {
-                // sets the scroll position to the top of the new messages
-                element.scrollTop = scrollTop - (scrollHeight - element.scrollHeight);
-            });
-        }
-    }, [
-        setShowScrollDownButton,
-        hasMore,
-        onScroll,
-        scrollRef,
-    ]);
-    return useDebounce(scrollCb, DELAY);
-}
-
-export { useDebounce as a, useHandleOnScrollCallback as u };
-//# sourceMappingURL=bundle-Nv1SlZSC.js.map

package/chunks/bundle-Nv1SlZSC.js.map

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