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

package/dist/cjs/chunks/bundle-VXYKCjcf.js

@@ -0,0 +1,217 @@
+'use strict';
+
+var React = require('react');
+var DOMPurify = require('dompurify');
+var _tslib = require('./bundle-RmtoGD4w.js');
+var consts = require('./bundle-PxOOmulx.js');
+var consts$2 = require('./bundle-SiCT4KKh.js');
+var consts$1 = require('./bundle-T16VOUoM.js');
+
+function renderToString(_a) {
+    var userId = _a.userId, nickname = _a.nickname;
+    // donot change this template, it wont work
+    var el = "<span data-userid=\"".concat(userId, "\" data-sb-mention=\"true\" class=\"").concat(consts.MENTION_USER_LABEL_CLASSNAME, "\">").concat(nickname, "</span>");
+    var purifier = DOMPurify(window);
+    var sanitized_ = purifier.sanitize(el);
+    var token = sanitized_.split(' ');
+    var spanTag = token[0], rest = token.slice(1);
+    // we do this because DOMPurify removes the contenteditable attribute
+    var sanitized = _tslib.__spreadArray([spanTag, 'contenteditable="false"'], rest, true).join(' ');
+    return sanitized;
+}
+
+var sanitizeString = function (str) {
+    return str === null || str === void 0 ? void 0 : str.replace(/[\u00A0-\u9999<>]/gim, function (i) { return ''.concat('&#', String(i.charCodeAt(0)), ';'); });
+};
+/**
+ * NodeList cannot be used with Array methods
+ * @param {NodeListOf<ChildNode>} childNodes
+ * @returns Array of child nodes
+ */
+var nodeListToArray = function (childNodes) {
+    try {
+        return Array.from(childNodes);
+    }
+    catch (error) {
+        return [];
+    }
+};
+function isChannelTypeSupportsMultipleFilesMessage(channel) {
+    var _a;
+    return channel && ((_a = channel.isGroupChannel) === null || _a === void 0 ? void 0 : _a.call(channel)) && !channel.isBroadcast && !channel.isSuper;
+}
+
+function inserTemplateToDOM(templateList) {
+    var nodes = templateList.map(function (template) {
+        var text = template.text, userId = template.userId;
+        if (userId) {
+            return renderToString({ userId: userId, nickname: text });
+        }
+        return sanitizeString(text);
+    })
+        .join(' ')
+        // add a space at the end of the mention, else cursor/caret wont work
+        .concat(' ');
+    document.execCommand('insertHTML', false, nodes);
+}
+
+var PASTE_NODE = 'sendbird-uikit__paste-node';
+var TEXT_MESSAGE_CLASS = 'sendbird-word';
+var MENTION_CLASS = 'sendbird-word__mention';
+var MENTION_CLASS_IN_INPUT = 'sendbird-mention-user-label';
+var MENTION_CLASS_COMBINED_QUERY = ".".concat(MENTION_CLASS, ", .").concat(MENTION_CLASS_IN_INPUT);
+
+function querySelectorIncludingSelf(master, selector) {
+    var result = _tslib.__spreadArray([
+        master
+    ], Array.from(master.querySelectorAll(selector)), true).find(function (el) { return el.matches(selector); });
+    return result;
+}
+// Pasted dom node can be OG_MESSAGE or partial message or full message
+// full messsage would have TEXT_MESSAGE_BODY_CLASSNAME and have childNodes
+// partial message would not have TEXT_MESSAGE_BODY_CLASSNAME
+function getLeafNodes(master) {
+    // og message
+    var ogMessage = querySelectorIncludingSelf(master, ".".concat(consts$1.OG_MESSAGE_BODY_CLASSNAME));
+    if (ogMessage) {
+        return nodeListToArray(ogMessage.childNodes);
+    }
+    var textMessageBody = querySelectorIncludingSelf(master, ".".concat(consts$2.TEXT_MESSAGE_BODY_CLASSNAME));
+    if (textMessageBody) {
+        return nodeListToArray(textMessageBody.childNodes);
+    }
+    return nodeListToArray(master.childNodes);
+}
+function createPasteNode() {
+    var pasteNode = document.body.querySelector("#".concat(PASTE_NODE));
+    // remove existing paste node
+    if (pasteNode) {
+        pasteNode === null || pasteNode === void 0 ? void 0 : pasteNode.remove();
+    }
+    // create new paste node and return
+    var node = document.createElement('div');
+    node.id = PASTE_NODE;
+    node.style.display = 'none';
+    return node;
+}
+function hasMention(parent) {
+    return (parent === null || parent === void 0 ? void 0 : parent.querySelector(MENTION_CLASS_COMBINED_QUERY)) ? true : false;
+}
+var extractTextFromNodes = function (nodes) {
+    var text = '';
+    nodes.forEach(function (node) {
+        // to preserve space between words
+        var textNodes = node.querySelectorAll(".".concat(TEXT_MESSAGE_CLASS));
+        if (textNodes.length > 0) {
+            text += ((extractTextFromNodes(Array.from(textNodes))) + ' ');
+        }
+        text += (node.innerText + ' ');
+    });
+    return text;
+};
+function domToMessageTemplate(nodeArray) {
+    var templates = nodeArray === null || nodeArray === void 0 ? void 0 : nodeArray.reduce(function (accumulator, currentValue) {
+        var _a;
+        // currentValue can be node(from messageBody or messageInput) or text
+        var mentionNode;
+        // this looks awkward, but it is a fallback to set default text
+        var text = currentValue === null || currentValue === void 0 ? void 0 : currentValue.innerText;
+        // if text node, set text
+        if (currentValue instanceof Text) {
+            mentionNode = false;
+            text = currentValue.textContent;
+        }
+        if (currentValue instanceof HTMLElement) {
+            mentionNode = (currentValue.classList.contains(MENTION_CLASS) || currentValue.classList.contains(MENTION_CLASS_IN_INPUT))
+                ? currentValue
+                : currentValue.querySelector(MENTION_CLASS_COMBINED_QUERY);
+        }
+        // if mentionNode is not null, it is a mention
+        if (mentionNode) {
+            var text_1 = currentValue === null || currentValue === void 0 ? void 0 : currentValue.innerText;
+            var userId = (_a = mentionNode.dataset) === null || _a === void 0 ? void 0 : _a.userid;
+            return _tslib.__spreadArray(_tslib.__spreadArray([], accumulator, true), [
+                {
+                    text: text_1,
+                    userId: userId,
+                },
+            ], false);
+        }
+        return _tslib.__spreadArray(_tslib.__spreadArray([], accumulator, true), [
+            {
+                text: text,
+            },
+        ], false);
+    }, []);
+    return templates;
+}
+function getUsersFromWords(templates, channel) {
+    var userMap = {};
+    var users = channel.members;
+    templates.forEach(function (template) {
+        if (template.userId) {
+            var mentionedMember = users.find(function (user) { return user.userId === template.userId; });
+            // Object.values would return array-> [undefined] if the user is not in the channel
+            if (mentionedMember) {
+                userMap[template.userId] = mentionedMember;
+            }
+        }
+    });
+    return Object.values(userMap);
+}
+
+// exported, should be backward compatible
+// conditions to test:
+// 1. paste simple text
+// 2. paste text with mention
+// 3. paste text with mention and text
+// 4. paste text with mention and text and paste again before and after
+// 5. copy message with mention(only one mention, no other text) and paste
+// 6. copy message with mention from input and paste(before and after)
+function usePaste(_a) {
+    var ref = _a.ref, setIsInput = _a.setIsInput, setHeight = _a.setHeight, channel = _a.channel, setMentionedUsers = _a.setMentionedUsers;
+    return React.useCallback(function (e) {
+        e.preventDefault();
+        var html = e === null || e === void 0 ? void 0 : e.clipboardData.getData('text/html');
+        // simple text, continue as normal
+        if (!html) {
+            var text = e === null || e === void 0 ? void 0 : e.clipboardData.getData('text');
+            document.execCommand('insertHTML', false, sanitizeString(text));
+            setIsInput(true);
+            setHeight();
+            return;
+        }
+        // has html, check if there are mentions, sanitize and insert
+        var purifier = DOMPurify(window);
+        var clean = purifier.sanitize(html);
+        var pasteNode = createPasteNode();
+        pasteNode.innerHTML = clean;
+        // does not have mention, continue as normal
+        if (!hasMention(pasteNode)) {
+            // to preserve space between words
+            var text = extractTextFromNodes(Array.from(pasteNode.children));
+            document.execCommand('insertHTML', false, sanitizeString(text));
+            pasteNode.remove();
+            setIsInput(true);
+            setHeight();
+            return;
+        }
+        // has mention, collect leaf nodes and parse words
+        var leafNodes = getLeafNodes(pasteNode);
+        var words = domToMessageTemplate(leafNodes);
+        var mentionedUsers = channel.isGroupChannel() ? getUsersFromWords(words, channel) : [];
+        // side effects
+        setMentionedUsers(mentionedUsers);
+        inserTemplateToDOM(words);
+        pasteNode.remove();
+        setIsInput(true);
+        setHeight();
+    }, [ref, setIsInput, setHeight, channel, setMentionedUsers]);
+}
+
+exports.isChannelTypeSupportsMultipleFilesMessage = isChannelTypeSupportsMultipleFilesMessage;
+exports.nodeListToArray = nodeListToArray;
+exports.renderToString = renderToString;
+exports.sanitizeString = sanitizeString;
+exports.usePaste = usePaste;
+//# sourceMappingURL=bundle-VXYKCjcf.js.map

