stream-chat-react 13.14.1 → 14.0.0-beta.1

package/dist/components/MediaRecorder/classes/AmplitudeRecorder.js

@@ -1,85 +0,0 @@
-import { BehaviorSubject } from '../observable/BehaviorSubject';
-import { Subject } from '../observable/Subject';
-import { mergeDeepUndefined } from '../../../utils/mergeDeep';
-const MAX_FREQUENCY_AMPLITUDE = 255;
-const logError = (e) => e && console.error('[AMPLITUDE RECORDER ERROR]', e);
-const rootMeanSquare = (values) => Math.sqrt(values.reduce((acc, val) => acc + Math.pow(val, 2), 0) / values.length);
-export const DEFAULT_AMPLITUDE_RECORDER_CONFIG = {
-    analyserConfig: {
-        fftSize: 32,
-        maxDecibels: 0,
-        minDecibels: -100,
-    },
-    sampleCount: 100,
-    samplingFrequencyMs: 60,
-};
-export var AmplitudeRecorderState;
-(function (AmplitudeRecorderState) {
-    AmplitudeRecorderState["CLOSED"] = "closed";
-    AmplitudeRecorderState["RECORDING"] = "recording";
-    AmplitudeRecorderState["STOPPED"] = "stopped";
-})(AmplitudeRecorderState || (AmplitudeRecorderState = {}));
-export class AmplitudeRecorder {
-    constructor({ config, stream }) {
-        this.amplitudes = new BehaviorSubject([]);
-        this.state = new BehaviorSubject(undefined);
-        this.error = new Subject();
-        this.start = () => {
-            if (this.state.value === AmplitudeRecorderState.CLOSED)
-                return;
-            if (!this.stream) {
-                throw new Error('Missing MediaStream instance. Cannot to start amplitude recording');
-            }
-            if (this.state.value === AmplitudeRecorderState.RECORDING)
-                this.stop();
-            if (!this.analyserNode) {
-                if (!this.stream)
-                    return;
-                this.init();
-            }
-            this.state.next(AmplitudeRecorderState.RECORDING);
-            this.amplitudeSamplingInterval = setInterval(() => {
-                if (!(this.analyserNode && this.state.value === AmplitudeRecorderState.RECORDING))
-                    return;
-                const frequencyBins = new Uint8Array(this.analyserNode.frequencyBinCount);
-                try {
-                    this.analyserNode.getByteFrequencyData(frequencyBins);
-                }
-                catch (e) {
-                    logError(e);
-                    this.error.next(e);
-                    return;
-                }
-                const normalizedSignalStrength = rootMeanSquare(frequencyBins) / MAX_FREQUENCY_AMPLITUDE;
-                this.amplitudes.next([...this.amplitudes.value, normalizedSignalStrength]);
-            }, this.config.samplingFrequencyMs);
-        };
-        this.config = mergeDeepUndefined({ ...config }, DEFAULT_AMPLITUDE_RECORDER_CONFIG);
-        this.stream = stream;
-    }
-    init() {
-        this.audioContext = new AudioContext();
-        this.analyserNode = this.audioContext.createAnalyser();
-        const { analyserConfig } = this.config;
-        this.analyserNode.fftSize = analyserConfig.fftSize;
-        this.analyserNode.maxDecibels = analyserConfig.maxDecibels;
-        this.analyserNode.minDecibels = analyserConfig.minDecibels;
-        this.microphone = this.audioContext.createMediaStreamSource(this.stream);
-        this.microphone.connect(this.analyserNode);
-    }
-    stop() {
-        clearInterval(this.amplitudeSamplingInterval);
-        this.amplitudeSamplingInterval = undefined;
-        this.state.next(AmplitudeRecorderState.STOPPED);
-    }
-    close() {
-        if (this.state.value !== AmplitudeRecorderState.STOPPED)
-            this.stop();
-        this.state.next(AmplitudeRecorderState.CLOSED);
-        this.amplitudes.next([]);
-        this.microphone?.disconnect();
-        this.analyserNode?.disconnect();
-        if (this.audioContext?.state !== 'closed')
-            this.audioContext?.close();
-    }
-}

package/dist/components/MediaRecorder/classes/BrowserPermission.d.ts

