use-audio-record/dist/react.cjs

<!-- automd:badges color=yellow -->

'use strict';

const react = require('react');
const constants = require('./shared/use-audio-record.c8adf376.cjs');

function useAudioRecorder(options = {}) {
  const { mimeType = constants.getMimeType(), sampleRate = constants.SAMPLING_RATE } = options;
  const streamRef = react.useRef(null);
  const mediaRecorderRef = react.useRef(null);
  const chunksRef = react.useRef([]);
  const [recording, setRecording] = react.useState(false);
  const [duration, setDuration] = react.useState(0);
  const [recordedBlob, setRecordedBlob] = react.useState(null);
  const initRecorder = async () => {
    if (!streamRef.current) {
      streamRef.current = await navigator.mediaDevices.getUserMedia({
        audio: true
      });
    }
  };
  const [recordedAudioBuffer, setRecordedAudioBuffer] = react.useState(null);
  const startRecording = async (completeCallback) => {
    setRecordedBlob(null);
    const startTime = Date.now();
    try {
      if (!streamRef.current) {
        await initRecorder();
      }
      const mediaRecorder = new MediaRecorder(streamRef.current, {
        mimeType
      });
      mediaRecorderRef.current = mediaRecorder;
      mediaRecorder.addEventListener("dataavailable", async (event) => {
        if (event.data.size > 0) {
          chunksRef.current.push(event.data);
        }
        if (mediaRecorder.state === "inactive") {
          const duration2 = Date.now() - startTime;
          let blob = new Blob(chunksRef.current, {
            type: mediaRecorder.mimeType
          });
          if (constants.getMimeType() === "audio/webm") {
            blob = await constants.webmFixDuration(blob, duration2, blob.type);
          }
          setRecordedBlob(blob);
          if (!recordedBlob?.size) {
            return;
          }
          const fileReader = new FileReader();
          fileReader.onloadend = async () => {
            const audioCTX = new AudioContext({
              sampleRate
            });
            setRecordedAudioBuffer(
              await audioCTX.decodeAudioData(fileReader.result)
            );
            completeCallback?.();
          };
          fileReader.readAsArrayBuffer(recordedBlob);
          chunksRef.current = [];
        }
      });
      mediaRecorder.start();
      setRecording(true);
    } catch (error) {
      console.error("Error accessing microphone:", error);
    }
  };
  const stopRecording = () => {
    if (mediaRecorderRef.current && mediaRecorderRef.current.state === "recording") {
      mediaRecorderRef.current.stop();
      setDuration(0);
      setRecording(false);
    }
  };
  react.useEffect(() => {
    if (recording) {
      const timer = setInterval(() => {
        setDuration((prevDuration) => prevDuration + 1);
      }, 1e3);
      return () => {
        clearInterval(timer);
      };
    }
    return () => {
    };
  }, [recording]);
  const handleToggleRecording = (completeCallback) => {
    if (recording) {
      stopRecording();
    } else {
      startRecording(completeCallback);
    }
  };
  return {
    streamRef,
    mediaRecorderRef,
    recording,
    duration,
    recordedBlob,
    recordedAudioBuffer,
    chunksRef,
    initRecorder,
    startRecording,
    stopRecording,
    handleToggleRecording
  };
}

exports.useAudioRecorder = useAudioRecorder;
//# sourceMappingURL=react.cjs.map