sera-ai 1.0.22 → 1.0.24

package/dist/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var React3 = require('react');
+var ffmpeg = require('@ffmpeg/ffmpeg');
 var pRetry = require('p-retry');
 var lucideReact = require('lucide-react');
 var jsxRuntime = require('react/jsx-runtime');
@@ -78,14 +79,14 @@ var createFFmpegWorker = () => {
       
       processAudioData: function(audioBuffer, options = {}) {
         try {
-          const { quality = 1, bitRate = 128000 } = options;
+          const { quality = 1, bitRate = 128000, sampleRate = 44100 } = options;
           const float32Array = new Float32Array(audioBuffer);
-          const wavBuffer = this.float32ToWavFile(float32Array);
-          
+          const wavBuffer = this.float32ToWavFile(float32Array, sampleRate);
+
           return {
             buffer: wavBuffer,
             size: wavBuffer.byteLength,
-            duration: float32Array.length / 44100
+            duration: float32Array.length / sampleRate
           };
         } catch (error) {
           throw new Error('Failed to process audio data: ' + error.message);
@@ -292,14 +293,38 @@ var createFFmpegWorker = () => {
 };
 var useFFmpegConverter = () => {
   const [isLoaded, setIsLoaded] = React3.useState(true);
+  const [ffmpegLoaded, setFfmpegLoaded] = React3.useState(false);
   const [isConverting, setIsConverting] = React3.useState(false);
   const [progress, setProgress] = React3.useState(0);
   const [error, setError] = React3.useState(null);
   const [statusMessage, setStatusMessage] = React3.useState("");
+  const ffmpegRef = React3.useRef(null);
   const loadFFmpeg = React3.useCallback(async () => {
-    setIsLoaded(true);
-    return true;
-  }, []);
+    if (ffmpegRef.current && ffmpegLoaded) {
+      return true;
+    }
+    try {
+      setStatusMessage("Loading FFmpeg...");
+      const ffmpeg$1 = ffmpeg.createFFmpeg({
+        log: false,
+        progress: ({ ratio }) => {
+          setProgress(Math.round(ratio * 100));
+        }
+      });
+      await ffmpeg$1.load();
+      ffmpegRef.current = ffmpeg$1;
+      setFfmpegLoaded(true);
+      setIsLoaded(true);
+      setStatusMessage("");
+      console.log("FFmpeg WASM loaded successfully");
+      return true;
+    } catch (err) {
+      console.error("Failed to load FFmpeg:", err);
+      setError("Failed to load FFmpeg");
+      setStatusMessage("");
+      return false;
+    }
+  }, [ffmpegLoaded]);
   const convertToWav = React3.useCallback(
     async (audioData, sampleRate = AUDIO_SAMPLE_RATE, fileName = "recording.wav") => {
       setIsConverting(true);
@@ -344,8 +369,7 @@ var useFFmpegConverter = () => {
           worker.postMessage({
             type: "convertWav",
             audioBuffer: audioData.buffer,
-            sampleRate,
-            options: { quality: 1, bitRate: 128e3 }
+            options: { quality: 1, bitRate: 128e3, sampleRate }
           });
         });
       } catch (err) {
@@ -357,6 +381,69 @@ var useFFmpegConverter = () => {
     },
     []
   );
+  const convertToFlac = React3.useCallback(
+    async (wavFile) => {
+      if (!ffmpegRef.current || !ffmpegLoaded) {
+        const loaded = await loadFFmpeg();
+        if (!loaded) {
+          console.error("Failed to load FFmpeg for FLAC conversion");
+          return wavFile;
+        }
+      }
+      const ffmpeg$1 = ffmpegRef.current;
+      if (!ffmpeg$1) {
+        console.error("FFmpeg not available");
+        return wavFile;
+      }
+      try {
+        setIsConverting(true);
+        setProgress(0);
+        setError(null);
+        setStatusMessage("Converting to FLAC...");
+        const inputFileName = "input.wav";
+        const outputFileName = "output.flac";
+        const wavData = await ffmpeg.fetchFile(wavFile);
+        ffmpeg$1.FS("writeFile", inputFileName, wavData);
+        setProgress(30);
+        setStatusMessage("Encoding FLAC...");
+        await ffmpeg$1.run(
+          "-i",
+          inputFileName,
+          "-c:a",
+          "flac",
+          "-compression_level",
+          "5",
+          // 0-12, higher = smaller file but slower
+          outputFileName
+        );
+        setProgress(80);
+        setStatusMessage("Finalizing...");
+        const flacData = ffmpeg$1.FS("readFile", outputFileName);
+        ffmpeg$1.FS("unlink", inputFileName);
+        ffmpeg$1.FS("unlink", outputFileName);
+        const flacBlob = new Blob([new Uint8Array(flacData)], { type: "audio/flac" });
+        const flacFileName = wavFile.name.replace(/\.wav$/i, ".flac");
+        const flacFile = new File([flacBlob], flacFileName, { type: "audio/flac" });
+        setProgress(100);
+        setStatusMessage("FLAC conversion complete");
+        console.log(`[FLAC] Converted ${wavFile.size} bytes WAV to ${flacFile.size} bytes FLAC (${Math.round((1 - flacFile.size / wavFile.size) * 100)}% reduction)`);
+        setTimeout(() => {
+          setIsConverting(false);
+          setProgress(0);
+          setStatusMessage("");
+        }, 500);
+        return flacFile;
+      } catch (err) {
+        console.error("FLAC conversion failed:", err);
+        setError("FLAC conversion failed");
+        setIsConverting(false);
+        setProgress(0);
+        setStatusMessage("");
+        return wavFile;
+      }
+    },
+    [ffmpegLoaded, loadFFmpeg]
+  );
   const removeSilence = React3.useCallback(async (file) => {
     if (!file) {
       setError("No file provided for processing");
@@ -529,14 +616,16 @@ var useFFmpegConverter = () => {
     setStatusMessage("");
   }, []);
   return {
-    ffmpeg: null,
+    ffmpeg: ffmpegRef.current,
     isLoaded,
+    ffmpegLoaded,
     isConverting,
     progress,
     error,
     statusMessage,
     loadFFmpeg,
     convertToWav,
+    convertToFlac,
     removeSilence,
     reset
   };
@@ -2960,7 +3049,8 @@ var useAudioRecorder = ({
     loadFFmpeg,
     progress,
     statusMessage,
-    convertToWav
+    convertToWav,
+    convertToFlac
   } = useFFmpegConverter_default();
   const isLoadedRef = React3__namespace.default.useRef(isLoaded);
   React3__namespace.default.useEffect(() => {
@@ -3168,12 +3258,27 @@ var useAudioRecorder = ({
             } else {
               console.log("[SILENCE] Silence removal disabled or not loaded");
             }
+            let audioFile = wavFile;
+            try {
+              console.log("[FLAC] Converting WAV to FLAC...");
+              const flacFile = await convertToFlac(wavFile);
+              if (flacFile && flacFile.type === "audio/flac") {
+                audioFile = flacFile;
+                console.log(
+                  `[FLAC] Conversion successful: ${wavFile.size} bytes WAV \u2192 ${flacFile.size} bytes FLAC`
+                );
+              } else {
+                console.warn("[FLAC] Conversion failed, using WAV file");
+              }
+            } catch (flacError) {
+              console.warn("[FLAC] Conversion error, using WAV file:", flacError);
+            }
             console.log(
-              `[OUT] Final file for transcription: ${wavFile.size} bytes, ${wavFile.name}`
+              `[OUT] Final file for transcription: ${audioFile.size} bytes, ${audioFile.name}`
             );
-            if (wavFile.size < 500) {
+            if (audioFile.size < 500) {
               console.warn(
-                `[WARN] Small audio file (${wavFile.size} bytes) - may contain minimal audio data, sending to server anyway`
+                `[WARN] Small audio file (${audioFile.size} bytes) - may contain minimal audio data, sending to server anyway`
               );
             }
             const requestData = {
@@ -3194,13 +3299,13 @@ var useAudioRecorder = ({
             let contentType;
             switch (selectedFormatRef.current) {
               case "hl7":
-                formData = createHL7TranscriptionRequest(wavFile, requestData);
+                formData = createHL7TranscriptionRequest(audioFile, requestData);
                 contentType = "multipart/form-data; hl7-request=true";
                 console.log("Created HL7-formatted request");
                 console.log("HL7 FormData entries:", Array.from(formData.entries()));
                 break;
               case "fhir":
-                formData = createFHIRTranscriptionRequest(wavFile, requestData);
+                formData = createFHIRTranscriptionRequest(audioFile, requestData);
                 contentType = "multipart/form-data; fhir-request=true";
                 console.log("Created FHIR-formatted request");
                 console.log("FHIR FormData entries:", Array.from(formData.entries()));
@@ -3213,7 +3318,7 @@ var useAudioRecorder = ({
                 } else if (sessionIdRef.current) {
                   formData.append("sessionId", sessionIdRef.current);
                 }
-                formData.append("audio", wavFile);
+                formData.append("audio", audioFile);
                 formData.append("model", selectedModelRef.current);
                 formData.append("doctorName", doctorName);
                 formData.append("patientName", patientName || "");