@@ -1,22 +0,0 @@
-import type { RecordedMediaType } from '../../ReactFileUtilities';
-import { Subject } from '../observable/Subject';
-import { BehaviorSubject } from '../observable/BehaviorSubject';
-export declare enum RecordingPermission {
-    CAM = "camera",
-    MIC = "microphone"
-}
-export type BrowserPermissionOptions = {
-    mediaType: RecordedMediaType;
-};
-export declare class BrowserPermission {
-    name: string;
-    state: BehaviorSubject<PermissionState | undefined>;
-    status: BehaviorSubject<PermissionStatus | undefined>;
-    error: Subject<Error | undefined>;
-    private changeSubscriptions;
-    constructor({ mediaType }: BrowserPermissionOptions);
-    get isWatching(): boolean;
-    watch(): Promise<void>;
-    unwatch(): void;
-    check(): Promise<void>;
-}

package/dist/components/MediaRecorder/classes/BrowserPermission.js

@@ -1,63 +0,0 @@
-import { Subscription } from '../observable/Subscription';
-import { Subject } from '../observable/Subject';
-import { BehaviorSubject } from '../observable/BehaviorSubject';
-export var RecordingPermission;
-(function (RecordingPermission) {
-    RecordingPermission["CAM"] = "camera";
-    RecordingPermission["MIC"] = "microphone";
-})(RecordingPermission || (RecordingPermission = {}));
-const MEDIA_TO_PERMISSION = {
-    audio: RecordingPermission.MIC,
-    video: RecordingPermission.CAM,
-};
-export class BrowserPermission {
-    constructor({ mediaType }) {
-        this.state = new BehaviorSubject(undefined);
-        this.status = new BehaviorSubject(undefined);
-        this.error = new Subject();
-        this.changeSubscriptions = [];
-        this.name = MEDIA_TO_PERMISSION[mediaType];
-    }
-    get isWatching() {
-        return this.changeSubscriptions.some((subscription) => !subscription.closed);
-    }
-    async watch() {
-        if (!this.status.value) {
-            await this.check();
-            if (!this.status.value)
-                return;
-        }
-        const status = this.status.value;
-        const handlePermissionChange = (e) => {
-            const { state } = e.target;
-            this.state.next(state);
-        };
-        status.addEventListener('change', handlePermissionChange);
-        this.changeSubscriptions.push(new Subscription(() => {
-            status.removeEventListener('change', handlePermissionChange);
-        }));
-    }
-    unwatch() {
-        this.changeSubscriptions.forEach((subscription) => subscription.unsubscribe());
-    }
-    async check() {
-        if (!this.name) {
-            this.error.next(new Error('Unknown media recording permission'));
-            return;
-        }
-        let permissionState;
-        try {
-            const permissionStatus = await navigator.permissions.query({
-                name: this.name,
-            });
-            permissionState = permissionStatus.state;
-            this.status.next(permissionStatus);
-        }
-        catch (e) {
-            // permission does not exist - cannot be queried
-            // an example would be Firefox - camera, neither microphone perms can be queried
-            permissionState = 'granted';
-        }
-        this.state.next(permissionState);
-    }
-}

package/dist/components/MediaRecorder/classes/MediaRecorderController.d.ts

