@siteed/expo-audio-stream 1.8.0 → 1.9.1

package/src/ExpoAudioStream.types.ts

@@ -69,7 +69,6 @@ export interface AudioRecording {
     bitDepth: BitDepth
     sampleRate: SampleRate
     transcripts?: TranscriberData[]
-    wavPCMData?: Float32Array // Full PCM data for the recording in WAV format (only on web, for native use the fileUri)
     analysisData?: AudioAnalysis // Analysis data for the recording depending on enableProcessing flag
     compression?: CompressionInfo & {
         compressedFileUri: string
@@ -239,22 +238,9 @@ export interface WaveformConfig {
     height?: number // Height of the waveform view in dp (default: 64)
 }
 
-export interface WebRecordingOptions {
-    /**
-     * Web-specific option to skip the final audio data consolidation process.
-     * When true, it will:
-     * - Skip the time-consuming process of concatenating all audio chunks
-     * - Return immediately with the compressed audio (if compression is enabled)
-     * - Improve performance when stopping large recordings
-     * - Useful when only the compressed audio is needed (e.g., when not using transcription)
-     * @default false
-     */
-    skipFinalConsolidation?: boolean
-}
-
 export interface UseAudioRecorderState {
     startRecording: (_: RecordingConfig) => Promise<StartRecordingResult>
-    stopRecording: (options?: WebRecordingOptions) => Promise<AudioRecording | null>
+    stopRecording: () => Promise<AudioRecording | null>
     pauseRecording: () => Promise<void>
     resumeRecording: () => Promise<void>
     isRecording: boolean

package/src/ExpoAudioStream.web.ts

@@ -9,12 +9,10 @@ import {
     ConsoleLike,
     RecordingConfig,
     StartRecordingResult,
-    WebRecordingOptions,
 } from './ExpoAudioStream.types'
 import { WebRecorder } from './WebRecorder.web'
 import { AudioEventPayload } from './events'
 import { encodingToBitDepth } from './utils/encodingToBitDepth'
-import { writeWavHeader } from './utils/writeWavHeader'
 
 export interface EmitAudioEventProps {
     data: Float32Array
@@ -35,6 +33,7 @@ export interface ExpoAudioStreamWebProps {
     logger?: ConsoleLike
     audioWorkletUrl: string
     featuresExtratorUrl: string
+    maxBufferSize?: number // Maximum number of chunks to keep in memory
 }
 
 export class ExpoAudioStreamWeb extends LegacyEventEmitter {
@@ -59,11 +58,13 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
     logger?: ConsoleLike
     latestPosition: number = 0
     totalCompressedSize: number = 0
+    private readonly maxBufferSize: number
 
     constructor({
         audioWorkletUrl,
         featuresExtratorUrl,
         logger,
+        maxBufferSize = 100, // Default to storing last 100 chunks (1 chunk = 0.5 seconds)
     }: ExpoAudioStreamWebProps) {
         const mockNativeModule = {
             addListener: () => {
@@ -93,6 +94,7 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
         this.streamUuid = null // Initialize UUID on first recording start
         this.audioWorkletUrl = audioWorkletUrl
         this.featuresExtratorUrl = featuresExtratorUrl
+        this.maxBufferSize = maxBufferSize
     }
 
     // Utility to handle user media stream
@@ -134,7 +136,11 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
                 position,
                 compression,
             }: EmitAudioEventProps) => {
+                // Keep only the latest chunks based on maxBufferSize
                 this.audioChunks.push(new Float32Array(data))
+                if (this.audioChunks.length > this.maxBufferSize) {
+                    this.audioChunks.shift() // Remove oldest chunk
+                }
                 this.currentSize += data.byteLength
                 this.emitAudioEvent({ data, position, compression })
                 this.lastEmittedTime = Date.now()
@@ -218,72 +224,63 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
     }
 
     // Stop recording
-    async stopRecording(options?: WebRecordingOptions): Promise<AudioRecording> {
+    async stopRecording(): Promise<AudioRecording> {
         if (!this.customRecorder) {
             throw new Error('Recorder is not initialized')
         }
 
-        // Create a promise to handle the PCM data processing
-        return new Promise<AudioRecording>((resolve) => {
-            // Use requestAnimationFrame to avoid blocking the UI
-            requestAnimationFrame(() => {
-                // Move the async work inside a self-executing async function
-                (async () => {
-                    const { pcmData, compressedBlob } = await this.customRecorder!.stop(options)
+        this.logger?.debug('[Stop] Starting stop process')
+        const startTime = performance.now()
 
-                    this.logger?.debug(`Stopped recording`, pcmData)
-                    this.isRecording = false
-                    this.isPaused = false
-                    this.currentDurationMs = Date.now() - this.recordingStartTime
+        try {
+            this.logger?.debug('[Stop] Stopping recorder')
+            const { compressedBlob } = await this.customRecorder.stop()
 
-                    // Process in the next frame to avoid blocking
-                    requestAnimationFrame(() => {
-                        // Rest of the code remains the same
-                        const wavBuffer = writeWavHeader({
-                            buffer: pcmData.buffer,
-                            sampleRate: this.recordingConfig?.sampleRate ?? 44100,
-                            numChannels: this.recordingConfig?.channels ?? 1,
-                            bitDepth: this.bitDepth,
-                        })
+            this.isRecording = false
+            this.isPaused = false
+            this.currentDurationMs = Date.now() - this.recordingStartTime
 
-                        const cloneableBuffer = wavBuffer.slice(0)
+            let compression: AudioRecording['compression']
+            let fileUri = `${this.streamUuid}.${this.extension}`
+            let mimeType = `audio/${this.extension}`
 
-                        const blob = new Blob([cloneableBuffer], {
-                            type: `audio/${this.extension}`,
-                        })
-                        const fileUri = URL.createObjectURL(blob)
+            if (compressedBlob && this.recordingConfig?.compression?.enabled) {
+                const compressedUri = URL.createObjectURL(compressedBlob)
+                compression = {
+                    compressedFileUri: compressedUri,
+                    size: compressedBlob.size,
+                    mimeType: 'audio/webm',
+                    format: 'opus',
+                    bitrate: this.recordingConfig.compression.bitrate ?? 128000,
+                }
+                // Use compressed values when compression is enabled
+                fileUri = compressedUri
+                mimeType = 'audio/webm'
+            }
 
-                        let compression: AudioRecording['compression']
-                        if (compressedBlob && this.recordingConfig?.compression?.enabled) {
-                            const compressedUri = URL.createObjectURL(compressedBlob)
-                            compression = {
-                                compressedFileUri: compressedUri,
-                                size: compressedBlob.size,
-                                mimeType: 'audio/webm',
-                                format: 'opus',
-                                bitrate: this.recordingConfig.compression.bitrate ?? 128000,
-                            }
-                        }
+            this.logger?.debug(
+                `[Stop] Completed stop process in ${performance.now() - startTime}ms`,
+                {
+                    durationMs: this.currentDurationMs,
+                    compressedSize: compression?.size,
+                }
+            )
 
-                        resolve({
-                            fileUri,
-                            filename: `${this.streamUuid}.${this.extension}`,
-                            wavPCMData: new Float32Array(cloneableBuffer),
-                            bitDepth: this.bitDepth,
-                            channels: this.recordingConfig?.channels ?? 1,
-                            sampleRate: this.recordingConfig?.sampleRate ?? 44100,
-                            durationMs: this.currentDurationMs,
-                            size: this.currentSize,
-                            mimeType: `audio/${this.extension}`,
-                            compression,
-                        })
-                    })
-                })().catch((error) => {
-                    this.logger?.error('Error in stopRecording:', error)
-                    throw error
-                })
-            })
-        })
+            return {
+                fileUri,
+                filename: `${this.streamUuid}.${this.extension}`,
+                bitDepth: this.bitDepth,
+                channels: this.recordingConfig?.channels ?? 1,
+                sampleRate: this.recordingConfig?.sampleRate ?? 44100,
+                durationMs: this.currentDurationMs,
+                size: this.currentSize,
+                mimeType,
+                compression,
+            }
+        } catch (error) {
+            this.logger?.error('[Stop] Error stopping recording:', error)
+            throw error
+        }
     }
 
     // Pause recording