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

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

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

package/cjs/chunks/bundle-MBuX_zXW.js

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

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

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

package/cjs/chunks/bundle-MeuNh9Q9.js

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

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

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

package/cjs/chunks/bundle-N1ipvkhN.js

@@ -1,6 +0,0 @@
-'use strict';
-
-var MENTION_USER_LABEL_CLASSNAME = 'sendbird-mention-user-label';
-
-exports.MENTION_USER_LABEL_CLASSNAME = MENTION_USER_LABEL_CLASSNAME;
-//# sourceMappingURL=bundle-N1ipvkhN.js.map

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

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

package/cjs/chunks/bundle-NYFm08XH.js

@@ -1,15 +0,0 @@
-'use strict';
-
-/* eslint-disable no-bitwise */
-/* eslint-disable eqeqeq */
-/* eslint-disable no-mixed-operators */
-// https://stackoverflow.com/a/2117523
-// used mainly for dom key generation
-var uuidv4 = function () { return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-    var r = Math.random() * 16 | 0;
-    var v = c === 'x' ? r : (r & 0x3 | 0x8);
-    return v.toString(16);
-}); };
-
-exports.uuidv4 = uuidv4;
-//# sourceMappingURL=bundle-NYFm08XH.js.map

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

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

package/cjs/chunks/bundle-Pe-j2f1D.js

@@ -1,8 +0,0 @@
-'use strict';
-
-var noop = function () { };
-var isAboutSame = function (a, b, px) { return Math.abs(a - b) <= px; };
-
-exports.isAboutSame = isAboutSame;
-exports.noop = noop;
-//# sourceMappingURL=bundle-Pe-j2f1D.js.map

package/cjs/chunks/bundle-Pe-j2f1D.js.map

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

package/cjs/chunks/bundle-QH7iLrPR.js

