@sendbird/uikit-react 3.15.13 → 3.15.14

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/cjs/chunks/bundle-Khwf-z37.js.map

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

package/cjs/chunks/bundle-Ol1CxgYk.js

@@ -1,385 +0,0 @@
-'use strict';
-
-var _tslib = require('./bundle-D1slQ3hS.js');
-var React = require('react');
-var index$1 = require('./bundle-DTD48j2K.js');
-var utils = require('./bundle-Cq5LKFhE.js');
-var reactDom = require('react-dom');
-var LocalizationContext = require('./bundle-DE5YH8Q-.js');
-var MediaQueryContext = require('./bundle-B5aEwfu1.js');
-var ui_IconButton = require('../ui/IconButton.js');
-var ui_Button = require('../ui/Button.js');
-var ui_Icon = require('../ui/Icon.js');
-var ui_Label = require('./bundle-BA6Cum_9.js');
-require('@sendbird/uikit-tools');
-require('../withSendbird.js');
-require('css-vars-ponyfill');
-require('@sendbird/chat');
-var uuid = require('./bundle-s1cLz65w.js');
-require('@sendbird/chat/openChannel');
-require('@sendbird/chat/groupChannel');
-require('./bundle-sZREfKpL.js');
-var consts = require('./bundle-BloKh_k7.js');
-var useSendbirdStateContext = require('../useSendbirdStateContext.js');
-require('./bundle-QF_AmnwV.js');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var React__default = /*#__PURE__*/_interopDefaultCompat(React);
-
-/**
- * Mapping object to convert numeric keys to descriptive text
- * [(legacy) numeric key]: [(new) descriptive text]
- */
-var colorMapping = {
-    // Primary / Secondary / Error / Information
-    100: 'extra-light',
-    200: 'light',
-    300: 'main',
-    400: 'dark',
-    500: 'extra-dark',
-    // Overlay
-    'overlay-01': 'overlay-dark',
-    'overlay-02': 'overlay-light',
-    // OnLight
-    'onlight-01': 'onlight-text-high-emphasis',
-    'onlight-02': 'onlight-text-mid-emphasis',
-    'onlight-03': 'onlight-text-low-emphasis',
-    'onlight-04': 'onlight-text-disabled',
-    // OnDark
-    'ondark-01': 'ondark-text-high-emphasis',
-    'ondark-02': 'ondark-text-mid-emphasis',
-    'ondark-03': 'ondark-text-low-emphasis',
-    'ondark-04': 'ondark-text-disabled',
-};
-/**
- * Order of mappings to ensure longer keys are matched first
- * e.g. In --sendbird-dark-background-extra-dark, 'extra-dark' should be matched instead of 'dark'
- */
-var colorMappingOrder = Object
-    .values(colorMapping)
-    .sort(function (a, b) { return b.length - a.length; });
-/**
- * Convert colorMapping to a Map for quick lookup in mapColorKeys
- */
-var colorMappingMap = new Map(Object.entries(colorMapping).map(function (_a) {
-    var key = _a[0], value = _a[1];
-    return [value, key];
-}));
-/**
- * Converts descriptive color keys to their numeric equivalents.
- *
- * This function takes a set of CSS variable keys and transforms
- * descriptive color keys (e.g. 'extra-light', 'main') into their
- * numeric equivalents(e.g. 100, 200, ..., 500) as defined in the colorMapping object.
- *
- * e.g.
- * Input:
- * {
- *   '--sendbird-light-primary-extra-dark': '#00487c',
- *   '--sendbird-light-primary-dark': '#4bb3fd',
- *   '--sendbird-light-primary-main': '#3e6680',
- *   '--sendbird-light-primary-light': '#0496ff',
- *   '--sendbird-light-primary-extra-light': '#027bce',
- * }
- *
- * Output:
- * {
- *   '--sendbird-light-primary-500': '#00487c',
- *   '--sendbird-light-primary-400': '#4bb3fd',
- *   '--sendbird-light-primary-300': '#3e6680',
- *   '--sendbird-light-primary-200': '#0496ff',
- *   '--sendbird-light-primary-100': '#027bce',
- * }
- *
- * @param {ColorSet} colorSet - The input object containing CSS variables with descriptive keys.
- * @returns {ColorSet} The transformed object with numeric keys.
- */
-var mapColorKeys = function (colorSet) {
-    var mappedColors = {};
-    Object.entries(colorSet).forEach(function (_a) {
-        var key = _a[0], value = _a[1];
-        var descriptiveKey = key;
-        for (var _i = 0, colorMappingOrder_1 = colorMappingOrder; _i < colorMappingOrder_1.length; _i++) {
-            var mappingValue = colorMappingOrder_1[_i];
-            // Prepare a regex to match the mapping value at the end of the key
-            // e.g., '-extra-dark$'
-            var regex = new RegExp("-".concat(mappingValue, "$"));
-            if (regex.test(key)) {
-                // Find the corresponding numeric key for the mapping value using Map
-                var numericKey = colorMappingMap.get(mappingValue);
-                if (numericKey) {
-                    // Replace the descriptive text with the numeric key
-                    descriptiveKey = key.replace(regex, "-".concat(numericKey));
-                    break;
-                }
-            }
-        }
-        mappedColors[descriptiveKey] = value;
-    });
-    return mappedColors;
-};
-
-// simple component to be used as modal root
-var MODAL_ROOT = 'sendbird-modal-root';
-var ModalRoot = function () { return (React__default.default.createElement("div", { id: MODAL_ROOT, className: MODAL_ROOT })); };
-
-var ModalHeader = function (_a) {
-    var titleText = _a.titleText, onCloseClick = _a.onCloseClick;
-    return (React__default.default.createElement("div", { className: "sendbird-modal__header" },
-        React__default.default.createElement(ui_Label.Label, { type: ui_Label.LabelTypography.H_1, color: ui_Label.LabelColors.ONBACKGROUND_1 }, titleText),
-        React__default.default.createElement("div", { className: "sendbird-modal__close" },
-            React__default.default.createElement(ui_IconButton, { width: "32px", height: "32px", onClick: onCloseClick },
-                React__default.default.createElement(ui_Icon.default, { type: ui_Icon.IconTypes.CLOSE, fillColor: ui_Icon.IconColors.DEFAULT, width: "24px", height: "24px" })))));
-};
-var ModalBody = function (_a) {
-    var children = _a.children;
-    return (React__default.default.createElement("div", { className: "sendbird-modal__body" },
-        React__default.default.createElement(ui_Label.Label, { type: ui_Label.LabelTypography.SUBTITLE_1, color: ui_Label.LabelColors.ONBACKGROUND_2 }, children)));
-};
-var ModalFooter = function (_a) {
-    var submitText = _a.submitText, _b = _a.disabled, disabled = _b === void 0 ? false : _b, _c = _a.hideCancelButton, hideCancelButton = _c === void 0 ? false : _c, _d = _a.type, type = _d === void 0 ? ui_Button.ButtonTypes.DANGER : _d, onSubmit = _a.onSubmit, onCancel = _a.onCancel;
-    var stringSet = React.useContext(LocalizationContext.LocalizationContext).stringSet;
-    return (React__default.default.createElement("div", { className: "sendbird-modal__footer" },
-        !hideCancelButton && (React__default.default.createElement(ui_Button.default, { type: ui_Button.ButtonTypes.SECONDARY, onClick: onCancel },
-            React__default.default.createElement(ui_Label.Label, { type: ui_Label.LabelTypography.BUTTON_1, color: ui_Label.LabelColors.ONBACKGROUND_1 }, stringSet.BUTTON__CANCEL))),
-        React__default.default.createElement(ui_Button.default, { type: type, disabled: disabled, onClick: onSubmit }, submitText)));
-};
-function Modal(props) {
-    var _a;
-    var _b = props.children, children = _b === void 0 ? null : _b, _c = props.className, className = _c === void 0 ? '' : _c, _d = props.contentClassName, contentClassName = _d === void 0 ? '' : _d, _e = props.isCloseOnClickOutside, isCloseOnClickOutside = _e === void 0 ? false : _e, _f = props.isFullScreenOnMobile, isFullScreenOnMobile = _f === void 0 ? false : _f, titleText = props.titleText, submitText = props.submitText, _g = props.disabled, disabled = _g === void 0 ? false : _g, _h = props.hideFooter, hideFooter = _h === void 0 ? false : _h, _j = props.type, type = _j === void 0 ? ui_Button.ButtonTypes.DANGER : _j, renderHeader = props.renderHeader, _k = props.onSubmit, onSubmit = _k === void 0 ? utils.noop : _k, onClose = props.onClose, onCancel = props.onCancel, customFooter = props.customFooter;
-    var handleClose = (_a = onClose !== null && onClose !== void 0 ? onClose : onCancel) !== null && _a !== void 0 ? _a : utils.noop;
-    var eventHandlers = useSendbirdStateContext.useSendbirdStateContext().eventHandlers;
-    var id = React.useState(function () { return "sbu-modal-".concat(uuid.uuidv4()); })[0];
-    React.useEffect(function () {
-        var _a, _b;
-        return (_b = (_a = eventHandlers === null || eventHandlers === void 0 ? void 0 : eventHandlers.modal) === null || _a === void 0 ? void 0 : _a.onMounted) === null || _b === void 0 ? void 0 : _b.call(_a, { close: handleClose, id: id });
-    }, []);
-    var isMobile = MediaQueryContext.useMediaQueryContext().isMobile;
-    return reactDom.createPortal(React__default.default.createElement("div", { className: utils.classnames('sendbird-modal', className, isFullScreenOnMobile && isMobile && 'sendbird-modal--full-mobile') },
-        React__default.default.createElement("div", { className: utils.classnames.apply(void 0, _tslib.__spreadArray(['sendbird-modal__content'], (Array.isArray(contentClassName) ? contentClassName : [contentClassName]), false)) },
-            (renderHeader === null || renderHeader === void 0 ? void 0 : renderHeader()) || React__default.default.createElement(ModalHeader, { titleText: titleText !== null && titleText !== void 0 ? titleText : '', onCloseClick: handleClose }),
-            React__default.default.createElement(ModalBody, null, children),
-            !hideFooter
-                && (customFooter !== null && customFooter !== void 0 ? customFooter : (React__default.default.createElement(ModalFooter, { disabled: disabled, onCancel: handleClose, onSubmit: onSubmit, submitText: submitText !== null && submitText !== void 0 ? submitText : '', type: type })))),
-        React__default.default.createElement("div", { className: utils.classnames('sendbird-modal__backdrop', isCloseOnClickOutside && 'sendbird-modal__backdrop--clickoutside'), onClick: function (e) {
-                e === null || e === void 0 ? void 0 : e.stopPropagation();
-                if (isCloseOnClickOutside) {
-                    handleClose();
-                }
-            } })), document.getElementById(MODAL_ROOT));
-}
-
-var Context = React.createContext({
-    start: utils.noop,
-    stop: utils.noop,
-    isRecordable: false,
-});
-var VoiceRecorderProvider = function (props) {
-    var _a;
-    var children = props.children;
-    var config = useSendbirdStateContext.useSendbirdStateContext().config;
-    var logger = config.logger, groupChannel = config.groupChannel;
-    var _b = React.useState(null), mediaRecorder = _b[0], setMediaRecorder = _b[1];
-    var _c = React.useState(false), isRecordable = _c[0], setIsRecordable = _c[1];
-    var _d = React.useState(false), permissionWarning = _d[0], setPermissionWarning = _d[1];
-    var stringSet = LocalizationContext.useLocalization().stringSet;
-    var isVoiceMessageEnabled = groupChannel.enableVoiceMessage;
-    var _e = React.useState(null), webAudioUtils = _e[0], setWebAudioUtils = _e[1];
-    var browserSupportMimeType = (_a = consts.BROWSER_SUPPORT_MIME_TYPE_LIST.find(function (mimeType) { return MediaRecorder.isTypeSupported(mimeType); })) !== null && _a !== void 0 ? _a : '';
-    if (isVoiceMessageEnabled && !browserSupportMimeType) {
-        logger.error('VoiceRecorder: Browser does not support mimeType', { mimmeTypes: consts.BROWSER_SUPPORT_MIME_TYPE_LIST });
-    }
-    React.useEffect(function () {
-        if (isVoiceMessageEnabled && !webAudioUtils) {
-            Promise.resolve().then(function () { return require('./bundle-BOCivP7e.js'); }).then(function (module) { return setWebAudioUtils(module); });
-        }
-    }, [isVoiceMessageEnabled, webAudioUtils]);
-    var start = React.useCallback(function (eventHandler) {
-        var _a, _b;
-        if (isVoiceMessageEnabled && !webAudioUtils) {
-            logger.error('VoiceRecorder: Recording audio processor is being loaded.');
-            return;
-        }
-        var checkPermission = function () {
-            try {
-                // Type '"microphone"' is not assignable to type 'PermissionName'.ts(2322)
-                // this is typescript issue
-                // https://github.com/microsoft/TypeScript/issues/33923
-                // @ts-expect-error
-                navigator.permissions.query({ name: 'microphone' }).then(function (result) {
-                    if (result.state === 'denied') {
-                        logger.warning('VoiceRecorder: Permission denied.');
-                        setPermissionWarning(true);
-                    }
-                });
-            }
-            catch (error) {
-                logger.warning('VoiceRecorder: Failed to check permission.', error);
-            }
-        };
-        logger.info('VoiceRecorder: Start recording.');
-        if (mediaRecorder) {
-            stop();
-            logger.info('VoiceRecorder: Previous mediaRecorder is stopped.');
-        }
-        checkPermission();
-        (_b = (_a = navigator === null || navigator === void 0 ? void 0 : navigator.mediaDevices) === null || _a === void 0 ? void 0 : _a.getUserMedia) === null || _b === void 0 ? void 0 : _b.call(_a, { audio: true }).then(function (stream) {
-            var _a;
-            logger.info('VoiceRecorder: Succeeded getting media stream.', stream);
-            setIsRecordable(true);
-            var mediaRecorder = new MediaRecorder(stream, {
-                mimeType: browserSupportMimeType,
-                audioBitsPerSecond: consts.VOICE_RECORDER_AUDIO_BIT_RATE,
-            });
-            // when recording stops
-            mediaRecorder.ondataavailable = function (e) {
-                logger.info('VoiceRecorder: Succeeded getting an available data.', e.data);
-                var audioFile = new File([e.data], consts.VOICE_MESSAGE_FILE_NAME, {
-                    lastModified: new Date().getTime(),
-                    type: consts.VOICE_MESSAGE_MIME_TYPE,
-                });
-                webAudioUtils === null || webAudioUtils === void 0 ? void 0 : webAudioUtils.downsampleToWav(audioFile, function (buffer) {
-                    var _a;
-                    var mp3Buffer = webAudioUtils === null || webAudioUtils === void 0 ? void 0 : webAudioUtils.encodeMp3(buffer);
-                    var mp3blob = new Blob(mp3Buffer, { type: consts.VOICE_MESSAGE_MIME_TYPE });
-                    var convertedAudioFile = new File([mp3blob], consts.VOICE_MESSAGE_FILE_NAME, {
-                        lastModified: new Date().getTime(),
-                        type: consts.VOICE_MESSAGE_MIME_TYPE,
-                    });
-                    (_a = eventHandler === null || eventHandler === void 0 ? void 0 : eventHandler.onRecordingEnded) === null || _a === void 0 ? void 0 : _a.call(eventHandler, convertedAudioFile);
-                    logger.info('VoiceRecorder: Succeeded converting audio file.', convertedAudioFile);
-                });
-                var tracks = stream.getAudioTracks();
-                tracks.forEach(function (track) { return track.stop(); });
-                setIsRecordable(false);
-            };
-            mediaRecorder.onstart = (_a = eventHandler === null || eventHandler === void 0 ? void 0 : eventHandler.onRecordingStarted) !== null && _a !== void 0 ? _a : utils.noop;
-            mediaRecorder === null || mediaRecorder === void 0 ? void 0 : mediaRecorder.start();
-            setMediaRecorder(mediaRecorder);
-        }).catch(function (err) {
-            logger.error('VoiceRecorder: Failed getting media stream.', err);
-            setMediaRecorder(null);
-        });
-    }, [mediaRecorder, webAudioUtils]);
-    var stop = React.useCallback(function () {
-        // Stop recording
-        mediaRecorder === null || mediaRecorder === void 0 ? void 0 : mediaRecorder.stop();
-        setMediaRecorder(null);
-        setIsRecordable(false);
-        logger.info('VoiceRecorder: Stop recording.');
-    }, [mediaRecorder]);
-    return (React__default.default.createElement(Context.Provider, { value: { start: start, stop: stop, isRecordable: isRecordable } },
-        children,
-        permissionWarning && (React__default.default.createElement(Modal, { hideFooter: true, onClose: function () { return setPermissionWarning(false); } },
-            React__default.default.createElement(React__default.default.Fragment, null, stringSet.VOICE_RECORDING_PERMISSION_DENIED)))));
-};
-var useVoiceRecorderContext = function () { return React.useContext(Context); };
-var index = {
-    VoiceRecorderProvider: VoiceRecorderProvider,
-    useVoiceRecorderContext: useVoiceRecorderContext,
-};
-
-var GlobalModalContext = React.createContext({
-    openModal: utils.noop,
-});
-var GlobalModalProvider = function (_a) {
-    var children = _a.children;
-    // Idea from https://dev.to/nurislamov/simple-modals-queue-in-react-4g6c
-    var _b = React.useState([]), globalModalQueue = _b[0], setGlobalModalQueue = _b[1];
-    var openModal = React.useCallback(function (props) {
-        setGlobalModalQueue(function (currentQue) { return _tslib.__spreadArray(_tslib.__spreadArray([], currentQue, true), [props], false); });
-    }, []);
-    var closeModal = React.useCallback(function () {
-        setGlobalModalQueue(function (currentQue) { return currentQue.slice(1); });
-    }, []);
-    var ModalComponent = React.useMemo(function () { return function () {
-        return index$1.K(globalModalQueue)
-            .when(function (q) { return q.length === 0; }, function () {
-            return React__default.default.createElement(React__default.default.Fragment, null);
-        })
-            .otherwise(function () {
-            var _a = globalModalQueue[0], modalProps = _a.modalProps, childElement = _a.childElement;
-            return (React__default.default.createElement(Modal, _tslib.__assign({}, modalProps, { className: utils.classnames('sendbird-global-modal', modalProps === null || modalProps === void 0 ? void 0 : modalProps.className), onClose: function () {
-                    var _a;
-                    (_a = modalProps === null || modalProps === void 0 ? void 0 : modalProps.onClose) === null || _a === void 0 ? void 0 : _a.call(modalProps);
-                    closeModal();
-                } }), childElement({
-                closeModal: closeModal,
-            })));
-        });
-    }; }, [globalModalQueue]);
-    return (React__default.default.createElement(GlobalModalContext.Provider, { value: {
-            openModal: openModal,
-        } },
-        React__default.default.createElement(ModalComponent, null),
-        children));
-};
-var useGlobalModalContext = function () { return React.useContext(GlobalModalContext); };
-
-var EmojiManager = /** @class */ (function () {
-    function EmojiManager(props) {
-        var _this = this;
-        var _a;
-        var sdk = props.sdk, logger = props.logger;
-        (_a = sdk === null || sdk === void 0 ? void 0 : sdk.getAllEmoji) === null || _a === void 0 ? void 0 : _a.call(sdk).then(function (emojiContainer) {
-            _this._emojiContainer = emojiContainer;
-            logger === null || logger === void 0 ? void 0 : logger.info('EmojiManager | Succeeded getting all emojis. ', emojiContainer);
-        }).catch(function () {
-            logger === null || logger === void 0 ? void 0 : logger.warning('EmojiManager | Failed getting all emojis.');
-        });
-    }
-    Object.defineProperty(EmojiManager.prototype, "AllEmojisAsArray", {
-        get: function () {
-            return this._emojiContainer.emojiCategories.flatMap(function (category) { return category.emojis; });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(EmojiManager.prototype, "AllEmojisAsMap", {
-        get: function () {
-            return this._emojiContainer.emojiCategories
-                .flatMap(function (category) { return category.emojis; })
-                .reduce(function (map, emoji) {
-                map.set(emoji.key, emoji.url);
-                return map;
-            }, new Map());
-        },
-        enumerable: false,
-        configurable: true
-    });
-    EmojiManager.prototype.getAllEmojis = function (type) {
-        var _this = this;
-        return index$1.K(type)
-            .when(function (type) { return ['array', 'arr'].includes(type); }, function () { return _this.AllEmojisAsArray; })
-            .when(function (type) { return ['map'].includes(type); }, function () { return _this.AllEmojisAsMap; })
-            .otherwise(function () { return _this.AllEmojisAsArray; });
-    };
-    EmojiManager.prototype.getEmojiUrl = function (reactionKey) {
-        var _a, _b;
-        return (_b = (_a = this.AllEmojisAsArray.find(function (emoji) { return emoji.key === reactionKey; })) === null || _a === void 0 ? void 0 : _a.url) !== null && _b !== void 0 ? _b : '';
-    };
-    Object.defineProperty(EmojiManager.prototype, "emojiContainer", {
-        get: function () {
-            return this._emojiContainer;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return EmojiManager;
-}());
-
-exports.EmojiManager = EmojiManager;
-exports.GlobalModalProvider = GlobalModalProvider;
-exports.MODAL_ROOT = MODAL_ROOT;
-exports.Modal = Modal;
-exports.ModalBody = ModalBody;
-exports.ModalFooter = ModalFooter;
-exports.ModalHeader = ModalHeader;
-exports.ModalRoot = ModalRoot;
-exports.VoiceRecorderProvider = VoiceRecorderProvider;
-exports.index = index;
-exports.mapColorKeys = mapColorKeys;
-exports.useGlobalModalContext = useGlobalModalContext;
-exports.useVoiceRecorderContext = useVoiceRecorderContext;
-//# sourceMappingURL=bundle-Ol1CxgYk.js.map

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

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

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

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

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

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

package/cjs/chunks/bundle-S-XkXH4q.js.map

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/cjs/useSendbirdStateContext.js

@@ -1,27 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var React = require('react');
-var withSendbird = require('./withSendbird.js');
-require('./chunks/bundle-D1slQ3hS.js');
-
-/**
- * Example:
- * const MyComponent = () => {
- *  const context = useSendbirdStateContext();
- *  const sdk = sendbirdSelectors.getSdk(context);
- *  return (<div>...</div>);
- * }
- */
-var NO_CONTEXT_ERROR = 'No sendbird state value available. Make sure you are rendering `<SendbirdProvider>` at the top of your app.';
-function useSendbirdStateContext() {
-    var context = React.useContext(withSendbird.SendbirdSdkContext);
-    if (!context)
-        throw new Error(NO_CONTEXT_ERROR);
-    return context;
-}
-
-exports.default = useSendbirdStateContext;
-exports.useSendbirdStateContext = useSendbirdStateContext;
-//# sourceMappingURL=useSendbirdStateContext.js.map

package/cjs/useSendbirdStateContext.js.map

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

package/cjs/withSendbird.js

@@ -1,33 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _tslib = require('./chunks/bundle-D1slQ3hS.js');
-var React = require('react');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var React__default = /*#__PURE__*/_interopDefaultCompat(React);
-
-var SendbirdSdkContext = React__default.default.createContext(null);
-/**
- * @deprecated This function is deprecated. Use `useSendbirdStateContext` instead.
- * */
-var withSendbirdContext = function (OriginalComponent, mapStoreToProps) {
-    var ContextAwareComponent = function (props) { return (React__default.default.createElement(SendbirdSdkContext.Consumer, null, function (context) {
-        if (mapStoreToProps && typeof mapStoreToProps !== 'function') {
-            // eslint-disable-next-line no-console
-            console.warn('Second parameter to withSendbirdContext must be a pure function');
-        }
-        var mergedProps = (mapStoreToProps && typeof mapStoreToProps === 'function')
-            ? _tslib.__assign(_tslib.__assign({}, mapStoreToProps(context)), props) : _tslib.__assign(_tslib.__assign({}, context), props);
-        return React__default.default.createElement(OriginalComponent, _tslib.__assign({}, mergedProps));
-    })); };
-    var componentName = OriginalComponent.displayName || OriginalComponent.name || 'Component';
-    ContextAwareComponent.displayName = "SendbirdAware".concat(componentName);
-    return ContextAwareComponent;
-};
-
-exports.SendbirdSdkContext = SendbirdSdkContext;
-exports.default = withSendbirdContext;
-//# sourceMappingURL=withSendbird.js.map

package/cjs/withSendbird.js.map

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

package/types/hooks/useAppendDomNode.d.ts

@@ -1,2 +0,0 @@
-declare function useAppendDomNode(ids?: string[], rootSelector?: string): void;
-export default useAppendDomNode;

package/types/hooks/useSendbirdStateContext.d.ts

@@ -1,3 +0,0 @@
-import { SendBirdState } from '../lib/types';
-export declare function useSendbirdStateContext(): SendBirdState;
-export default useSendbirdStateContext;

package/types/lib/Sendbird.d.ts

@@ -1,67 +0,0 @@
-import './index.scss';
-import './__experimental__typography.scss';
-import React from 'react';
-import { GroupChannel } from '@sendbird/chat/groupChannel';
-import { StringSet } from '../ui/Label/stringSet';
-import { ConfigureSessionTypes } from './hooks/useConnect/types';
-import { UIKitOptions, CommonUIKitConfigProps, SendbirdChatInitParams, CustomExtensionParams, SBUEventHandlers } from './types';
-import { HTMLTextDirection, RenderUserProfileProps, UserListQuery } from '../types';
-import { SBUGlobalPubSub } from './pubSub/topics';
-export { useSendbirdStateContext } from '../hooks/useSendbirdStateContext';
-interface VoiceRecordOptions {
-    maxRecordingTime?: number;
-    minRecordingTime?: number;
-}
-export type ImageCompressionOutputFormatType = 'preserve' | 'png' | 'jpeg';
-export interface ImageCompressionOptions {
-    compressionRate?: number;
-    resizingWidth?: number | string;
-    resizingHeight?: number | string;
-    outputFormat?: ImageCompressionOutputFormatType;
-}
-export interface SendbirdConfig {
-    logLevel?: string | Array<string>;
-    pubSub?: SBUGlobalPubSub;
-    userMention?: {
-        maxMentionCount?: number;
-        maxSuggestionCount?: number;
-    };
-    isREMUnitEnabled?: boolean;
-}
-export interface SendbirdProviderProps extends CommonUIKitConfigProps, React.PropsWithChildren<unknown> {
-    appId: string;
-    userId: string;
-    accessToken?: string;
-    customApiHost?: string;
-    customWebSocketHost?: string;
-    configureSession?: ConfigureSessionTypes;
-    theme?: 'light' | 'dark';
-    config?: SendbirdConfig;
-    nickname?: string;
-    colorSet?: Record<string, string>;
-    stringSet?: Partial<StringSet>;
-    dateLocale?: Locale;
-    profileUrl?: string;
-    voiceRecord?: VoiceRecordOptions;
-    userListQuery?: () => UserListQuery;
-    imageCompression?: ImageCompressionOptions;
-    allowProfileEdit?: boolean;
-    disableMarkAsDelivered?: boolean;
-    breakpoint?: string | boolean;
-    htmlTextDirection?: HTMLTextDirection;
-    forceLeftToRightMessageLayout?: boolean;
-    uikitOptions?: UIKitOptions;
-    isUserIdUsedForNickname?: boolean;
-    sdkInitParams?: SendbirdChatInitParams;
-    customExtensionParams?: CustomExtensionParams;
-    isMultipleFilesMessageEnabled?: boolean;
-    renderUserProfile?: (props: RenderUserProfileProps) => React.ReactElement;
-    onStartDirectMessage?: (channel: GroupChannel) => void;
-    /**
-     * @deprecated Please use `onStartDirectMessage` instead. It's renamed.
-     */
-    onUserProfileMessage?: (channel: GroupChannel) => void;
-    eventHandlers?: SBUEventHandlers;
-}
-export declare function SendbirdProvider(props: SendbirdProviderProps): React.JSX.Element;
-export default SendbirdProvider;

package/types/lib/SendbirdSdkContext.d.ts

@@ -1,12 +0,0 @@
-import React from 'react';
-import type { SendBirdState } from './types';
-type ContextAwareComponentType = {
-    (props: any): JSX.Element;
-    displayName: string;
-};
-export declare const SendbirdSdkContext: React.Context<SendBirdState>;
-/**
- * @deprecated This function is deprecated. Use `useSendbirdStateContext` instead.
- * */
-declare const withSendbirdContext: (OriginalComponent: any, mapStoreToProps: Record<string, any>) => ContextAwareComponentType;
-export default withSendbirdContext;

package/types/lib/SendbirdState.d.ts

@@ -1,7 +0,0 @@
-import { Dispatch } from 'react';
-import { LoggerInterface } from './Logger';
-export type CustomUseReducerDispatcher = Dispatch<{
-    type: string;
-    payload: any;
-}>;
-export type Logger = LoggerInterface;