@siteed/expo-audio-studio 2.1.1

package/build/index.js

@@ -0,0 +1,14 @@
+// src/index.ts
+import { extractRawWavAnalysis, extractAudioAnalysis, } from './AudioAnalysis/extractAudioAnalysis';
+import { extractAudioData } from './AudioAnalysis/extractAudioData';
+import { extractMelSpectrogram } from './AudioAnalysis/extractMelSpectrogram';
+import { extractPreview } from './AudioAnalysis/extractPreview';
+import { AudioRecorderProvider, useSharedAudioRecorder, } from './AudioRecorder.provider';
+import ExpoAudioStreamModule from './ExpoAudioStreamModule';
+import { trimAudio } from './trimAudio';
+import { useAudioRecorder } from './useAudioRecorder';
+export * from './utils/convertPCMToFloat32';
+export * from './utils/getWavFileInfo';
+export * from './utils/writeWavHeader';
+export { AudioRecorderProvider, ExpoAudioStreamModule, extractRawWavAnalysis, extractAudioAnalysis, extractPreview, trimAudio, extractAudioData, extractMelSpectrogram, useAudioRecorder, useSharedAudioRecorder, };
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,eAAe;AAEf,OAAO,EACH,qBAAqB,EACrB,oBAAoB,GACvB,MAAM,sCAAsC,CAAA;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAA;AACnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAA;AAC7E,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAC/D,OAAO,EACH,qBAAqB,EACrB,sBAAsB,GACzB,MAAM,0BAA0B,CAAA;AACjC,OAAO,qBAAqB,MAAM,yBAAyB,CAAA;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAErD,cAAc,6BAA6B,CAAA;AAC3C,cAAc,wBAAwB,CAAA;AACtC,cAAc,wBAAwB,CAAA;AAEtC,OAAO,EACH,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACpB,cAAc,EACd,SAAS,EACT,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,sBAAsB,GACzB,CAAA","sourcesContent":["// src/index.ts\n\nimport {\n    extractRawWavAnalysis,\n    extractAudioAnalysis,\n} from './AudioAnalysis/extractAudioAnalysis'\nimport { extractAudioData } from './AudioAnalysis/extractAudioData'\nimport { extractMelSpectrogram } from './AudioAnalysis/extractMelSpectrogram'\nimport { extractPreview } from './AudioAnalysis/extractPreview'\nimport {\n    AudioRecorderProvider,\n    useSharedAudioRecorder,\n} from './AudioRecorder.provider'\nimport ExpoAudioStreamModule from './ExpoAudioStreamModule'\nimport { trimAudio } from './trimAudio'\nimport { useAudioRecorder } from './useAudioRecorder'\n\nexport * from './utils/convertPCMToFloat32'\nexport * from './utils/getWavFileInfo'\nexport * from './utils/writeWavHeader'\n\nexport {\n    AudioRecorderProvider,\n    ExpoAudioStreamModule,\n    extractRawWavAnalysis,\n    extractAudioAnalysis,\n    extractPreview,\n    trimAudio,\n    extractAudioData,\n    extractMelSpectrogram,\n    useAudioRecorder,\n    useSharedAudioRecorder,\n}\n\nexport type * from './AudioAnalysis/AudioAnalysis.types'\nexport type * from './ExpoAudioStream.types'\n"]}

package/build/trimAudio.d.ts

