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

package/cjs/chunks/bundle-PKJPiCJF.js

@@ -0,0 +1,224 @@
+'use strict';
+
+var React = require('react');
+var pubSub_topics = require('./bundle-P1tJL1VF.js');
+var utils = require('./bundle-PLzI4mgo.js');
+var index = require('./bundle-Epp2z49V.js');
+var utils_message_getOutgoingMessageState = require('../utils/message/getOutgoingMessageState.js');
+
+var getNicknamesMapFromMembers = function (members) {
+    if (members === void 0) { members = []; }
+    var nicknamesMap = new Map();
+    for (var memberIndex = 0; memberIndex < members.length; memberIndex += 1) {
+        var _a = members[memberIndex], userId = _a.userId, nickname = _a.nickname;
+        nicknamesMap.set(userId, nickname);
+    }
+    return nicknamesMap;
+};
+var getParentMessageFrom = function (message) {
+    if (!message) {
+        return null;
+    }
+    if (isParentMessage(message)) {
+        return message;
+    }
+    if (isThreadMessage(message)) {
+        return (message === null || message === void 0 ? void 0 : message.parentMessage) || null;
+    }
+    return null;
+};
+var isParentMessage = function (message) {
+    return ((message === null || message === void 0 ? void 0 : message.parentMessage) === null
+        && typeof (message === null || message === void 0 ? void 0 : message.parentMessageId) === 'number'
+        && !(message === null || message === void 0 ? void 0 : message.parentMessageId));
+};
+var isThreadMessage = function (message) {
+    return ((message === null || message === void 0 ? void 0 : message.parentMessage) !== null
+        && typeof (message === null || message === void 0 ? void 0 : message.parentMessageId) === 'number'
+        && (message === null || message === void 0 ? void 0 : message.parentMessageId) > 0
+        && (message === null || message === void 0 ? void 0 : message.threadInfo) === null);
+};
+var isAboutSame = function (a, b, px) { return (Math.abs(a - b) <= px); };
+var isEmpty = function (val) { return (val === null || val === undefined); };
+// Some Ids return string and number inconsistently
+// only use to comapre IDs
+function compareIds(a, b) {
+    if (isEmpty(a) || isEmpty(b)) {
+        return false;
+    }
+    var aString = a.toString();
+    var bString = b.toString();
+    return aString === bString;
+}
+var getMessageCreatedAt = function (message) { return index.format(message.createdAt, 'p'); };
+var isReadMessage = function (channel, message) { return (utils_message_getOutgoingMessageState.getOutgoingMessageState(channel, message) === utils_message_getOutgoingMessageState.OutgoingMessageStates.READ); };
+var isSameGroup = function (message, comparingMessage, currentChannel) {
+    var _a, _b, _c, _d;
+    if (!(message
+        && comparingMessage
+        && message.messageType
+        && message.messageType !== 'admin'
+        && comparingMessage.messageType
+        && (comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.messageType) !== 'admin'
+        && (message === null || message === void 0 ? void 0 : message.sender)
+        && (comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.sender)
+        && (message === null || message === void 0 ? void 0 : message.createdAt)
+        && (comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.createdAt)
+        && ((_a = message === null || message === void 0 ? void 0 : message.sender) === null || _a === void 0 ? void 0 : _a.userId)
+        && ((_b = comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.sender) === null || _b === void 0 ? void 0 : _b.userId))) {
+        return false;
+    }
+    return ((message === null || message === void 0 ? void 0 : message.sendingStatus) === (comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.sendingStatus)
+        && ((_c = message === null || message === void 0 ? void 0 : message.sender) === null || _c === void 0 ? void 0 : _c.userId) === ((_d = comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.sender) === null || _d === void 0 ? void 0 : _d.userId)
+        && getMessageCreatedAt(message) === getMessageCreatedAt(comparingMessage)
+        && isReadMessage(currentChannel, message) === isReadMessage(currentChannel, comparingMessage));
+};
+var compareMessagesForGrouping = function (prevMessage, currMessage, nextMessage, currentChannel, replyType) {
+    if (replyType === 'THREAD' && (currMessage === null || currMessage === void 0 ? void 0 : currMessage.threadInfo)) {
+        return [false, false];
+    }
+    var sendingStatus = (currMessage === null || currMessage === void 0 ? void 0 : currMessage.sendingStatus) || '';
+    var isAcceptable = sendingStatus !== 'pending' && sendingStatus !== 'failed';
+    return [
+        isSameGroup(prevMessage, currMessage, currentChannel) && isAcceptable,
+        isSameGroup(currMessage, nextMessage, currentChannel) && isAcceptable,
+    ];
+};
+var scrollIntoLast = function (intialTry) {
+    if (intialTry === void 0) { intialTry = 0; }
+    var MAX_TRIES = 10;
+    var currentTry = intialTry;
+    if (currentTry > MAX_TRIES) {
+        return;
+    }
+    try {
+        var scrollDOM = document.querySelector('.sendbird-thread-ui--scroll');
+        // eslint-disable-next-line no-multi-assign
+        scrollDOM.scrollTop = scrollDOM.scrollHeight;
+    }
+    catch (error) {
+        setTimeout(function () {
+            scrollIntoLast(currentTry + 1);
+        }, 500 * currentTry);
+    }
+};
+
+/**
+ * pubSub is used instead of messagesDispatcher to avoid redundantly calling
+ * because this useSendMultipleFilesMessage is used in the Channel and Thread both
+ */
+var useSendMultipleFilesMessage = function (_a, _b) {
+    var currentChannel = _a.currentChannel, onBeforeSendMultipleFilesMessage = _a.onBeforeSendMultipleFilesMessage, publishingModules = _a.publishingModules;
+    var logger = _b.logger, pubSub = _b.pubSub, scrollRef = _b.scrollRef;
+    var sendMessage = React.useCallback(function (files, quoteMessage) {
+        return new Promise(function (resolve, reject) {
+            if (!currentChannel) {
+                logger.warning('Channel: Sending MFm failed, because currentChannel is null.', { currentChannel: currentChannel });
+                reject();
+            }
+            if (files.length <= 1) {
+                logger.warning('Channel: Sending MFM failed, because there are no multiple files.', { files: files });
+                reject();
+            }
+            var messageParams = {
+                fileInfoList: files.map(function (file) { return ({
+                    file: file,
+                    fileName: file.name,
+                    fileSize: file.size,
+                    mimeType: file.type,
+                }); }),
+            };
+            if (quoteMessage) {
+                messageParams.isReplyToChannel = true;
+                messageParams.parentMessageId = quoteMessage.messageId;
+            }
+            if (typeof onBeforeSendMultipleFilesMessage === 'function') {
+                messageParams = onBeforeSendMultipleFilesMessage(files, quoteMessage);
+            }
+            logger.info('Channel: Start sending MFM', { messageParams: messageParams });
+            try {
+                currentChannel.sendMultipleFilesMessage(messageParams)
+                    .onFileUploaded(function (requestId, index, uploadableFileInfo, error) {
+                    logger.info('Channel: onFileUploaded during sending MFM', {
+                        requestId: requestId,
+                        index: index,
+                        error: error,
+                        uploadableFileInfo: uploadableFileInfo,
+                    });
+                    pubSub.publish(pubSub_topics.pubSubTopics.ON_FILE_INFO_UPLOADED, {
+                        response: {
+                            channelUrl: currentChannel.url,
+                            requestId: requestId,
+                            index: index,
+                            uploadableFileInfo: uploadableFileInfo,
+                            error: error,
+                        },
+                        publishingModules: publishingModules,
+                    });
+                })
+                    .onPending(function (pendingMessage) {
+                    logger.info('Channel: in progress of sending MFM', { pendingMessage: pendingMessage, fileInfoList: messageParams.fileInfoList });
+                    pubSub.publish(pubSub_topics.pubSubTopics.SEND_MESSAGE_START, {
+                        message: pendingMessage,
+                        channel: currentChannel,
+                        publishingModules: publishingModules,
+                    });
+                    // We need this delay because rendering MFM takes time due to large image files.
+                    setTimeout(function () {
+                        if (scrollRef && pubSub_topics.shouldPubSubPublishToChannel(publishingModules)) {
+                            utils.scrollIntoLast(0, scrollRef);
+                        }
+                        if (pubSub_topics.shouldPubSubPublishToThread(publishingModules)) {
+                            scrollIntoLast(0);
+                        }
+                    }, 100);
+                })
+                    .onFailed(function (error, failedMessage) {
+                    logger.error('Channel: Sending MFM failed.', { error: error, failedMessage: failedMessage });
+                    pubSub.publish(pubSub_topics.pubSubTopics.SEND_MESSAGE_FAILED, {
+                        channel: currentChannel,
+                        message: failedMessage,
+                        publishingModules: publishingModules,
+                    });
+                    reject(error);
+                })
+                    .onSucceeded(function (succeededMessage) {
+                    logger.info('Channel: Sending voice message success!', { succeededMessage: succeededMessage });
+                    pubSub.publish(pubSub_topics.pubSubTopics.SEND_FILE_MESSAGE, {
+                        channel: currentChannel,
+                        message: succeededMessage,
+                        publishingModules: publishingModules,
+                    });
+                    // We need this delay because rendering MFM takes time due to large image files.
+                    setTimeout(function () {
+                        if (scrollRef && pubSub_topics.shouldPubSubPublishToChannel(publishingModules)) {
+                            utils.scrollIntoLast(0, scrollRef);
+                        }
+                        if (pubSub_topics.shouldPubSubPublishToThread(publishingModules)) {
+                            scrollIntoLast(0);
+                        }
+                    }, 100);
+                    resolve(succeededMessage);
+                });
+            }
+            catch (error) {
+                logger.error('Channel: Sending MFM failed.', { error: error });
+                reject(error);
+            }
+        });
+    }, [
+        currentChannel,
+        onBeforeSendMultipleFilesMessage,
+        publishingModules,
+    ]);
+    return [sendMessage];
+};
+
+exports.compareIds = compareIds;
+exports.compareMessagesForGrouping = compareMessagesForGrouping;
+exports.getNicknamesMapFromMembers = getNicknamesMapFromMembers;
+exports.getParentMessageFrom = getParentMessageFrom;
+exports.isAboutSame = isAboutSame;
+exports.scrollIntoLast = scrollIntoLast;
+exports.useSendMultipleFilesMessage = useSendMultipleFilesMessage;
+//# sourceMappingURL=bundle-PKJPiCJF.js.map

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

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