package/dist/cjs/chunks/bundle-VXYKCjcf.js.map

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

package/dist/cjs/chunks/bundle-WOnMwb1P.js

@@ -0,0 +1,74 @@
+'use strict';
+
+var index = require('./bundle-CDhpLgdo.js');
+var index_module = require('./bundle--sK1aluY.js');
+
+function getMessageFirstFileType(message) {
+    return index_module.K(message)
+        .when(index.isFileMessage, function () {
+        var _a;
+        return (_a = message === null || message === void 0 ? void 0 : message.type) !== null && _a !== void 0 ? _a : '';
+    })
+        .when(index.isMultipleFilesMessage, function () {
+        var _a, _b;
+        return (_b = (_a = getFirstFileInfo(message)) === null || _a === void 0 ? void 0 : _a.mimeType) !== null && _b !== void 0 ? _b : '';
+    })
+        .otherwise(function () {
+        return '';
+    });
+}
+function getFirstFileInfo(message) {
+    var fileInfoList = message.fileInfoList;
+    return fileInfoList.length > 0 ? fileInfoList[0] : null;
+}
+function getMessageFirstFileName(message) {
+    return index_module.K(message)
+        .when(index.isFileMessage, function () {
+        var _a;
+        return (_a = message === null || message === void 0 ? void 0 : message.name) !== null && _a !== void 0 ? _a : '';
+    })
+        .when(index.isMultipleFilesMessage, function () {
+        var _a, _b;
+        return (_b = (_a = getFirstFileInfo(message)) === null || _a === void 0 ? void 0 : _a.fileName) !== null && _b !== void 0 ? _b : '';
+    })
+        .otherwise(function () {
+        return '';
+    });
+}
+function getMessageFirstFileUrl(message) {
+    return index_module.K(message)
+        .when(index.isFileMessage, function () {
+        var _a;
+        return (_a = message === null || message === void 0 ? void 0 : message.url) !== null && _a !== void 0 ? _a : '';
+    })
+        .when(index.isMultipleFilesMessage, function () {
+        var _a, _b;
+        return (_b = (_a = getFirstFileInfo(message)) === null || _a === void 0 ? void 0 : _a.url) !== null && _b !== void 0 ? _b : '';
+    })
+        .otherwise(function () {
+        return '';
+    });
+}
+function getMessageFirstFileThumbnails(message) {
+    return index_module.K(message)
+        .when(index.isFileMessage, function () {
+        return message.thumbnails;
+    })
+        .when(index.isMultipleFilesMessage, function () {
+        var _a, _b;
+        return (_b = (_a = getFirstFileInfo(message)) === null || _a === void 0 ? void 0 : _a.thumbnails) !== null && _b !== void 0 ? _b : [];
+    })
+        .otherwise(function () {
+        return [];
+    });
+}
+function getMessageFirstFileThumbnailUrl(message) {
+    var thumbnails = getMessageFirstFileThumbnails(message);
+    return (thumbnails && thumbnails.length > 0) ? thumbnails[0].url : '';
+}
+
+exports.getMessageFirstFileName = getMessageFirstFileName;
+exports.getMessageFirstFileThumbnailUrl = getMessageFirstFileThumbnailUrl;
+exports.getMessageFirstFileType = getMessageFirstFileType;
+exports.getMessageFirstFileUrl = getMessageFirstFileUrl;
+//# sourceMappingURL=bundle-WOnMwb1P.js.map