@@ -0,0 +1,25 @@
+import { TrimAudioOptions, TrimAudioResult, TrimProgressEvent } from './ExpoAudioStream.types';
+/**
+ * Trims an audio file based on the provided options.
+ *
+ * @experimental This API is experimental and not fully optimized for production use.
+ * Performance may vary based on file size and device capabilities.
+ * Future versions may include breaking changes.
+ *
+ * @param options Configuration options for the trimming operation
+ * @param progressCallback Optional callback to receive progress updates
+ * @returns Promise resolving to the trimmed audio file information, including processing time
+ */
+export declare function trimAudio(options: TrimAudioOptions, progressCallback?: (event: TrimProgressEvent) => void): Promise<TrimAudioResult>;
+/**
+ * Simplified version of trimAudio that returns only the URI of the trimmed file.
+ *
+ * @experimental This API is experimental and not fully optimized for production use.
+ * Performance may vary based on file size and device capabilities.
+ * Future versions may include breaking changes.
+ *
+ * @param options Configuration options for the trimming operation
+ * @returns Promise resolving to the URI of the trimmed audio file
+ */
+export declare function trimAudioSimple(options: TrimAudioOptions): Promise<string>;
+//# sourceMappingURL=trimAudio.d.ts.map

package/build/trimAudio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trimAudio.d.ts","sourceRoot":"","sources":["../src/trimAudio.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACpB,MAAM,yBAAyB,CAAA;AAMhC;;;;;;;;;;GAUG;AACH,wBAAsB,SAAS,CAC3B,OAAO,EAAE,gBAAgB,EACzB,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GACtD,OAAO,CAAC,eAAe,CAAC,CA8C1B;AAED;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CACjC,OAAO,EAAE,gBAAgB,GAC1B,OAAO,CAAC,MAAM,CAAC,CAGjB"}

package/build/trimAudio.js

@@ -0,0 +1,67 @@
+import { LegacyEventEmitter } from 'expo-modules-core';
+import ExpoAudioStreamModule from './ExpoAudioStreamModule';
+// Create a single emitter instance
+const emitter = new LegacyEventEmitter(ExpoAudioStreamModule);
+/**
+ * Trims an audio file based on the provided options.
+ *
+ * @experimental This API is experimental and not fully optimized for production use.
+ * Performance may vary based on file size and device capabilities.
+ * Future versions may include breaking changes.
+ *
+ * @param options Configuration options for the trimming operation
+ * @param progressCallback Optional callback to receive progress updates
+ * @returns Promise resolving to the trimmed audio file information, including processing time
+ */
+export async function trimAudio(options, progressCallback) {
+    // Validation
+    if (!options.fileUri) {
+        throw new Error('fileUri is required');
+    }
+    const mode = options.mode ?? 'single';
+    if (mode === 'single') {
+        if (options.startTimeMs === undefined &&
+            options.endTimeMs === undefined) {
+            throw new Error('At least one of startTimeMs or endTimeMs must be provided in single mode');
+        }
+    }
+    else if (mode === 'keep' || mode === 'remove') {
+        if (!options.ranges || options.ranges.length === 0) {
+            throw new Error('ranges must be provided and non-empty for keep or remove modes');
+        }
+    }
+    else {
+        throw new Error(`Invalid mode: ${mode}. Must be 'single', 'keep', or 'remove'`);
+    }
+    // Set up progress event listener if callback is provided
+    let subscription;
+    if (progressCallback) {
+        subscription = emitter.addListener('TrimProgress', (event) => {
+            progressCallback(event);
+        });
+    }
+    try {
+        const result = await ExpoAudioStreamModule.trimAudio(options);
+        return result;
+    }
+    finally {
+        if (subscription) {
+            subscription.remove();
+        }
+    }
+}
+/**
+ * Simplified version of trimAudio that returns only the URI of the trimmed file.
+ *
+ * @experimental This API is experimental and not fully optimized for production use.
+ * Performance may vary based on file size and device capabilities.
+ * Future versions may include breaking changes.
+ *
+ * @param options Configuration options for the trimming operation
+ * @returns Promise resolving to the URI of the trimmed audio file
+ */
+export async function trimAudioSimple(options) {
+    const result = await trimAudio(options);
+    return result.uri;
+}
+//# sourceMappingURL=trimAudio.js.map