package/cjs/chunks/bundle-PLzI4mgo.js

@@ -0,0 +1,159 @@
+'use strict';
+
+var _tslib = require('./bundle-crXcinmk.js');
+var index$1 = require('./bundle-Epp2z49V.js');
+var index = require('./bundle-rXNfPqQR.js');
+var message = require('@sendbird/chat/message');
+
+var scrollToRenderedMessage = function (scrollRef, initialTimeStamp, setIsScrolled) {
+    var _a;
+    try {
+        var container = scrollRef.current;
+        // scroll into the message with initialTimeStamp
+        var element = (_a = container.querySelectorAll("[data-sb-created-at=\"".concat(initialTimeStamp, "\"]"))) === null || _a === void 0 ? void 0 : _a[0];
+        if (element instanceof HTMLElement) {
+            // Set the scroll position of the container to bring the element to the top
+            container.scrollTop = element.offsetTop;
+        }
+    }
+    catch (_b) {
+        // do nothing
+    }
+    finally {
+        setIsScrolled === null || setIsScrolled === void 0 ? void 0 : setIsScrolled(true);
+    }
+};
+/* eslint-disable default-param-last */
+var scrollIntoLast = function (initialTry, scrollRef, setIsScrolled) {
+    if (initialTry === void 0) { initialTry = 0; }
+    var MAX_TRIES = 10;
+    var currentTry = initialTry;
+    if (currentTry > MAX_TRIES) {
+        setIsScrolled === null || setIsScrolled === void 0 ? void 0 : setIsScrolled(true);
+        return;
+    }
+    try {
+        var scrollDOM = (scrollRef === null || scrollRef === void 0 ? void 0 : scrollRef.current) || document.querySelector('.sendbird-conversation__messages-padding');
+        scrollDOM.scrollTop = scrollDOM.scrollHeight;
+        setIsScrolled === null || setIsScrolled === void 0 ? void 0 : setIsScrolled(true);
+    }
+    catch (error) {
+        setTimeout(function () {
+            scrollIntoLast(currentTry + 1, scrollRef, setIsScrolled);
+        }, 500 * currentTry);
+    }
+};
+var isOperator = function (groupChannel) {
+    var myRole = groupChannel === null || groupChannel === void 0 ? void 0 : groupChannel.myRole;
+    return myRole === 'operator';
+};
+var isDisabledBecauseFrozen = function (groupChannel) {
+    var isFrozen = groupChannel === null || groupChannel === void 0 ? void 0 : groupChannel.isFrozen;
+    return isFrozen && !isOperator(groupChannel);
+};
+var isDisabledBecauseMuted = function (groupChannel) {
+    var myMutedState = groupChannel === null || groupChannel === void 0 ? void 0 : groupChannel.myMutedState;
+    return myMutedState === 'muted';
+};
+var getAllEmojisMapFromEmojiContainer = function (emojiContainer) {
+    var _a = emojiContainer.emojiCategories, emojiCategories = _a === void 0 ? [] : _a;
+    var allEmojisMap = new Map();
+    for (var categoryIndex = 0; categoryIndex < emojiCategories.length; categoryIndex += 1) {
+        var emojis = emojiCategories[categoryIndex].emojis;
+        for (var emojiIndex = 0; emojiIndex < emojis.length; emojiIndex += 1) {
+            var _b = emojis[emojiIndex], key = _b.key, url = _b.url;
+            allEmojisMap.set(key, url);
+        }
+    }
+    return allEmojisMap;
+};
+var getNicknamesMapFromMembers = function (members) {
+    if (members === void 0) { members = []; }
+    var nicknamesMap = new Map();
+    for (var memberIndex = 0; memberIndex < members.length; memberIndex += 1) {
+        var _a = members[memberIndex], userId = _a.userId, nickname = _a.nickname;
+        nicknamesMap.set(userId, nickname);
+    }
+    return nicknamesMap;
+};
+var getUniqueListBy = function (arr, key) {
+    var entries = arr.map(function (item) { return [item[key], item]; });
+    return Array.from(new Map(entries).values());
+};
+var getUniqueListByMessageId = function (arr) {
+    return getUniqueListBy(arr, 'messageId');
+};
+var sortByCreatedAt = function (messages) {
+    return messages.sort(function (a, b) { return a.createdAt - b.createdAt; });
+};
+var mergeAndSortMessages = function (oldMessages, newMessages) {
+    var lastOldMessage = oldMessages[oldMessages.length - 1];
+    var firstNewMessage = newMessages[0];
+    // If the last message of oldMessages is older than the first message of newMessages,
+    // then we can safely append newMessages to oldMessages.
+    if ((lastOldMessage === null || lastOldMessage === void 0 ? void 0 : lastOldMessage.createdAt) < (firstNewMessage === null || firstNewMessage === void 0 ? void 0 : firstNewMessage.createdAt)) {
+        return _tslib.__spreadArray(_tslib.__spreadArray([], oldMessages, true), newMessages, true);
+    }
+    // todo: optimize this
+    // If the last message of oldMessages is newer than the first message of newMessages,
+    // then we need to merge the two arrays and sort them by createdAt.
+    var mergedMessages = _tslib.__spreadArray(_tslib.__spreadArray([], oldMessages, true), newMessages, true);
+    var unique = getUniqueListByMessageId(mergedMessages);
+    return sortByCreatedAt(unique);
+};
+var getMessageCreatedAt = function (message) { return index$1.format(message.createdAt, 'p'); };
+var isSameGroup = function (message, comparingMessage, currentChannel) {
+    var _a, _b;
+    if (!(message
+        && comparingMessage
+        && message.messageType
+        && message.messageType !== 'admin'
+        && comparingMessage.messageType
+        && (comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.messageType) !== 'admin'
+        && 'sender' in message
+        && 'sender' in comparingMessage
+        && message.createdAt
+        && comparingMessage.createdAt
+        && message.sender.userId
+        && comparingMessage.sender.userId)) {
+        return false;
+    }
+    return ((message === null || message === void 0 ? void 0 : message.sendingStatus) === (comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.sendingStatus)
+        && ((_a = message === null || message === void 0 ? void 0 : message.sender) === null || _a === void 0 ? void 0 : _a.userId) === ((_b = comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.sender) === null || _b === void 0 ? void 0 : _b.userId)
+        && getMessageCreatedAt(message) === getMessageCreatedAt(comparingMessage)
+        && index.isReadMessage(currentChannel, message) === index.isReadMessage(currentChannel, comparingMessage));
+};
+var passUnsuccessfullMessages = function (allMessages, newMessage) {
+    if ('sendingStatus' in newMessage
+        && (newMessage.sendingStatus === message.SendingStatus.SUCCEEDED || newMessage.sendingStatus === message.SendingStatus.PENDING)) {
+        var lastIndexOfSucceededMessage = allMessages
+            .map(function (message$1) {
+            if ('sendingStatus' in message$1 && message$1.sendingStatus)
+                return message$1.sendingStatus;
+            return message$1.isAdminMessage() ? message.SendingStatus.SUCCEEDED : null;
+        })
+            .lastIndexOf(message.SendingStatus.SUCCEEDED);
+        if (lastIndexOfSucceededMessage + 1 < allMessages.length) {
+            var messages = _tslib.__spreadArray([], allMessages, true);
+            messages.splice(lastIndexOfSucceededMessage + 1, 0, newMessage);
+            return messages;
+        }
+    }
+    return _tslib.__spreadArray(_tslib.__spreadArray([], allMessages, true), [newMessage], false);
+};
+var isAboutSame = function (a, b, px) {
+    return Math.abs(a - b) <= px;
+};
+
+exports.getAllEmojisMapFromEmojiContainer = getAllEmojisMapFromEmojiContainer;
+exports.getNicknamesMapFromMembers = getNicknamesMapFromMembers;
+exports.isAboutSame = isAboutSame;
+exports.isDisabledBecauseFrozen = isDisabledBecauseFrozen;
+exports.isDisabledBecauseMuted = isDisabledBecauseMuted;
+exports.isOperator = isOperator;
+exports.isSameGroup = isSameGroup;
+exports.mergeAndSortMessages = mergeAndSortMessages;
+exports.passUnsuccessfullMessages = passUnsuccessfullMessages;
+exports.scrollIntoLast = scrollIntoLast;
+exports.scrollToRenderedMessage = scrollToRenderedMessage;
+//# sourceMappingURL=bundle-PLzI4mgo.js.map

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

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

package/cjs/chunks/bundle-P__OxDCf.js

@@ -0,0 +1,236 @@
+'use strict';
+
+var React = require('react');
+var _tslib = require('./bundle-crXcinmk.js');
+var consts = require('./bundle-noiyvZaq.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-P__OxDCf.js.map

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

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