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

package/Thread.js

@@ -0,0 +1,128 @@
+import React__default from 'react';
+import { ThreadProvider } from './Thread/context.js';
+import ThreadUI from './Thread/components/ThreadUI.js';
+import './chunks/bundle-2vDuq7rZ.js';
+import './chunks/bundle-ZpJZTfoV.js';
+import './chunks/bundle-pPXMJqsS.js';
+import './chunks/bundle-QjlA2FJF.js';
+import './chunks/bundle-2yC2lcsy.js';
+import './chunks/bundle-D_pLwnQ0.js';
+import './chunks/bundle-jZAA8To5.js';
+import './utils/message/getOutgoingMessageState.js';
+import './chunks/bundle-clvMvbED.js';
+import '@sendbird/chat/message';
+import './chunks/bundle-QgJ-QF2G.js';
+import './useSendbirdStateContext.js';
+import './withSendbird.js';
+import './Thread/context/types.js';
+import '@sendbird/chat';
+import './chunks/bundle-pn6NSL3O.js';
+import '@sendbird/chat/groupChannel';
+import './chunks/bundle-Uxbdznli.js';
+import './chunks/bundle-RmLRpAz9.js';
+import './chunks/bundle-P4MVV67N.js';
+import './chunks/bundle-LeSGRB3v.js';
+import './chunks/bundle-WNY8ys7l.js';
+import './chunks/bundle-el_ZuVfM.js';
+import './chunks/bundle-aH34IG5T.js';
+import './Thread/components/ParentMessageInfo.js';
+import './chunks/bundle-viJ5cbpO.js';
+import './chunks/bundle-u4FcOlD_.js';
+import 'react-dom';
+import './chunks/bundle-5B1lC0AK.js';
+import './chunks/bundle-le7uFwMX.js';
+import './ui/IconButton.js';
+import './ui/Button.js';
+import './ui/Icon.js';
+import './chunks/bundle-9gCVckwb.js';
+import './Thread/components/ParentMessageInfoItem.js';
+import './ui/ImageRenderer.js';
+import './ui/TextButton.js';
+import './chunks/bundle-Oh0p64yp.js';
+import './ui/EmojiReactions.js';
+import './ui/ReactionBadge.js';
+import './ui/ReactionButton.js';
+import './chunks/bundle-h5FVzAFt.js';
+import './ui/ContextMenu.js';
+import './ui/SortByRow.js';
+import './ui/BottomSheet.js';
+import './hooks/useModal.js';
+import './ui/UserListItem.js';
+import './chunks/bundle-01jpPkcx.js';
+import './chunks/bundle-bB65NrBo.js';
+import './ui/MutedAvatarOverlay.js';
+import './ui/Checkbox.js';
+import './ui/UserProfile.js';
+import './sendbirdSelectors.js';
+import './ui/Tooltip.js';
+import './ui/TooltipWrapper.js';
+import './Message/context.js';
+import './ui/VoiceMessageItemBody.js';
+import './ui/ProgressBar.js';
+import './VoicePlayer/useVoicePlayer.js';
+import './chunks/bundle-6SK2BcAv.js';
+import './VoiceRecorder/context.js';
+import './ui/PlaybackTime.js';
+import './ui/Loader.js';
+import './chunks/bundle-p0743TDx.js';
+import './chunks/bundle-b1oTo8nl.js';
+import './ui/MentionLabel.js';
+import './ui/LinkLabel.js';
+import './chunks/bundle-tAxBnRjT.js';
+import './chunks/bundle-3TDg04r-.js';
+import './chunks/bundle-dnb1LuEr.js';
+import './chunks/bundle-SCA97hXF.js';
+import './Channel/hooks/useInitialMessagesFetch.js';
+import './chunks/bundle-zoJ1TiRJ.js';
+import './Channel/components/SuggestedMentionList.js';
+import './chunks/bundle-aeBYYspY.js';
+import './ui/MessageItemMenu.js';
+import './chunks/bundle-be0-DpAW.js';
+import './ui/MessageItemReactionMenu.js';
+import './ui/MessageInput.js';
+import './chunks/bundle-rx40_uS_.js';
+import 'dompurify';
+import './chunks/bundle-UNImIpvz.js';
+import './chunks/bundle-Dc36wM2_.js';
+import './chunks/bundle-Z7mQGJRw.js';
+import './chunks/bundle-FjwGlAhe.js';
+import './Message/hooks/useDirtyGetMentions.js';
+import './Thread/components/ThreadHeader.js';
+import './Thread/components/ThreadList.js';
+import './Thread/components/ThreadListItem.js';
+import './ui/DateSeparator.js';
+import './chunks/bundle-2Uy-IVG_.js';
+import './chunks/bundle-MlGtQfZg.js';
+import './chunks/bundle-kFKvO5kE.js';
+import './ui/TextMessageItemBody.js';
+import './ui/OGMessageItemBody.js';
+import './ui/FileMessageItemBody.js';
+import './ui/ThumbnailMessageItemBody.js';
+import './chunks/bundle-OJLCWEjZ.js';
+import './ui/UnknownMessageItemBody.js';
+import 'date-fns';
+import './Thread/components/ThreadMessageInput.js';
+import './chunks/bundle-lsTPyhe8.js';
+import './VoiceRecorder/useVoiceRecorder.js';
+import './chunks/bundle-V9lKxPrR.js';
+import './Channel/hooks/useHandleUploadFiles.js';
+import './chunks/bundle-5UuDIaK_.js';
+import './ui/PlaceHolder.js';
+
+var Thread = function (props) {
+    var 
+    // props
+    className = props.className, 
+    // ThreadProviderProps
+    channelUrl = props.channelUrl, message = props.message, onHeaderActionClick = props.onHeaderActionClick, onMoveToParentMessage = props.onMoveToParentMessage, isMultipleFilesMessageEnabled = props.isMultipleFilesMessageEnabled, 
+    // onBeforeSend~~~Message
+    onBeforeSendUserMessage = props.onBeforeSendUserMessage, onBeforeSendFileMessage = props.onBeforeSendFileMessage, onBeforeSendVoiceMessage = props.onBeforeSendVoiceMessage, onBeforeSendMultipleFilesMessage = props.onBeforeSendMultipleFilesMessage, 
+    // ThreadUIProps
+    renderHeader = props.renderHeader, renderParentMessageInfo = props.renderParentMessageInfo, renderMessage = props.renderMessage, renderMessageInput = props.renderMessageInput, renderCustomSeparator = props.renderCustomSeparator, renderParentMessageInfoPlaceholder = props.renderParentMessageInfoPlaceholder, renderThreadListPlaceHolder = props.renderThreadListPlaceHolder, renderFileUploadIcon = props.renderFileUploadIcon, renderVoiceMessageIcon = props.renderVoiceMessageIcon, renderSendMessageIcon = props.renderSendMessageIcon;
+    return (React__default.createElement("div", { className: "sendbird-thread ".concat(className) },
+        React__default.createElement(ThreadProvider, { channelUrl: channelUrl, message: message, onHeaderActionClick: onHeaderActionClick, onMoveToParentMessage: onMoveToParentMessage, onBeforeSendUserMessage: onBeforeSendUserMessage, onBeforeSendFileMessage: onBeforeSendFileMessage, onBeforeSendVoiceMessage: onBeforeSendVoiceMessage, onBeforeSendMultipleFilesMessage: onBeforeSendMultipleFilesMessage, isMultipleFilesMessageEnabled: isMultipleFilesMessageEnabled },
+            React__default.createElement(ThreadUI, { renderHeader: renderHeader, renderParentMessageInfo: renderParentMessageInfo, renderMessage: renderMessage, renderMessageInput: renderMessageInput, renderCustomSeparator: renderCustomSeparator, renderParentMessageInfoPlaceholder: renderParentMessageInfoPlaceholder, renderThreadListPlaceHolder: renderThreadListPlaceHolder, renderFileUploadIcon: renderFileUploadIcon, renderVoiceMessageIcon: renderVoiceMessageIcon, renderSendMessageIcon: renderSendMessageIcon }))));
+};
+
+export { Thread as default };
+//# sourceMappingURL=Thread.js.map