@@ -1,75 +0,0 @@
-import { AmplitudeRecorder } from './AmplitudeRecorder';
-import { BrowserPermission } from './BrowserPermission';
-import { BehaviorSubject, Subject } from '../observable';
-import type { TranscoderConfig } from '../transcode';
-import type { RecordedMediaType } from '../../ReactFileUtilities';
-import type { LocalVoiceRecordingAttachment } from 'stream-chat';
-import type { AmplitudeRecorderConfig } from './AmplitudeRecorder';
-import type { TranslationContextValue } from '../../../context';
-export declare const RECORDED_MIME_TYPE_BY_BROWSER: {
-    readonly audio: {
-        readonly others: "audio/webm";
-        readonly safari: "audio/mp4;codecs=mp4a.40.2";
-    };
-};
-export declare const DEFAULT_AUDIO_TRANSCODER_CONFIG: TranscoderConfig;
-type MediaRecorderConfig = Omit<MediaRecorderOptions, 'mimeType'> & Required<Pick<MediaRecorderOptions, 'mimeType'>>;
-export type AudioRecorderConfig = {
-    amplitudeRecorderConfig: AmplitudeRecorderConfig;
-    mediaRecorderConfig: MediaRecorderOptions;
-    transcoderConfig: TranscoderConfig;
-};
-type PartialValues<T> = {
-    [P in keyof T]?: Partial<T[P]>;
-};
-export type CustomAudioRecordingConfig = PartialValues<AudioRecorderConfig>;
-export type AudioRecorderOptions = {
-    config?: CustomAudioRecordingConfig;
-    generateRecordingTitle?: (mimeType: string) => string;
-    t?: TranslationContextValue['t'];
-};
-export declare enum MediaRecordingState {
-    PAUSED = "paused",
-    RECORDING = "recording",
-    STOPPED = "stopped"
-}
-export declare enum RecordingAttachmentType {
-    VOICE_RECORDING = "voiceRecording"
-}
-export declare class MediaRecorderController {
-    permission: BrowserPermission;
-    mediaRecorder: MediaRecorder | undefined;
-    amplitudeRecorder: AmplitudeRecorder | undefined;
-    amplitudeRecorderConfig: AmplitudeRecorderConfig;
-    mediaRecorderConfig: MediaRecorderConfig;
-    transcoderConfig: TranscoderConfig;
-    startTime: number | undefined;
-    recordedChunkDurations: number[];
-    recordedData: Blob[];
-    recordingUri: string | undefined;
-    mediaType: RecordedMediaType;
-    signalRecordingReady: ((r: LocalVoiceRecordingAttachment) => void) | undefined;
-    recordingState: BehaviorSubject<MediaRecordingState | undefined>;
-    recording: BehaviorSubject<LocalVoiceRecordingAttachment | undefined>;
-    error: Subject<Error | undefined>;
-    notification: Subject<{
-        text: string;
-        type: 'success' | 'error';
-    } | undefined>;
-    customGenerateRecordingTitle: ((mimeType: string) => string) | undefined;
-    t: TranslationContextValue['t'];
-    constructor({ config, generateRecordingTitle, t }?: AudioRecorderOptions);
-    get durationMs(): number;
-    generateRecordingTitle: (mimeType: string) => string;
-    makeVoiceRecording: () => Promise<LocalVoiceRecordingAttachment | undefined>;
-    handleErrorEvent: (e: Event) => void;
-    handleDataavailableEvent: (e: BlobEvent) => Promise<void>;
-    resetRecordingState: () => void;
-    cleanUp: () => void;
-    start: () => Promise<void>;
-    pause: () => void;
-    resume: () => void;
-    stop: () => Promise<LocalVoiceRecordingAttachment> | Promise<undefined>;
-    cancel: () => void;
-}
-export {};

package/dist/components/MediaRecorder/classes/MediaRecorderController.js