@@ -1,102 +0,0 @@
-'use strict';
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
-
-var extendStatics = function(d, b) {
-    extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-    return extendStatics(d, b);
-};
-
-function __extends(d, b) {
-    if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-
-exports.__assign = function() {
-    exports.__assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return exports.__assign.apply(this, arguments);
-};
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
-
-function __spreadArray(to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-exports.__awaiter = __awaiter;
-exports.__extends = __extends;
-exports.__generator = __generator;
-exports.__spreadArray = __spreadArray;
-//# sourceMappingURL=bundle-QH7iLrPR.js.map

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

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

package/cjs/chunks/bundle-SngxTjas.js

@@ -1,30 +0,0 @@
-'use strict';
-
-var copyToClipboard = function (text) {
-    // @ts-ignore: Unreachable code error
-    if (window.clipboardData && window.clipboardData.setData) {
-        // Internet Explorer-specific code path to prevent textarea being shown while dialog is visible.
-        // @ts-ignore: Unreachable code error
-        return window.clipboardData.setData('Text', text);
-    }
-    if (document.queryCommandSupported && document.queryCommandSupported('copy')) {
-        var textarea = document.createElement('textarea');
-        textarea.textContent = text;
-        textarea.style.position = 'fixed'; // Prevent scrolling to bottom of page in Microsoft Edge.
-        document.body.appendChild(textarea);
-        textarea.select();
-        try {
-            return document.execCommand('copy'); // Security exception may be thrown by some browsers.
-        }
-        catch (ex) {
-            return false;
-        }
-        finally {
-            document.body.removeChild(textarea);
-        }
-    }
-    return false;
-};
-
-exports.copyToClipboard = copyToClipboard;
-//# sourceMappingURL=bundle-SngxTjas.js.map

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

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

package/cjs/chunks/bundle-VoZZnYtF.js

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

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

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

package/cjs/chunks/bundle-XoWonC_b.js

@@ -1,128 +0,0 @@
-'use strict';
-
-var consts = require('./bundle-EVdeXpsD.js');
-var lame_all = require('../lame.all.js');
-
-// Thanks to https://codesandbox.io/s/media-recorder-api-downsampling-16k-mp3-encode-using-lame-js-forked-n1pblw
-function encodeMp3(arrayBuffer) {
-    var wav = lame_all.WavHeader.readHeader(new DataView(arrayBuffer));
-    var dataView = new Int16Array(arrayBuffer, wav.dataOffset, wav.dataLen / 2);
-    var mp3Encoder = new lame_all.Mp3Encoder(wav.channels, wav.sampleRate, 128);
-    var maxSamples = 1152;
-    var samplesLeft = (wav.channels === 1) ? dataView : new Int16Array(wav.dataLen / (2 * wav.channels));
-    var samplesRight = (wav.channels === 2) ? new Int16Array(wav.dataLen / (2 * wav.channels)) : undefined;
-    if (wav.channels > 1) {
-        for (var j = 0; j < samplesLeft.length; j++) {
-            samplesLeft[j] = dataView[j * 2];
-            samplesRight[j] = dataView[j * 2 + 1];
-        }
-    }
-    var dataBuffer = [];
-    var remaining = samplesLeft.length;
-    for (var i = 0; remaining >= maxSamples; i += maxSamples) {
-        var left = samplesLeft.subarray(i, i + maxSamples);
-        var right = void 0;
-        if (samplesRight) {
-            right = samplesRight.subarray(i, i + maxSamples);
-        }
-        var mp3buf = mp3Encoder.encodeBuffer(left, right);
-        dataBuffer.push(new Int8Array(mp3buf));
-        remaining -= maxSamples;
-    }
-    var mp3Lastbuf = mp3Encoder.flush();
-    dataBuffer.push(new Int8Array(mp3Lastbuf));
-    return dataBuffer;
-}
-// Convert audioFile to arrayBuffer, because Mp3Encoder requires a parameter of ArrayBuffer type
-function downsampleToWav(file, callback) {
-    // Browser compatibility
-    // https://caniuse.com/?search=AudioContext
-    var audioCtx = new AudioContext({ sampleRate: consts.VOICE_RECORDER_AUDIO_SAMPLE_RATE });
-    var fileReader = new FileReader();
-    fileReader.onload = function (ev) {
-        // Decode audio
-        audioCtx.decodeAudioData(ev.target.result, function (buffer) {
-            // this is where you down sample the audio, usually is 44100 samples per second
-            var usingWebkit = !window.OfflineAudioContext;
-            var offlineAudioCtx = new OfflineAudioContext(1, 16000 * buffer.duration, 16000);
-            var soundSource = offlineAudioCtx.createBufferSource();
-            soundSource.buffer = buffer;
-            soundSource.connect(offlineAudioCtx.destination);
-            var reader = new FileReader();
-            reader.onload = function () {
-                var renderCompleteHandler = function (evt) {
-                    var renderedBuffer = usingWebkit ? evt.renderedBuffer : evt;
-                    var buffer = bufferToWav(renderedBuffer, renderedBuffer.length);
-                    if (callback) {
-                        callback(buffer);
-                    }
-                };
-                if (usingWebkit) {
-                    offlineAudioCtx.oncomplete = renderCompleteHandler;
-                    offlineAudioCtx.startRendering();
-                }
-                else {
-                    offlineAudioCtx
-                        .startRendering()
-                        .then(renderCompleteHandler)
-                        // eslint-disable-next-line no-console
-                        .catch(function (err) { return console.warn(err); });
-                }
-            };
-            reader.readAsArrayBuffer(file);
-            soundSource.start(0);
-        });
-    };
-    fileReader.readAsArrayBuffer(file);
-}
-function bufferToWav(abuffer, len) {
-    var numOfChan = abuffer.numberOfChannels;
-    var length = len * numOfChan * 2 + 44;
-    var buffer = new ArrayBuffer(length);
-    var view = new DataView(buffer);
-    var channels = [];
-    var i = 0;
-    var sample;
-    var offset = 0;
-    var pos = 0;
-    // write WAVE header
-    setUint32(0x46464952); // "RIFF"
-    setUint32(length - 8); // file length - 8
-    setUint32(0x45564157); // "WAVE"
-    setUint32(0x20746d66); // "fmt " chunk
-    setUint32(16); // length = 16
-    setUint16(1); // PCM (uncompressed)
-    setUint16(numOfChan);
-    setUint32(abuffer.sampleRate);
-    setUint32(abuffer.sampleRate * 2 * numOfChan); // avg. bytes/sec
-    setUint16(numOfChan * 2); // block-align
-    setUint16(16); // 16-bit (hardcoded in this demo)
-    setUint32(0x61746164); // "data" - chunk
-    setUint32(length - pos - 4); // chunk length
-    // write interleaved data
-    for (i = 0; i < abuffer.numberOfChannels; i++)
-        channels.push(abuffer.getChannelData(i));
-    while (pos < length) {
-        for (i = 0; i < numOfChan; i++) {
-            // interleave channels
-            sample = Math.max(-1, Math.min(1, channels[i][offset])); // clamp
-            sample = (0.5 + sample < 0 ? sample * 32768 : sample * 32767) | 0; // scale to 16-bit signed int
-            view.setInt16(pos, sample, true); // write 16-bit sample
-            pos += 2;
-        }
-        offset++; // next source sample
-    }
-    return buffer;
-    function setUint16(data) {
-        view.setUint16(pos, data, true);
-        pos += 2;
-    }
-    function setUint32(data) {
-        view.setUint32(pos, data, true);
-        pos += 4;
-    }
-}
-
-exports.downsampleToWav = downsampleToWav;
-exports.encodeMp3 = encodeMp3;
-//# sourceMappingURL=bundle-XoWonC_b.js.map

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

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