package/Thread.js.map

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

package/VoicePlayer/context.js

@@ -0,0 +1,7 @@
+import 'react';
+export { a as ALL, b as VoicePlayerProvider, u as useVoicePlayerContext } from '../chunks/bundle-6SK2BcAv.js';
+import '../chunks/bundle-P4MVV67N.js';
+import '../useSendbirdStateContext.js';
+import '../chunks/bundle-QjlA2FJF.js';
+import '../withSendbird.js';
+//# sourceMappingURL=context.js.map

package/VoicePlayer/useVoicePlayer.js

@@ -0,0 +1,71 @@
+import { useState, useEffect } from 'react';
+import { u as useVoicePlayerContext, A as AudioUnitDefaultValue } from '../chunks/bundle-6SK2BcAv.js';
+import { e as VOICE_PLAYER_AUDIO_ID } from '../chunks/bundle-P4MVV67N.js';
+import { useVoiceRecorderContext } from '../VoiceRecorder/context.js';
+import '../chunks/bundle-QjlA2FJF.js';
+import '../useSendbirdStateContext.js';
+import '../withSendbird.js';
+import '../chunks/bundle-LeSGRB3v.js';
+import '../chunks/bundle-WNY8ys7l.js';
+import '../chunks/bundle-D_pLwnQ0.js';
+import '../chunks/bundle-u4FcOlD_.js';
+import 'react-dom';
+import '../chunks/bundle-5B1lC0AK.js';
+import '../chunks/bundle-le7uFwMX.js';
+import '../ui/IconButton.js';
+import '../ui/Button.js';
+import '../chunks/bundle-aH34IG5T.js';
+import '../ui/Icon.js';
+
+var generateGroupKey = function (channelUrl, key) {
+    if (channelUrl === void 0) { channelUrl = ''; }
+    if (key === void 0) { key = ''; }
+    return ("".concat(channelUrl, "-").concat(key));
+};
+
+var useVoicePlayer = function (_a) {
+    var _b;
+    var _c = _a.key, key = _c === void 0 ? '' : _c, _d = _a.channelUrl, channelUrl = _d === void 0 ? '' : _d, _e = _a.audioFile, audioFile = _e === void 0 ? null : _e, _f = _a.audioFileUrl, audioFileUrl = _f === void 0 ? '' : _f;
+    var groupKey = useState(generateGroupKey(channelUrl, key))[0];
+    var _g = useVoicePlayerContext(), play = _g.play, pause = _g.pause, stop = _g.stop, voicePlayerStore = _g.voicePlayerStore;
+    var isRecordable = useVoiceRecorderContext().isRecordable;
+    var currentAudioUnit = ((_b = voicePlayerStore === null || voicePlayerStore === void 0 ? void 0 : voicePlayerStore.audioStorage) === null || _b === void 0 ? void 0 : _b[groupKey]) || AudioUnitDefaultValue();
+    var playVoicePlayer = function () {
+        if (!isRecordable) {
+            play === null || play === void 0 ? void 0 : play({
+                groupKey: groupKey,
+                audioFile: audioFile,
+                audioFileUrl: audioFileUrl,
+            });
+        }
+    };
+    var pauseVoicePlayer = function () {
+        pause === null || pause === void 0 ? void 0 : pause(groupKey);
+    };
+    var stopVoicePlayer = function (text) {
+        if (text === void 0) { text = ''; }
+        stop === null || stop === void 0 ? void 0 : stop(text);
+    };
+    useEffect(function () {
+        return function () {
+            var _a;
+            if (audioFile || audioFileUrl) {
+                // Can't get the current AudioPlayer through the React hooks(useReducer or useState) in this scope
+                var voiceAudioPlayerElement = document.getElementById(VOICE_PLAYER_AUDIO_ID);
+                (_a = voiceAudioPlayerElement === null || voiceAudioPlayerElement === void 0 ? void 0 : voiceAudioPlayerElement.pause) === null || _a === void 0 ? void 0 : _a.call(voiceAudioPlayerElement);
+            }
+        };
+    }, []);
+    return ({
+        play: playVoicePlayer,
+        pause: pauseVoicePlayer,
+        stop: stopVoicePlayer,
+        playbackTime: currentAudioUnit.playbackTime * 1000,
+        duration: currentAudioUnit.duration * 1000,
+        // the unit of playbackTime and duration should be millisecond
+        playingStatus: currentAudioUnit.playingStatus,
+    });
+};
+
+export { useVoicePlayer };
+//# sourceMappingURL=useVoicePlayer.js.map