@@ -1,255 +0,0 @@
-import fixWebmDuration from 'fix-webm-duration';
-import { nanoid } from 'nanoid';
-import { AmplitudeRecorder, DEFAULT_AMPLITUDE_RECORDER_CONFIG, } from './AmplitudeRecorder';
-import { BrowserPermission } from './BrowserPermission';
-import { BehaviorSubject, Subject } from '../observable';
-import { transcode } from '../transcode';
-import { resampleWaveformData } from '../../Attachment';
-import { createFileFromBlobs, getExtensionFromMimeType, getRecordedMediaTypeFromMimeType, } from '../../ReactFileUtilities';
-import { defaultTranslatorFunction } from '../../../i18n';
-import { mergeDeepUndefined } from '../../../utils/mergeDeep';
-export const RECORDED_MIME_TYPE_BY_BROWSER = {
-    audio: {
-        others: 'audio/webm',
-        safari: 'audio/mp4;codecs=mp4a.40.2',
-    },
-};
-export const DEFAULT_AUDIO_TRANSCODER_CONFIG = {
-    sampleRate: 16000,
-};
-const disposeOfMediaStream = (stream) => {
-    if (!stream?.active)
-        return;
-    stream.getTracks().forEach((track) => {
-        track.stop();
-        stream.removeTrack(track);
-    });
-};
-const logError = (e) => e && console.error('[MEDIA RECORDER ERROR]', e);
-export var MediaRecordingState;
-(function (MediaRecordingState) {
-    MediaRecordingState["PAUSED"] = "paused";
-    MediaRecordingState["RECORDING"] = "recording";
-    MediaRecordingState["STOPPED"] = "stopped";
-})(MediaRecordingState || (MediaRecordingState = {}));
-export var RecordingAttachmentType;
-(function (RecordingAttachmentType) {
-    RecordingAttachmentType["VOICE_RECORDING"] = "voiceRecording";
-})(RecordingAttachmentType || (RecordingAttachmentType = {}));
-export class MediaRecorderController {
-    constructor({ config, generateRecordingTitle, t } = {}) {
-        this.recordedChunkDurations = [];
-        this.recordedData = [];
-        this.recordingState = new BehaviorSubject(undefined);
-        this.recording = new BehaviorSubject(undefined);
-        this.error = new Subject();
-        this.notification = new Subject();
-        this.generateRecordingTitle = (mimeType) => {
-            if (this.customGenerateRecordingTitle) {
-                return this.customGenerateRecordingTitle(mimeType);
-            }
-            return `${this.mediaType}_recording_${new Date().toISOString()}.${getExtensionFromMimeType(mimeType)}`; // extension needed so that desktop Safari can play the asset
-        };
-        this.makeVoiceRecording = async () => {
-            if (this.recordingUri)
-                URL.revokeObjectURL(this.recordingUri);
-            if (!this.recordedData.length)
-                return;
-            const { mimeType } = this.mediaRecorderConfig;
-            let blob = new Blob(this.recordedData, { type: mimeType });
-            if (mimeType.match('audio/webm')) {
-                // The browser does not include duration metadata with the recorded blob
-                blob = await fixWebmDuration(blob, this.durationMs, {
-                    logger: () => null, // prevents polluting the browser console
-                });
-            }
-            if (!mimeType.match('audio/mp4')) {
-                blob = await transcode({
-                    blob,
-                    ...this.transcoderConfig,
-                });
-            }
-            if (!blob)
-                return;
-            this.recordingUri = URL.createObjectURL(blob);
-            const file = createFileFromBlobs({
-                blobsArray: [blob],
-                fileName: this.generateRecordingTitle(blob.type),
-                mimeType: blob.type,
-            });
-            return {
-                asset_url: this.recordingUri,
-                duration: this.durationMs / 1000,
-                file_size: blob.size,
-                localMetadata: {
-                    file,
-                    id: nanoid(),
-                },
-                mime_type: blob.type,
-                title: file.name,
-                type: RecordingAttachmentType.VOICE_RECORDING,
-                waveform_data: resampleWaveformData(this.amplitudeRecorder?.amplitudes.value ?? [], this.amplitudeRecorderConfig.sampleCount),
-            };
-        };
-        this.handleErrorEvent = (e) => {
-            const { error } = e;
-            logError(error);
-            this.error.next(error);
-            this.notification.next({
-                text: this.t('An error has occurred during recording'),
-                type: 'error',
-            });
-        };
-        this.handleDataavailableEvent = async (e) => {
-            if (!e.data.size)
-                return;
-            if (this.mediaType !== 'audio')
-                return;
-            try {
-                this.recordedData.push(e.data);
-                const recording = await this.makeVoiceRecording();
-                if (!recording)
-                    return;
-                this.signalRecordingReady?.(recording);
-                this.recording.next(recording);
-            }
-            catch (e) {
-                logError(e);
-                this.error.next(e);
-                this.notification.next({
-                    text: this.t('An error has occurred during the recording processing'),
-                    type: 'error',
-                });
-            }
-        };
-        this.resetRecordingState = () => {
-            this.recordedData = [];
-            this.recording.next(undefined);
-            this.recordingState.next(undefined);
-            this.recordedChunkDurations = [];
-            this.startTime = undefined;
-        };
-        this.cleanUp = () => {
-            this.resetRecordingState();
-            if (this.recordingUri)
-                URL.revokeObjectURL(this.recordingUri);
-            this.amplitudeRecorder?.close();
-            if (this.mediaRecorder) {
-                disposeOfMediaStream(this.mediaRecorder.stream);
-                this.mediaRecorder.removeEventListener('dataavailable', this.handleDataavailableEvent);
-                this.mediaRecorder.removeEventListener('error', this.handleErrorEvent);
-            }
-        };
-        this.start = async () => {
-            if ([MediaRecordingState.RECORDING, MediaRecordingState.PAUSED].includes(this.recordingState.value)) {
-                const error = new Error('Cannot start recording. Recording already in progress');
-                logError(error);
-                this.error.next(error);
-                return;
-            }
-            // account for requirement on iOS as per this bug report: https://bugs.webkit.org/show_bug.cgi?id=252303
-            if (!navigator.mediaDevices) {
-                const error = new Error('Media recording is not supported');
-                logError(error);
-                this.error.next(error);
-                this.notification.next({ text: this.t('Error starting recording'), type: 'error' });
-                return;
-            }
-            if (this.mediaType === 'video') {
-                const error = new Error(`Video recording is not supported. Provided MIME type: ${this.mediaRecorderConfig.mimeType}`);
-                logError(error);
-                this.error.next(error);
-                this.notification.next({ text: this.t('Error starting recording'), type: 'error' });
-                return;
-            }
-            if (!this.permission.state.value) {
-                await this.permission.check();
-            }
-            if (this.permission.state.value === 'denied') {
-                logError(new Error('Permission denied'));
-                return;
-            }
-            try {
-                const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
-                this.mediaRecorder = new MediaRecorder(stream, this.mediaRecorderConfig);
-                this.mediaRecorder.addEventListener('dataavailable', this.handleDataavailableEvent);
-                this.mediaRecorder.addEventListener('error', this.handleErrorEvent);
-                this.startTime = new Date().getTime();
-                this.mediaRecorder.start();
-                if (this.mediaType === 'audio' && stream) {
-                    this.amplitudeRecorder = new AmplitudeRecorder({
-                        config: this.amplitudeRecorderConfig,
-                        stream,
-                    });
-                    this.amplitudeRecorder.start();
-                }
-                this.recordingState.next(MediaRecordingState.RECORDING);
-            }
-            catch (error) {
-                logError(error);
-                this.cancel();
-                this.error.next(error);
-                this.notification.next({ text: this.t('Error starting recording'), type: 'error' });
-            }
-        };
-        this.pause = () => {
-            if (this.recordingState.value !== MediaRecordingState.RECORDING)
-                return;
-            if (this.startTime) {
-                this.recordedChunkDurations.push(new Date().getTime() - this.startTime);
-                this.startTime = undefined;
-            }
-            this.mediaRecorder?.pause();
-            this.amplitudeRecorder?.stop();
-            this.recordingState.next(MediaRecordingState.PAUSED);
-        };
-        this.resume = () => {
-            if (this.recordingState.value !== MediaRecordingState.PAUSED)
-                return;
-            this.startTime = new Date().getTime();
-            this.mediaRecorder?.resume();
-            this.amplitudeRecorder?.start();
-            this.recordingState.next(MediaRecordingState.RECORDING);
-        };
-        this.stop = () => {
-            const recording = this.recording.value;
-            if (recording)
-                return Promise.resolve(recording);
-            if (![MediaRecordingState.PAUSED, MediaRecordingState.RECORDING].includes((this.mediaRecorder?.state || '')))
-                return Promise.resolve(undefined);
-            if (this.startTime) {
-                this.recordedChunkDurations.push(new Date().getTime() - this.startTime);
-                this.startTime = undefined;
-            }
-            const result = new Promise((res) => {
-                this.signalRecordingReady = res;
-            });
-            this.mediaRecorder?.stop();
-            this.amplitudeRecorder?.stop();
-            this.recordingState.next(MediaRecordingState.STOPPED);
-            return result;
-        };
-        this.cancel = () => {
-            this.stop();
-            this.cleanUp();
-        };
-        this.t = t || defaultTranslatorFunction;
-        this.amplitudeRecorderConfig = mergeDeepUndefined({ ...config?.amplitudeRecorderConfig }, DEFAULT_AMPLITUDE_RECORDER_CONFIG);
-        this.mediaRecorderConfig = mergeDeepUndefined({ ...config?.mediaRecorderConfig }, {
-            mimeType: MediaRecorder.isTypeSupported('audio/webm')
-                ? RECORDED_MIME_TYPE_BY_BROWSER.audio.others
-                : RECORDED_MIME_TYPE_BY_BROWSER.audio.safari,
-        });
-        this.transcoderConfig = mergeDeepUndefined({ ...config?.transcoderConfig }, DEFAULT_AUDIO_TRANSCODER_CONFIG);
-        const mediaType = getRecordedMediaTypeFromMimeType(this.mediaRecorderConfig.mimeType);
-        if (!mediaType) {
-            throw new Error(`Unsupported media type (supported audio or video only). Provided mimeType: ${this.mediaRecorderConfig.mimeType}`);
-        }
-        this.mediaType = mediaType;
-        this.permission = new BrowserPermission({ mediaType });
-        this.customGenerateRecordingTitle = generateRecordingTitle;
-    }
-    get durationMs() {
-        return this.recordedChunkDurations.reduce((acc, val) => acc + val, 0);
-    }
-}