package/build/trimAudio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trimAudio.js","sourceRoot":"","sources":["../src/trimAudio.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAA0B,MAAM,mBAAmB,CAAA;AAO9E,OAAO,qBAAqB,MAAM,yBAAyB,CAAA;AAE3D,mCAAmC;AACnC,MAAM,OAAO,GAAG,IAAI,kBAAkB,CAAC,qBAAqB,CAAC,CAAA;AAE7D;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAC3B,OAAyB,EACzB,gBAAqD;IAErD,aAAa;IACb,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAA;IAC1C,CAAC;IACD,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,QAAQ,CAAA;IACrC,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;QACpB,IACI,OAAO,CAAC,WAAW,KAAK,SAAS;YACjC,OAAO,CAAC,SAAS,KAAK,SAAS,EACjC,CAAC;YACC,MAAM,IAAI,KAAK,CACX,0EAA0E,CAC7E,CAAA;QACL,CAAC;IACL,CAAC;SAAM,IAAI,IAAI,KAAK,MAAM,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC9C,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CACX,gEAAgE,CACnE,CAAA;QACL,CAAC;IACL,CAAC;SAAM,CAAC;QACJ,MAAM,IAAI,KAAK,CACX,iBAAiB,IAAI,yCAAyC,CACjE,CAAA;IACL,CAAC;IAED,yDAAyD;IACzD,IAAI,YAA2C,CAAA;IAC/C,IAAI,gBAAgB,EAAE,CAAC;QACnB,YAAY,GAAG,OAAO,CAAC,WAAW,CAC9B,cAAc,EACd,CAAC,KAAwB,EAAE,EAAE;YACzB,gBAAgB,CAAC,KAAK,CAAC,CAAA;QAC3B,CAAC,CACJ,CAAA;IACL,CAAC;IAED,IAAI,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,qBAAqB,CAAC,SAAS,CAAC,OAAO,CAAC,CAAA;QAC7D,OAAO,MAAM,CAAA;IACjB,CAAC;YAAS,CAAC;QACP,IAAI,YAAY,EAAE,CAAC;YACf,YAAY,CAAC,MAAM,EAAE,CAAA;QACzB,CAAC;IACL,CAAC;AACL,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACjC,OAAyB;IAEzB,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,OAAO,CAAC,CAAA;IACvC,OAAO,MAAM,CAAC,GAAG,CAAA;AACrB,CAAC","sourcesContent":["import { LegacyEventEmitter, type EventSubscription } from 'expo-modules-core'\n\nimport {\n    TrimAudioOptions,\n    TrimAudioResult,\n    TrimProgressEvent,\n} from './ExpoAudioStream.types'\nimport ExpoAudioStreamModule from './ExpoAudioStreamModule'\n\n// Create a single emitter instance\nconst emitter = new LegacyEventEmitter(ExpoAudioStreamModule)\n\n/**\n * Trims an audio file based on the provided options.\n *\n * @experimental This API is experimental and not fully optimized for production use.\n * Performance may vary based on file size and device capabilities.\n * Future versions may include breaking changes.\n *\n * @param options Configuration options for the trimming operation\n * @param progressCallback Optional callback to receive progress updates\n * @returns Promise resolving to the trimmed audio file information, including processing time\n */\nexport async function trimAudio(\n    options: TrimAudioOptions,\n    progressCallback?: (event: TrimProgressEvent) => void\n): Promise<TrimAudioResult> {\n    // Validation\n    if (!options.fileUri) {\n        throw new Error('fileUri is required')\n    }\n    const mode = options.mode ?? 'single'\n    if (mode === 'single') {\n        if (\n            options.startTimeMs === undefined &&\n            options.endTimeMs === undefined\n        ) {\n            throw new Error(\n                'At least one of startTimeMs or endTimeMs must be provided in single mode'\n            )\n        }\n    } else if (mode === 'keep' || mode === 'remove') {\n        if (!options.ranges || options.ranges.length === 0) {\n            throw new Error(\n                'ranges must be provided and non-empty for keep or remove modes'\n            )\n        }\n    } else {\n        throw new Error(\n            `Invalid mode: ${mode}. Must be 'single', 'keep', or 'remove'`\n        )\n    }\n\n    // Set up progress event listener if callback is provided\n    let subscription: EventSubscription | undefined\n    if (progressCallback) {\n        subscription = emitter.addListener(\n            'TrimProgress',\n            (event: TrimProgressEvent) => {\n                progressCallback(event)\n            }\n        )\n    }\n\n    try {\n        const result = await ExpoAudioStreamModule.trimAudio(options)\n        return result\n    } finally {\n        if (subscription) {\n            subscription.remove()\n        }\n    }\n}\n\n/**\n * Simplified version of trimAudio that returns only the URI of the trimmed file.\n *\n * @experimental This API is experimental and not fully optimized for production use.\n * Performance may vary based on file size and device capabilities.\n * Future versions may include breaking changes.\n *\n * @param options Configuration options for the trimming operation\n * @returns Promise resolving to the URI of the trimmed audio file\n */\nexport async function trimAudioSimple(\n    options: TrimAudioOptions\n): Promise<string> {\n    const result = await trimAudio(options)\n    return result.uri\n}\n"]}