package/VoiceRecorder/context.js

@@ -0,0 +1,132 @@
+import React__default, { createContext, useState, useEffect, useCallback, useContext } from 'react';
+import { u as useLocalization } from '../chunks/bundle-LeSGRB3v.js';
+import { M as Modal } from '../chunks/bundle-u4FcOlD_.js';
+import { B as BROWSER_SUPPORT_MIME_TYPE_LIST, V as VOICE_RECORDER_AUDIO_BIT_RATE, a as VOICE_MESSAGE_FILE_NAME, b as VOICE_MESSAGE_MIME_TYPE } from '../chunks/bundle-P4MVV67N.js';
+import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
+import '../chunks/bundle-WNY8ys7l.js';
+import '../chunks/bundle-D_pLwnQ0.js';
+import 'react-dom';
+import '../chunks/bundle-5B1lC0AK.js';
+import '../chunks/bundle-le7uFwMX.js';
+import '../ui/IconButton.js';
+import '../chunks/bundle-QjlA2FJF.js';
+import '../ui/Button.js';
+import '../chunks/bundle-aH34IG5T.js';
+import '../ui/Icon.js';
+import '../withSendbird.js';
+
+var noop = function () { };
+var Context = createContext({
+    start: noop,
+    stop: noop,
+    isRecordable: false,
+});
+var VoiceRecorderProvider = function (props) {
+    var _a;
+    var children = props.children;
+    var config = useSendbirdStateContext().config;
+    var logger = config.logger, isVoiceMessageEnabled = config.isVoiceMessageEnabled;
+    var _b = useState(null), mediaRecorder = _b[0], setMediaRecorder = _b[1];
+    var _c = useState(false), isRecordable = _c[0], setIsRecordable = _c[1];
+    var _d = useState(false), permissionWarning = _d[0], setPermissionWarning = _d[1];
+    var stringSet = useLocalization().stringSet;
+    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);
+        }
+    };
+    var browserSupportMimeType = (_a = BROWSER_SUPPORT_MIME_TYPE_LIST.find(function (mimeType) { return MediaRecorder.isTypeSupported(mimeType); })) !== null && _a !== void 0 ? _a : '';
+    if (!browserSupportMimeType) {
+        logger.error('VoiceRecorder: Browser does not support mimeType', { mimmeTypes: BROWSER_SUPPORT_MIME_TYPE_LIST });
+    }
+    var _e = useState(null), webAudioUtils = _e[0], setWebAudioUtils = _e[1];
+    useEffect(function () {
+        if (isVoiceMessageEnabled && !webAudioUtils) {
+            import('../chunks/bundle-0QkkGO1-.js').then(function (data) {
+                setWebAudioUtils(data);
+            });
+        }
+    }, []);
+    var start = useCallback(function (eventHandler) {
+        var _a, _b;
+        if (isVoiceMessageEnabled && !webAudioUtils) {
+            logger.error('VoiceRecorder: Recording audio processor is being loaded.');
+            return;
+        }
+        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) {
+            logger.info('VoiceRecorder: Succeeded getting media stream.', stream);
+            setIsRecordable(true);
+            var mediaRecorder = new MediaRecorder(stream, {
+                mimeType: browserSupportMimeType,
+                audioBitsPerSecond: VOICE_RECORDER_AUDIO_BIT_RATE,
+            });
+            mediaRecorder.ondataavailable = function (e) {
+                var _a, _b, _c;
+                logger.info('VoiceRecorder: Succeeded getting an available data.', e.data);
+                var audioFile = new File([e.data], VOICE_MESSAGE_FILE_NAME, {
+                    lastModified: new Date().getTime(),
+                    type: VOICE_MESSAGE_MIME_TYPE,
+                });
+                webAudioUtils === null || webAudioUtils === void 0 ? void 0 : webAudioUtils.downsampleToWav(audioFile, function (buffer) {
+                    var mp3Buffer = webAudioUtils === null || webAudioUtils === void 0 ? void 0 : webAudioUtils.encodeMp3(buffer);
+                    var mp3blob = new Blob(mp3Buffer, { type: VOICE_MESSAGE_MIME_TYPE });
+                    var convertedAudioFile = new File([mp3blob], VOICE_MESSAGE_FILE_NAME, {
+                        lastModified: new Date().getTime(),
+                        type: VOICE_MESSAGE_MIME_TYPE,
+                    });
+                    eventHandler === null || eventHandler === void 0 ? void 0 : eventHandler.onRecordingEnded(convertedAudioFile);
+                    logger.info('VoiceRecorder: Succeeded converting audio file.', convertedAudioFile);
+                });
+                (_c = (_a = stream === null || stream === void 0 ? void 0 : stream.getAudioTracks) === null || _a === void 0 ? void 0 : (_b = _a.call(stream)).forEach) === null || _c === void 0 ? void 0 : _c.call(_b, function (track) { return track === null || track === void 0 ? void 0 : track.stop(); });
+                setIsRecordable(false);
+            };
+            mediaRecorder === null || mediaRecorder === void 0 ? void 0 : mediaRecorder.start();
+            setMediaRecorder(mediaRecorder);
+            eventHandler === null || eventHandler === void 0 ? void 0 : eventHandler.onRecordingStarted();
+        }).catch(function (err) {
+            logger.error('VoiceRecorder: Failed getting media stream.', err);
+            setMediaRecorder(null);
+        });
+    }, [mediaRecorder, webAudioUtils]);
+    var stop = 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.createElement(Context.Provider, { value: {
+            start: start,
+            stop: stop,
+            isRecordable: isRecordable,
+        } },
+        children,
+        permissionWarning && (React__default.createElement(Modal, { hideFooter: true, onCancel: function () { return setPermissionWarning(false); } },
+            React__default.createElement(React__default.Fragment, null, stringSet.VOICE_RECORDING_PERMISSION_DENIED)))));
+};
+var useVoiceRecorderContext = function () { return useContext(Context); };
+var index = {
+    VoiceRecorderProvider: VoiceRecorderProvider,
+    useVoiceRecorderContext: useVoiceRecorderContext,
+};
+
+export { VoiceRecorderProvider, index as default, useVoiceRecorderContext };
+//# sourceMappingURL=context.js.map