package/dist/components/MediaRecorder/classes/index.d.ts

@@ -1,3 +0,0 @@
-export * from './BrowserPermission';
-export * from './MediaRecorderController';
-export type { AmplitudeRecorderConfig } from './AmplitudeRecorder';

package/dist/components/MediaRecorder/classes/index.js

@@ -1,2 +0,0 @@
-export * from './BrowserPermission';
-export * from './MediaRecorderController';

package/dist/components/MediaRecorder/hooks/index.d.ts

@@ -1 +0,0 @@
-export type { RecordingController } from './useMediaRecorder';

package/dist/components/MediaRecorder/hooks/index.js

@@ -1 +0,0 @@
-export {};

package/dist/components/MediaRecorder/hooks/useMediaRecorder.d.ts

@@ -1,18 +0,0 @@
-import { MediaRecorderController } from '../classes';
-import type { LocalVoiceRecordingAttachment } from 'stream-chat';
-import type { CustomAudioRecordingConfig, MediaRecordingState } from '../classes';
-import type { MessageInputContextValue } from '../../../context';
-export type RecordingController = {
-    completeRecording: () => void;
-    permissionState?: PermissionState;
-    recorder?: MediaRecorderController;
-    recording?: LocalVoiceRecordingAttachment;
-    recordingState?: MediaRecordingState;
-};
-type UseMediaRecorderParams = Pick<MessageInputContextValue, 'asyncMessagesMultiSendEnabled' | 'handleSubmit'> & {
-    enabled: boolean;
-    generateRecordingTitle?: (mimeType: string) => string;
-    recordingConfig?: CustomAudioRecordingConfig;
-};
-export declare const useMediaRecorder: ({ asyncMessagesMultiSendEnabled, enabled, generateRecordingTitle, handleSubmit, recordingConfig, }: UseMediaRecorderParams) => RecordingController;
-export {};