package/build/useAudioRecorder.d.ts

@@ -0,0 +1,21 @@
+import { AudioAnalysis } from './AudioAnalysis/AudioAnalysis.types';
+import { AudioRecording, CompressionInfo, ConsoleLike, RecordingConfig, StartRecordingResult } from './ExpoAudioStream.types';
+export interface UseAudioRecorderProps {
+    logger?: ConsoleLike;
+    audioWorkletUrl?: string;
+    featuresExtratorUrl?: string;
+}
+export interface UseAudioRecorderState {
+    startRecording: (_: RecordingConfig) => Promise<StartRecordingResult>;
+    stopRecording: () => Promise<AudioRecording>;
+    pauseRecording: () => Promise<void>;
+    resumeRecording: () => Promise<void>;
+    isRecording: boolean;
+    isPaused: boolean;
+    durationMs: number;
+    size: number;
+    compression?: CompressionInfo;
+    analysisData?: AudioAnalysis;
+}
+export declare function useAudioRecorder({ logger, audioWorkletUrl, featuresExtratorUrl, }?: UseAudioRecorderProps): UseAudioRecorderState;
+//# sourceMappingURL=useAudioRecorder.d.ts.map

package/build/useAudioRecorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAudioRecorder.d.ts","sourceRoot":"","sources":["../src/useAudioRecorder.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAA;AACnE,OAAO,EAEH,cAAc,EAEd,eAAe,EACf,WAAW,EACX,eAAe,EACf,oBAAoB,EACvB,MAAM,yBAAyB,CAAA;AAShC,MAAM,WAAW,qBAAqB;IAClC,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC/B;AAED,MAAM,WAAW,qBAAqB;IAClC,cAAc,EAAE,CAAC,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC,oBAAoB,CAAC,CAAA;IACrE,aAAa,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,CAAA;IAC5C,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IACnC,eAAe,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IACpC,WAAW,EAAE,OAAO,CAAA;IACpB,QAAQ,EAAE,OAAO,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,eAAe,CAAA;IAC7B,YAAY,CAAC,EAAE,aAAa,CAAA;CAC/B;AAkHD,wBAAgB,gBAAgB,CAAC,EAC7B,MAAM,EACN,eAAe,EACf,mBAAmB,GACtB,GAAE,qBAA0B,GAAG,qBAAqB,CA8cpD"}

package/build/useAudioRecorder.js