package/VoiceRecorder/useVoiceRecorder.js

@@ -0,0 +1,108 @@
+import { useState, useEffect, useCallback } from 'react';
+import { useVoiceRecorderContext } from './context.js';
+import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
+import '../chunks/bundle-LeSGRB3v.js';
+import '../chunks/bundle-WNY8ys7l.js';
+import '../chunks/bundle-D_pLwnQ0.js';
+import '../chunks/bundle-u4FcOlD_.js';
+import 'react-dom';
+import '../chunks/bundle-5B1lC0AK.js';
+import '../chunks/bundle-le7uFwMX.js';
+import '../ui/IconButton.js';
+import '../chunks/bundle-QjlA2FJF.js';
+import '../ui/Button.js';
+import '../chunks/bundle-aH34IG5T.js';
+import '../ui/Icon.js';
+import '../chunks/bundle-P4MVV67N.js';
+import '../withSendbird.js';
+
+// export interface UseVoiceRecorderProps extends VoiceRecorderEventHandler {
+//   /**
+//    * onRecordingStarted
+//    * onRecordingEnded
+//    */
+// }
+/* eslint-disable no-redeclare */
+var VoiceRecorderStatus = {
+    PREPARING: 'PREPARING',
+    READY_TO_RECORD: 'READY_TO_RECORD',
+    RECORDING: 'RECORDING',
+    COMPLETED: 'COMPLETED',
+};
+var noop = function () { };
+var useVoiceRecorder = function (_a) {
+    var _b = _a.onRecordingStarted, onRecordingStarted = _b === void 0 ? noop : _b, _c = _a.onRecordingEnded, onRecordingEnded = _c === void 0 ? noop : _c;
+    var config = useSendbirdStateContext().config;
+    var voiceRecord = config.voiceRecord;
+    var maxRecordingTime = voiceRecord.maxRecordingTime;
+    var voiceRecorder = useVoiceRecorderContext();
+    var isRecordable = voiceRecorder.isRecordable;
+    var _d = useState(null), recordedFile = _d[0], setRecordedFile = _d[1];
+    var _e = useState(VoiceRecorderStatus.PREPARING), recordingStatus = _e[0], setRecordingStatus = _e[1];
+    useEffect(function () {
+        if (isRecordable && recordingStatus === VoiceRecorderStatus.PREPARING) {
+            setRecordingStatus(VoiceRecorderStatus.READY_TO_RECORD);
+        }
+    }, [isRecordable]);
+    var start = useCallback(function () {
+        voiceRecorder === null || voiceRecorder === void 0 ? void 0 : voiceRecorder.start({
+            onRecordingStarted: function () {
+                setRecordingStatus(VoiceRecorderStatus.RECORDING);
+                onRecordingStarted();
+                startTimer();
+            },
+            onRecordingEnded: function (audioFile) {
+                setRecordingStatus(VoiceRecorderStatus.COMPLETED);
+                onRecordingEnded(audioFile);
+                setRecordedFile(audioFile);
+                stopTimer();
+            },
+        });
+    }, [onRecordingStarted, onRecordingEnded]);
+    var stop = useCallback(function () {
+        voiceRecorder === null || voiceRecorder === void 0 ? void 0 : voiceRecorder.stop();
+        stopTimer();
+    }, [voiceRecorder]);
+    var cancel = useCallback(function () {
+        stop();
+        setRecordedFile(null);
+    }, [voiceRecorder]);
+    // Timer
+    var _f = useState(0), recordingTime = _f[0], setRecordingTime = _f[1];
+    var timer = null;
+    function startTimer() {
+        stopTimer();
+        setRecordingTime(0);
+        var interval = setInterval(function () {
+            setRecordingTime(function (prevTime) {
+                var newTime = prevTime + 100;
+                if (newTime > maxRecordingTime) {
+                    stopTimer();
+                }
+                return newTime;
+            });
+        }, 100);
+        timer = interval;
+    }
+    function stopTimer() {
+        clearInterval(timer);
+        timer = null;
+    }
+    useEffect(function () {
+        if (recordingTime > maxRecordingTime) {
+            stop();
+        }
+    }, [recordingTime, maxRecordingTime, stop]);
+    return ({
+        start: start,
+        stop: stop,
+        cancel: cancel,
+        recordingStatus: recordingStatus,
+        recordingTime: recordingTime,
+        recordedFile: recordedFile,
+        recordingLimit: maxRecordingTime,
+    });
+};
+
+export { VoiceRecorderStatus, useVoiceRecorder };
+//# sourceMappingURL=useVoiceRecorder.js.map