package/dist/components/MediaRecorder/hooks/useMediaRecorder.js

@@ -1,60 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
-import { MediaRecorderController } from '../classes';
-import { useTranslationContext } from '../../../context';
-import { useMessageComposer } from '../../MessageInput';
-export const useMediaRecorder = ({ asyncMessagesMultiSendEnabled, enabled, generateRecordingTitle, handleSubmit, recordingConfig, }) => {
-    const { t } = useTranslationContext('useMediaRecorder');
-    const messageComposer = useMessageComposer();
-    const [recording, setRecording] = useState();
-    const [recordingState, setRecordingState] = useState();
-    const [permissionState, setPermissionState] = useState();
-    const [isScheduledForSubmit, scheduleForSubmit] = useState(false);
-    const recorder = useMemo(() => enabled
-        ? new MediaRecorderController({
-            config: recordingConfig ?? {},
-            generateRecordingTitle,
-            t,
-        })
-        : undefined, [recordingConfig, enabled, generateRecordingTitle, t]);
-    const completeRecording = useCallback(async () => {
-        if (!recorder)
-            return;
-        const recording = await recorder.stop();
-        if (!recording)
-            return;
-        await messageComposer.attachmentManager.uploadAttachment(recording);
-        if (!asyncMessagesMultiSendEnabled) {
-            // FIXME: cannot call handleSubmit() directly as the function has stale reference to attachments
-            scheduleForSubmit(true);
-        }
-        recorder.cleanUp();
-    }, [asyncMessagesMultiSendEnabled, messageComposer, recorder]);
-    useEffect(() => {
-        if (!isScheduledForSubmit)
-            return;
-        handleSubmit();
-        scheduleForSubmit(false);
-    }, [handleSubmit, isScheduledForSubmit]);
-    useEffect(() => {
-        if (!recorder)
-            return;
-        recorder.permission.watch();
-        const recordingSubscription = recorder.recording.subscribe(setRecording);
-        const recordingStateSubscription = recorder.recordingState.subscribe(setRecordingState);
-        const permissionStateSubscription = recorder.permission.state.subscribe(setPermissionState);
-        return () => {
-            recorder.cancel();
-            recorder.permission.unwatch();
-            recordingSubscription.unsubscribe();
-            recordingStateSubscription.unsubscribe();
-            permissionStateSubscription.unsubscribe();
-        };
-    }, [recorder]);
-    return {
-        completeRecording,
-        permissionState,
-        recorder,
-        recording,
-        recordingState,
-    };
-};