package/dist/cjs/chunks/bundle-WOnMwb1P.js.map

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

package/dist/cjs/chunks/bundle-Y1a8RrT8.js

@@ -0,0 +1,11 @@
+'use strict';
+
+// note to SDK team:
+// using enum inside .d.ts won’t work for jest, but const enum will work.
+var Role = {
+    OPERATOR: 'operator',
+    NONE: 'none',
+};
+
+exports.Role = Role;
+//# sourceMappingURL=bundle-Y1a8RrT8.js.map

package/dist/cjs/chunks/bundle-Y1a8RrT8.js.map

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

package/dist/cjs/chunks/bundle-cbDU-09l.js

@@ -0,0 +1,236 @@
+'use strict';
+
+var React = require('react');
+var _tslib = require('./bundle-RmtoGD4w.js');
+var consts = require('./bundle-98hUmAMo.js');
+var useSendbirdStateContext = require('../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 _tslib.__assign(_tslib.__assign({}, state), { audioStorage: _tslib.__assign(_tslib.__assign({}, state.audioStorage), (_a = {}, _a[groupKey] = audioUnit, _a)) });
+        }
+        case SET_CURRENT_PLAYER: {
+            var _j = action.payload, audioPlayer = _j.audioPlayer, groupKey = _j.groupKey;
+            return _tslib.__assign(_tslib.__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 _tslib.__assign(_tslib.__assign({}, state), { audioStorage: _tslib.__assign(_tslib.__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 _tslib.__assign(_tslib.__assign({}, state), { audioStorage: _tslib.__assign(_tslib.__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 _tslib.__assign(_tslib.__assign({}, state), { audioStorage: _tslib.__assign(_tslib.__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 = React.createContext({
+    play: noop,
+    pause: noop,
+    stop: noop,
+    voicePlayerStore: VoicePlayerStoreDefaultValue,
+});
+var VoicePlayerProvider = function (_a) {
+    var children = _a.children;
+    var _b = React.useReducer(voicePlayerReducer, voicePlayerInitialState), voicePlayerStore = _b[0], voicePlayerDispatcher = _b[1];
+    var currentGroupKey = voicePlayerStore.currentGroupKey, currentPlayer = voicePlayerStore.currentPlayer, audioStorage = voicePlayerStore.audioStorage;
+    var config = useSendbirdStateContext.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(consts.VOICE_PLAYER_ROOT_ID);
+        var voicePlayerAudioElement = document.getElementById(consts.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], consts.VOICE_MESSAGE_FILE_NAME, {
+                    lastModified: new Date().getTime(),
+                    type: consts.VOICE_MESSAGE_MIME_TYPE,
+                });
+                resolve(audioFile);
+                logger.info('VoicePlayer: Get the audioFile from URL.');
+            });
+        }).then(function (audioFile) {
+            var _a;
+            var voicePlayerRoot = document.getElementById(consts.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 = consts.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.createElement(Context.Provider, { value: {
+            play: play,
+            pause: pause,
+            stop: stop,
+            voicePlayerStore: voicePlayerStore,
+        } },
+        React.createElement("div", { id: consts.VOICE_PLAYER_ROOT_ID, style: { display: 'none' } }),
+        children));
+};
+var useVoicePlayerContext = function () { return React.useContext(Context); };
+
+exports.ALL = ALL;
+exports.AudioUnitDefaultValue = AudioUnitDefaultValue;
+exports.VOICE_PLAYER_STATUS = VOICE_PLAYER_STATUS;
+exports.VoicePlayerProvider = VoicePlayerProvider;
+exports.useVoicePlayerContext = useVoicePlayerContext;
+//# sourceMappingURL=bundle-cbDU-09l.js.map

package/dist/cjs/chunks/bundle-cbDU-09l.js.map

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