package/chunks/bundle-01jpPkcx.js

@@ -0,0 +1,70 @@
+import { a as __spreadArray } from './bundle-QjlA2FJF.js';
+import React__default from 'react';
+import ImageRenderer from '../ui/ImageRenderer.js';
+import { u as uuidv4 } from './bundle-Uxbdznli.js';
+import { p as pxToNumber } from './bundle-bB65NrBo.js';
+import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
+
+var AvatarDefault = function (props) {
+    var width = props.width, height = props.height, text = props.text;
+    var iconWidth = pxToNumber(width);
+    var iconHeight = pxToNumber(height);
+    if (typeof iconWidth === 'number' && !Number.isNaN(iconWidth)) {
+        iconWidth *= 0.575;
+    }
+    if (typeof iconHeight === 'number' && !Number.isNaN(iconHeight)) {
+        iconHeight *= 0.575;
+    }
+    return (React__default.createElement("div", { className: "sendbird-avatar-img--default ".concat(text ? 'text' : ''), style: { width: width, height: height } }, text
+        ? React__default.createElement("div", { className: 'sendbird-avatar-text' }, text)
+        : React__default.createElement(Icon, { type: IconTypes.USER, fillColor: IconColors.CONTENT, width: iconWidth, height: iconHeight })));
+};
+
+var imageRendererClassName = 'sendbird-avatar-img';
+var AvatarInner = function (_a) {
+    var _b = _a.src, src = _b === void 0 ? '' : _b, _c = _a.alt, alt = _c === void 0 ? '' : _c, height = _a.height, width = _a.width, customDefaultComponent = _a.customDefaultComponent;
+    var defaultComponent = function () { return customDefaultComponent
+        ? customDefaultComponent({ width: width, height: height })
+        : React__default.createElement(AvatarDefault, { width: width, height: height }); };
+    if (typeof src === 'string') {
+        return (React__default.createElement(ImageRenderer, { className: imageRendererClassName, url: src, height: height, width: width, alt: alt, defaultComponent: defaultComponent }));
+    }
+    if (src && src.length) {
+        if (src.length === 1) {
+            return (React__default.createElement(ImageRenderer, { className: imageRendererClassName, url: src[0], height: height, width: width, alt: alt, defaultComponent: defaultComponent }));
+        }
+        if (src.length === 2) {
+            return (React__default.createElement("div", { className: "sendbird-avatar--inner__two-child" },
+                React__default.createElement(ImageRenderer, { className: imageRendererClassName, url: src[0], height: height, width: width, alt: alt, defaultComponent: defaultComponent }),
+                React__default.createElement(ImageRenderer, { className: imageRendererClassName, url: src[1], height: height, width: width, alt: alt, defaultComponent: defaultComponent })));
+        }
+        if (src.length === 3) {
+            return (React__default.createElement(React__default.Fragment, null,
+                React__default.createElement("div", { className: "sendbird-avatar--inner__three-child--upper" },
+                    React__default.createElement(ImageRenderer, { className: imageRendererClassName, url: src[0], height: height, width: width, alt: alt, defaultComponent: defaultComponent })),
+                React__default.createElement("div", { className: "sendbird-avatar--inner__three-child--lower" },
+                    React__default.createElement(ImageRenderer, { className: imageRendererClassName, url: src[1], height: height, width: width, alt: alt, defaultComponent: defaultComponent }),
+                    React__default.createElement(ImageRenderer, { className: imageRendererClassName, url: src[2], height: height, width: width, alt: alt, defaultComponent: defaultComponent }))));
+        }
+        return (React__default.createElement("div", { className: "sendbird-avatar--inner__four-child" }, src.slice(0, 4)
+            .map(function (i) { return (React__default.createElement(ImageRenderer, { className: imageRendererClassName, url: i, height: height, width: width, alt: alt, key: uuidv4(), defaultComponent: defaultComponent })); })));
+    }
+    // default img
+    return (React__default.createElement(ImageRenderer, { className: imageRendererClassName, url: "", height: height, width: width, alt: alt, defaultComponent: defaultComponent }));
+};
+function Avatar(_a, ref) {
+    var _b = _a.className, className = _b === void 0 ? '' : _b, _c = _a.src, src = _c === void 0 ? '' : _c, _d = _a.alt, alt = _d === void 0 ? '' : _d, _e = _a.width, width = _e === void 0 ? '56px' : _e, _f = _a.height, height = _f === void 0 ? '56px' : _f, _g = _a.zIndex, zIndex = _g === void 0 ? 0 : _g, _h = _a.left, left = _h === void 0 ? '' : _h, onClick = _a.onClick, customDefaultComponent = _a.customDefaultComponent;
+    return (React__default.createElement("div", { className: __spreadArray(__spreadArray([], (Array.isArray(className) ? className : [className]), true), [
+            'sendbird-avatar',
+        ], false).join(' '), role: "button", ref: ref, style: {
+            height: height,
+            width: width,
+            zIndex: zIndex,
+            left: left,
+        }, onClick: onClick, onKeyDown: onClick, tabIndex: 0 },
+        React__default.createElement(AvatarInner, { src: src, width: width, height: height, alt: alt, customDefaultComponent: customDefaultComponent })));
+}
+var Avatar$1 = React__default.forwardRef(Avatar);
+
+export { Avatar$1 as A, AvatarDefault as a, AvatarInner as b };
+//# sourceMappingURL=bundle-01jpPkcx.js.map

package/chunks/bundle-01jpPkcx.js.map

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

package/chunks/bundle-0QkkGO1-.js

@@ -0,0 +1,125 @@
+import { d as VOICE_RECORDER_AUDIO_SAMPLE_RATE } from './bundle-P4MVV67N.js';
+import { WavHeader as ut, Mp3Encoder as ht } from '../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 = ut.readHeader(new DataView(arrayBuffer));
+    var dataView = new Int16Array(arrayBuffer, wav.dataOffset, wav.dataLen / 2);
+    var mp3Encoder = new ht(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: 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;
+    }
+}
+
+export { downsampleToWav, encodeMp3 };
+//# sourceMappingURL=bundle-0QkkGO1-.js.map

package/chunks/bundle-0QkkGO1-.js.map

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