package/dist/components/MediaRecorder/index.d.ts

@@ -1,6 +0,0 @@
-export * from './RecordingPermissionDeniedNotification';
-export * from './AudioRecorder';
-export * from './hooks';
-export { MediaRecordingState } from './classes/MediaRecorderController';
-export { RecordingPermission } from './classes/BrowserPermission';
-export type { CustomAudioRecordingConfig } from './classes';

package/dist/components/MediaRecorder/index.js

@@ -1,5 +0,0 @@
-export * from './RecordingPermissionDeniedNotification';
-export * from './AudioRecorder';
-export * from './hooks';
-export { MediaRecordingState } from './classes/MediaRecorderController';
-export { RecordingPermission } from './classes/BrowserPermission';

package/dist/components/MediaRecorder/observable/BehaviorSubject.d.ts

@@ -1,10 +0,0 @@
-import { Subject } from './Subject';
-import type { ObserverOrNext } from './Observer';
-import type { Subscription } from './Subscription';
-export declare class BehaviorSubject<T> extends Subject<T> {
-    private _value;
-    constructor(_value: T);
-    get value(): T;
-    subscribe(observerOrNext: ObserverOrNext<T>): Subscription;
-    next(value: T): void;
-}

package/dist/components/MediaRecorder/observable/BehaviorSubject.js

@@ -1,25 +0,0 @@
-import { Subject } from './Subject';
-import { createObserver } from './Observer';
-export class BehaviorSubject extends Subject {
-    constructor(_value) {
-        super();
-        this._value = _value;
-    }
-    get value() {
-        const { _value, thrownError } = this;
-        if (thrownError) {
-            throw thrownError;
-        }
-        return _value;
-    }
-    subscribe(observerOrNext) {
-        const observer = createObserver(observerOrNext);
-        const subscription = super.subscribe(observerOrNext);
-        if (!subscription.closed)
-            observer.next(this._value);
-        return subscription;
-    }
-    next(value) {
-        super.next((this._value = value));
-    }
-}

package/dist/components/MediaRecorder/observable/Observable.d.ts

@@ -1,17 +0,0 @@
-import type { ObserverOrNext } from './Observer';
-import { Subscription } from './Subscription';
-export interface Unsubscribable {
-    unsubscribe(): void;
-}
-type Producer<T> = (observer: ObserverOrNext<T>) => Subscription;
-export interface Subscribable<T> {
-    subscribe(observerOrNext: ObserverOrNext<T>): Unsubscribable;
-}
-export declare class Observable<T> implements Subscribable<T> {
-    protected _closed: boolean;
-    private _producer;
-    constructor(producer?: Producer<T>);
-    get closed(): boolean;
-    subscribe(observerOrNext: ObserverOrNext<T>): Subscription;
-}
-export {};