@@ -0,0 +1,427 @@
+// src/useAudioRecorder.ts
+import { Platform } from 'expo-modules-core';
+import { useCallback, useEffect, useReducer, useRef } from 'react';
+import ExpoAudioStreamModule from './ExpoAudioStreamModule';
+import { addAudioAnalysisListener, addAudioEventListener, addRecordingInterruptionListener, } from './events';
+const defaultAnalysis = {
+    segmentDurationMs: 100,
+    bitDepth: 32,
+    numberOfChannels: 1,
+    durationMs: 0,
+    sampleRate: 44100,
+    samples: 0,
+    dataPoints: [],
+    rmsRange: {
+        min: Number.POSITIVE_INFINITY,
+        max: Number.NEGATIVE_INFINITY,
+    },
+    amplitudeRange: {
+        min: Number.POSITIVE_INFINITY,
+        max: Number.NEGATIVE_INFINITY,
+    },
+};
+function audioRecorderReducer(state, action) {
+    switch (action.type) {
+        case 'START':
+            return {
+                ...state,
+                isRecording: true,
+                isPaused: false,
+                durationMs: 0,
+                size: 0,
+                compression: undefined,
+                analysisData: defaultAnalysis,
+            };
+        case 'STOP':
+            return {
+                ...state,
+                isRecording: false,
+                isPaused: false,
+                durationMs: 0,
+                size: 0,
+                compression: undefined,
+                analysisData: undefined,
+            };
+        case 'PAUSE':
+            return { ...state, isPaused: true, isRecording: false };
+        case 'RESUME':
+            return { ...state, isPaused: false, isRecording: true };
+        case 'UPDATE_RECORDING_STATE':
+            return {
+                ...state,
+                isPaused: action.payload.isPaused,
+                isRecording: action.payload.isRecording,
+            };
+        case 'UPDATE_STATUS': {
+            const newState = {
+                ...state,
+                durationMs: action.payload.durationMs,
+                size: action.payload.size,
+                compression: action.payload.compression
+                    ? {
+                        size: action.payload.compression.size,
+                        mimeType: action.payload.compression.mimeType,
+                        bitrate: action.payload.compression.bitrate,
+                        format: action.payload.compression.format,
+                    }
+                    : undefined,
+            };
+            return newState;
+        }
+        case 'UPDATE_ANALYSIS':
+            return {
+                ...state,
+                analysisData: action.payload,
+            };
+        default:
+            return state;
+    }
+}
+export function useAudioRecorder({ logger, audioWorkletUrl, featuresExtratorUrl, } = {}) {
+    const [state, dispatch] = useReducer(audioRecorderReducer, {
+        isRecording: false,
+        isPaused: false,
+        durationMs: 0,
+        size: 0,
+        compression: undefined,
+        analysisData: undefined,
+    });
+    const startResultRef = useRef(null);
+    const analysisListenerRef = useRef(null);
+    // analysisRef is the current analysis data (last 10 seconds by default)
+    const analysisRef = useRef({ ...defaultAnalysis });
+    // fullAnalysisRef is the full analysis data (all data points)
+    const fullAnalysisRef = useRef({
+        ...defaultAnalysis,
+    });
+    // Instantiate the module for web with URLs
+    const ExpoAudioStream = Platform.OS === 'web'
+        ? ExpoAudioStreamModule({
+            audioWorkletUrl,
+            featuresExtratorUrl,
+            logger,
+        })
+        : ExpoAudioStreamModule;
+    const onAudioStreamRef = useRef(null);
+    const stateRef = useRef({
+        isRecording: false,
+        isPaused: false,
+        durationMs: 0,
+        size: 0,
+        compression: undefined,
+    });
+    const recordingConfigRef = useRef(null);
+    const handleAudioAnalysis = useCallback(async ({ analysis, visualizationDuration, }) => {
+        const savedAnalysisData = analysisRef.current || {
+            ...defaultAnalysis,
+        };
+        const maxDuration = visualizationDuration;
+        logger?.debug(`[handleAudioAnalysis] Received audio analysis: maxDuration=${maxDuration} analysis.dataPoints=${analysis.dataPoints.length} analysisData.dataPoints=${savedAnalysisData.dataPoints.length}`, analysis);
+        // Combine data points
+        const combinedDataPoints = [
+            ...savedAnalysisData.dataPoints,
+            ...analysis.dataPoints,
+        ];
+        const fullCombinedDataPoints = [
+            ...(fullAnalysisRef.current?.dataPoints ?? []),
+            ...analysis.dataPoints,
+        ];
+        // Calculate the new duration
+        // The number of segments is based on how many segments of segmentDurationMs can fit in visualizationDuration
+        const numberOfSegments = Math.ceil(visualizationDuration / analysis.segmentDurationMs);
+        // maxDataPoints should be the number of data points, not milliseconds
+        const maxDataPoints = numberOfSegments;
+        logger?.debug(`[handleAudioAnalysis] Combined data points before trimming: numberOfSegments=${numberOfSegments} visualizationDuration=${visualizationDuration} combinedDataPointsLength=${combinedDataPoints.length} vs maxDataPoints=${maxDataPoints}`);
+        // Trim data points to keep within the maximum number of data points
+        if (combinedDataPoints.length > maxDataPoints) {
+            combinedDataPoints.splice(0, combinedDataPoints.length - maxDataPoints);
+        }
+        // Keep the full data points
+        fullAnalysisRef.current = {
+            ...fullAnalysisRef.current,
+            dataPoints: fullCombinedDataPoints,
+        };
+        fullAnalysisRef.current.durationMs =
+            fullCombinedDataPoints.length * analysis.segmentDurationMs;
+        savedAnalysisData.dataPoints = combinedDataPoints;
+        savedAnalysisData.bitDepth =
+            analysis.bitDepth || savedAnalysisData.bitDepth;
+        savedAnalysisData.durationMs =
+            combinedDataPoints.length * analysis.segmentDurationMs;
+        // Update amplitude range
+        const newMin = Math.min(savedAnalysisData.amplitudeRange.min, analysis.amplitudeRange.min);
+        const newMax = Math.max(savedAnalysisData.amplitudeRange.max, analysis.amplitudeRange.max);
+        savedAnalysisData.amplitudeRange = {
+            min: newMin,
+            max: newMax,
+        };
+        fullAnalysisRef.current.amplitudeRange = {
+            min: newMin,
+            max: newMax,
+        };
+        logger?.debug(`[handleAudioAnalysis] Updated analysis data: durationMs=${savedAnalysisData.durationMs}`, savedAnalysisData);
+        // Call the onAudioAnalysis callback if it exists in the recording config
+        if (recordingConfigRef.current?.onAudioAnalysis) {
+            recordingConfigRef.current
+                .onAudioAnalysis(analysis)
+                .catch((error) => {
+                logger?.warn(`Error processing audio analysis:`, error);
+            });
+        }
+        // Update the ref
+        analysisRef.current = savedAnalysisData;
+        // Dispatch the updated analysis data to state to trigger re-render
+        dispatch({
+            type: 'UPDATE_ANALYSIS',
+            payload: { ...savedAnalysisData },
+        });
+    }, [dispatch]);
+    const handleAudioEvent = useCallback(async (eventData) => {
+        const { fileUri, deltaSize, totalSize, lastEmittedSize, position, streamUuid, encoded, mimeType, buffer, compression, } = eventData;
+        logger?.debug(`[handleAudioEvent] Received audio event:`, {
+            fileUri,
+            deltaSize,
+            totalSize,
+            position,
+            mimeType,
+            lastEmittedSize,
+            streamUuid,
+            encodedLength: encoded?.length,
+            compression,
+        });
+        if (deltaSize === 0) {
+            // Ignore packet with no data
+            return;
+        }
+        try {
+            // Coming from native ( ios / android ) otherwise buffer is set
+            if (Platform.OS !== 'web') {
+                // Read the audio file as a base64 string for comparison
+                if (!encoded) {
+                    logger?.error(`Encoded audio data is missing`);
+                    throw new Error('Encoded audio data is missing');
+                }
+                onAudioStreamRef.current?.({
+                    data: encoded,
+                    position,
+                    fileUri,
+                    eventDataSize: deltaSize,
+                    totalSize,
+                    compression: compression && startResultRef.current?.compression
+                        ? {
+                            data: compression.data,
+                            size: compression.totalSize,
+                            mimeType: startResultRef.current.compression
+                                ?.mimeType,
+                            bitrate: startResultRef.current.compression
+                                ?.bitrate,
+                            format: startResultRef.current.compression
+                                ?.format,
+                        }
+                        : undefined,
+                });
+            }
+            else if (buffer) {
+                // Coming from web
+                const webEvent = {
+                    data: buffer,
+                    position,
+                    fileUri,
+                    eventDataSize: deltaSize,
+                    totalSize,
+                    compression: compression && startResultRef.current?.compression
+                        ? {
+                            data: compression.data,
+                            size: compression.totalSize,
+                            mimeType: startResultRef.current.compression
+                                ?.mimeType,
+                            bitrate: startResultRef.current.compression
+                                ?.bitrate,
+                            format: startResultRef.current.compression
+                                ?.format,
+                        }
+                        : undefined,
+                };
+                onAudioStreamRef.current?.(webEvent);
+                logger?.debug(`[handleAudioEvent] Audio data sent to onAudioStream`, webEvent);
+            }
+        }
+        catch (error) {
+            logger?.error(`Error processing audio event:`, error);
+        }
+    }, []);
+    const checkStatus = useCallback(async () => {
+        try {
+            const status = ExpoAudioStream.status();
+            logger?.debug(`Status: paused: ${status.isPaused} isRecording: ${status.isRecording} durationMs: ${status.durationMs} size: ${status.size}`, status.compression);
+            // Only dispatch if values actually changed
+            if (status.isRecording !== stateRef.current.isRecording ||
+                status.isPaused !== stateRef.current.isPaused) {
+                stateRef.current.isRecording = status.isRecording;
+                stateRef.current.isPaused = status.isPaused;
+                dispatch({
+                    type: 'UPDATE_RECORDING_STATE',
+                    payload: {
+                        isRecording: status.isRecording,
+                        isPaused: status.isPaused,
+                    },
+                });
+            }
+            if (status.durationMs !== stateRef.current.durationMs ||
+                status.size !== stateRef.current.size) {
+                stateRef.current.durationMs = status.durationMs;
+                stateRef.current.size = status.size;
+                stateRef.current.compression = status.compression;
+                dispatch({
+                    type: 'UPDATE_STATUS',
+                    payload: {
+                        durationMs: status.durationMs,
+                        size: status.size,
+                        compression: status.compression,
+                    },
+                });
+            }
+        }
+        catch (error) {
+            logger?.error(`Error getting status:`, error);
+        }
+    }, [ExpoAudioStream, logger]); // Only depend on ExpoAudioStream and logger
+    // Update ref when state changes
+    useEffect(() => {
+        stateRef.current = {
+            isRecording: state.isRecording,
+            isPaused: state.isPaused,
+            durationMs: state.durationMs,
+            size: state.size,
+            compression: state.compression,
+        };
+    }, [
+        state.isRecording,
+        state.isPaused,
+        state.durationMs,
+        state.size,
+        state.compression,
+    ]);
+    const startRecording = useCallback(async (recordingOptions) => {
+        recordingConfigRef.current = recordingOptions;
+        logger?.debug(`start recoding`, recordingOptions);
+        analysisRef.current = { ...defaultAnalysis }; // Reset analysis data
+        fullAnalysisRef.current = { ...defaultAnalysis };
+        const { onAudioStream, ...options } = recordingOptions;
+        const { enableProcessing } = options;
+        const maxRecentDataDuration = 10000; // TODO compute maxRecentDataDuration based on screen dimensions
+        if (typeof onAudioStream === 'function') {
+            onAudioStreamRef.current = onAudioStream;
+        }
+        else {
+            logger?.warn(`onAudioStream is not a function`, onAudioStream);
+            onAudioStreamRef.current = null;
+        }
+        const startResult = await ExpoAudioStream.startRecording(options);
+        dispatch({ type: 'START' });
+        startResultRef.current = startResult;
+        if (enableProcessing) {
+            logger?.debug(`Enabling audio analysis listener`);
+            const listener = addAudioAnalysisListener(async (analysisData) => {
+                try {
+                    await handleAudioAnalysis({
+                        analysis: analysisData,
+                        visualizationDuration: maxRecentDataDuration,
+                    });
+                }
+                catch (error) {
+                    logger?.warn(`Error processing audio analysis:`, error);
+                }
+            });
+            analysisListenerRef.current = listener;
+        }
+        return startResult;
+    }, [handleAudioAnalysis, dispatch]);
+    const stopRecording = useCallback(async () => {
+        logger?.debug(`stoping recording`);
+        const stopResult = await ExpoAudioStream.stopRecording();
+        stopResult.analysisData = fullAnalysisRef.current;
+        if (analysisListenerRef.current) {
+            analysisListenerRef.current.remove();
+            analysisListenerRef.current = null;
+        }
+        onAudioStreamRef.current = null;
+        logger?.debug(`recording stopped`, stopResult);
+        dispatch({ type: 'STOP' });
+        return stopResult;
+    }, [dispatch]);
+    const pauseRecording = useCallback(async () => {
+        logger?.debug(`pause recording`);
+        const pauseResult = await ExpoAudioStream.pauseRecording();
+        dispatch({ type: 'PAUSE' });
+        return pauseResult;
+    }, [dispatch]);
+    const resumeRecording = useCallback(async () => {
+        logger?.debug(`resume recording`);
+        const resumeResult = await ExpoAudioStream.resumeRecording();
+        dispatch({ type: 'RESUME' });
+        return resumeResult;
+    }, [dispatch]);
+    useEffect(() => {
+        let intervalId;
+        if (state.isRecording || state.isPaused) {
+            // Immediately check status when starting
+            checkStatus();
+            // Start interval
+            intervalId = setInterval(checkStatus, 1000);
+        }
+        return () => {
+            if (intervalId) {
+                clearInterval(intervalId);
+                intervalId = undefined;
+            }
+        };
+    }, [checkStatus, state.isRecording, state.isPaused]);
+    useEffect(() => {
+        logger?.debug(`Registering audio event listener`);
+        const subscribeAudio = addAudioEventListener(handleAudioEvent);
+        logger?.debug(`Subscribed to audio event listener and analysis listener`, {
+            subscribeAudio,
+        });
+        return () => {
+            logger?.debug(`Removing audio event listener`);
+            subscribeAudio.remove();
+        };
+    }, [handleAudioEvent, handleAudioAnalysis]);
+    useEffect(() => {
+        // Add event subscription for recording interruptions
+        logger?.debug('Setting up recording interruption listener');
+        const subscription = addRecordingInterruptionListener((event) => {
+            logger?.debug('Received recording interruption event:', event);
+            // Check if we have a callback configured
+            if (recordingConfigRef.current?.onRecordingInterrupted) {
+                try {
+                    recordingConfigRef.current.onRecordingInterrupted(event);
+                }
+                catch (error) {
+                    logger?.error('Error in recording interruption callback:', error);
+                }
+            }
+            else {
+                logger?.warn('No recording interruption callback configured');
+            }
+        });
+        return () => {
+            logger?.debug('Removing recording interruption listener');
+            subscription.remove();
+        };
+    }, []); // Empty dependency array since we want this to run once
+    return {
+        startRecording,
+        stopRecording,
+        pauseRecording,
+        resumeRecording,
+        isPaused: state.isPaused,
+        isRecording: state.isRecording,
+        durationMs: state.durationMs,
+        size: state.size,
+        compression: state.compression,
+        analysisData: state.analysisData,
+    };
+}
+//# sourceMappingURL=useAudioRecorder.js.map