@siteed/expo-audio-studio 2.18.6 → 3.0.0

package/build/cjs/trimAudio.js

@@ -1,76 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trimAudio = trimAudio;
-exports.trimAudioSimple = trimAudioSimple;
-const expo_modules_core_1 = require("expo-modules-core");
-const ExpoAudioStreamModule_1 = __importDefault(require("./ExpoAudioStreamModule"));
-const cleanNativeOptions_1 = require("./utils/cleanNativeOptions");
-// Create a single emitter instance
-const emitter = new expo_modules_core_1.LegacyEventEmitter(ExpoAudioStreamModule_1.default);
-/**
- * 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
- */
-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 {
-        // Clean non-serializable/undefined values to avoid Android Kotlin bridge crash
-        const result = await ExpoAudioStreamModule_1.default.trimAudio((0, cleanNativeOptions_1.cleanNativeOptions)(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
- */
-async function trimAudioSimple(options) {
-    const result = await trimAudio(options);
-    return result.uri;
-}
-//# sourceMappingURL=trimAudio.js.map

package/build/cjs/trimAudio.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"trimAudio.js","sourceRoot":"","sources":["../../src/trimAudio.ts"],"names":[],"mappings":";;;;;AAwBA,8BAoDC;AAYD,0CAKC;AA7FD,yDAA8E;AAO9E,oFAA2D;AAC3D,mEAA+D;AAE/D,mCAAmC;AACnC,MAAM,OAAO,GAAG,IAAI,sCAAkB,CAAC,+BAAqB,CAAC,CAAA;AAE7D;;;;;;;;;;GAUG;AACI,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,+EAA+E;QAC/E,MAAM,MAAM,GAAG,MAAM,+BAAqB,CAAC,SAAS,CAChD,IAAA,uCAAkB,EAAC,OAAO,CAAC,CAC9B,CAAA;QACD,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;AACI,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'\nimport { cleanNativeOptions } from './utils/cleanNativeOptions'\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        // Clean non-serializable/undefined values to avoid Android Kotlin bridge crash\n        const result = await ExpoAudioStreamModule.trimAudio(\n            cleanNativeOptions(options)\n        )\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/cjs/useAudioRecorder.js

@@ -1,518 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useAudioRecorder = useAudioRecorder;
-// src/useAudioRecorder.ts
-const expo_modules_core_1 = require("expo-modules-core");
-const react_1 = require("react");
-const AudioDeviceManager_1 = require("./AudioDeviceManager");
-const ExpoAudioStreamModule_1 = __importDefault(require("./ExpoAudioStreamModule"));
-const platformLimitations_1 = require("./constants/platformLimitations");
-const events_1 = require("./events");
-const cleanNativeOptions_1 = require("./utils/cleanNativeOptions");
-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,
-    },
-    extractionTimeMs: 0,
-};
-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;
-    }
-}
-function useAudioRecorder({ logger, audioWorkletUrl, featuresExtratorUrl, } = {}) {
-    // Initialize AudioDeviceManager with logger (once)
-    if (logger) {
-        AudioDeviceManager_1.audioDeviceManager.setLogger(logger);
-    }
-    const [state, dispatch] = (0, react_1.useReducer)(audioRecorderReducer, {
-        isRecording: false,
-        isPaused: false,
-        durationMs: 0,
-        size: 0,
-        compression: undefined,
-        analysisData: undefined,
-    });
-    const startResultRef = (0, react_1.useRef)(null);
-    const analysisListenerRef = (0, react_1.useRef)(null);
-    // analysisRef is the current analysis data (last 10 seconds by default)
-    const analysisRef = (0, react_1.useRef)({ ...defaultAnalysis });
-    // fullAnalysisRef is the full analysis data (all data points)
-    const fullAnalysisRef = (0, react_1.useRef)({
-        ...defaultAnalysis,
-    });
-    // Instantiate the module for web with URLs
-    const ExpoAudioStream = expo_modules_core_1.Platform.OS === 'web'
-        ? (0, ExpoAudioStreamModule_1.default)({
-            audioWorkletUrl,
-            featuresExtratorUrl,
-            logger,
-        })
-        : ExpoAudioStreamModule_1.default;
-    const onAudioStreamRef = (0, react_1.useRef)(null);
-    const stateRef = (0, react_1.useRef)({
-        isRecording: false,
-        isPaused: false,
-        durationMs: 0,
-        size: 0,
-        compression: undefined,
-    });
-    const recordingConfigRef = (0, react_1.useRef)(null);
-    // Generate unique instance ID for debugging
-    const instanceId = (0, react_1.useId)().replace(/:/g, '').slice(0, 5);
-    const handleAudioAnalysis = (0, react_1.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}`);
-        // 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}`, { dataPoints: savedAnalysisData.dataPoints.length });
-        // 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 = (0, react_1.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 (expo_modules_core_1.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 = (0, react_1.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
-    (0, react_1.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 = (0, react_1.useCallback)(async (recordingOptions) => {
-        // Validate the encoding configuration
-        const validationResult = (0, platformLimitations_1.validateRecordingConfig)({
-            encoding: recordingOptions.encoding,
-        });
-        // Log warnings if any
-        if (validationResult.warnings.length > 0) {
-            validationResult.warnings.forEach((warning) => {
-                logger?.warn(warning);
-            });
-        }
-        // Update recording options with validated values
-        const validatedOptions = {
-            ...recordingOptions,
-            encoding: validationResult.encoding,
-        };
-        recordingConfigRef.current = validatedOptions;
-        logger?.debug(`start recording with validated config`, validatedOptions);
-        analysisRef.current = { ...defaultAnalysis }; // Reset analysis data
-        fullAnalysisRef.current = { ...defaultAnalysis };
-        const { onAudioStream, onRecordingInterrupted, onAudioAnalysis, ...options } = validatedOptions;
-        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;
-        }
-        // Strip undefined values and functions that can't cross the native bridge
-        const cleanOptions = (0, cleanNativeOptions_1.cleanNativeOptions)(options);
-        const startResult = await ExpoAudioStream.startRecording(cleanOptions);
-        dispatch({ type: 'START' });
-        startResultRef.current = startResult;
-        if (enableProcessing) {
-            logger?.debug(`Enabling audio analysis listener`);
-            const listener = (0, events_1.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 prepareRecording = (0, react_1.useCallback)(async (recordingOptions) => {
-        recordingConfigRef.current = recordingOptions;
-        logger?.debug(`preparing recording`, recordingOptions);
-        analysisRef.current = { ...defaultAnalysis }; // Reset analysis data
-        fullAnalysisRef.current = { ...defaultAnalysis };
-        const { onAudioStream, onRecordingInterrupted, onAudioAnalysis, ...options } = recordingOptions;
-        // Store onAudioStream for later use when recording starts
-        if (typeof onAudioStream === 'function') {
-            onAudioStreamRef.current = onAudioStream;
-        }
-        else {
-            logger?.warn(`onAudioStream is not a function`, onAudioStream);
-            onAudioStreamRef.current = null;
-        }
-        // Strip undefined values and functions that can't cross the native bridge
-        const cleanOptions = (0, cleanNativeOptions_1.cleanNativeOptions)(options);
-        // Call the native prepareRecording method
-        await ExpoAudioStream.prepareRecording(cleanOptions);
-        logger?.debug(`recording prepared successfully`);
-    }, []);
-    const stopRecording = (0, react_1.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;
-        // Note: We deliberately DON'T clear recordingConfigRef here to preserve interruption callback
-        logger?.debug(`recording stopped`, stopResult);
-        dispatch({ type: 'STOP' });
-        return stopResult;
-    }, [dispatch]);
-    const pauseRecording = (0, react_1.useCallback)(async () => {
-        logger?.debug(`pause recording`);
-        const pauseResult = await ExpoAudioStream.pauseRecording();
-        dispatch({ type: 'PAUSE' });
-        return pauseResult;
-    }, [dispatch]);
-    const resumeRecording = (0, react_1.useCallback)(async () => {
-        logger?.debug(`resume recording`);
-        const resumeResult = await ExpoAudioStream.resumeRecording();
-        dispatch({ type: 'RESUME' });
-        return resumeResult;
-    }, [dispatch]);
-    (0, react_1.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]);
-    (0, react_1.useEffect)(() => {
-        logger?.debug(`Registering audio event listener`);
-        const subscribeAudio = (0, events_1.addAudioEventListener)(handleAudioEvent);
-        logger?.debug(`Subscribed to audio event listener and analysis listener`, {
-            subscribeAudio,
-        });
-        return () => {
-            logger?.debug(`Removing audio event listener`);
-            subscribeAudio.remove();
-        };
-    }, [handleAudioEvent, handleAudioAnalysis]);
-    (0, react_1.useEffect)(() => {
-        // Add event subscription for recording interruptions
-        logger?.debug(`Setting up recording interruption listener [${instanceId}]`);
-        const subscription = (0, events_1.addRecordingInterruptionListener)((event) => {
-            logger?.debug(`[${instanceId}] Received recording interruption event:`, event);
-            // Handle device disconnection for UI updates
-            if (event.reason === 'deviceDisconnected') {
-                logger?.debug(`[${instanceId}] Device disconnected - temporarily hiding last device from UI`);
-                // Get current device list before the native layer updates
-                const currentDevices = AudioDeviceManager_1.audioDeviceManager.getRawDevices();
-                // Wait a moment for native layer to update, then compare
-                setTimeout(async () => {
-                    try {
-                        // Get updated devices without notifying yet
-                        const updatedDevices = await AudioDeviceManager_1.audioDeviceManager.getAvailableDevices({
-                            refresh: true,
-                        });
-                        // Find missing devices by comparing lists
-                        const missingDevices = currentDevices.filter((oldDevice) => !updatedDevices.some((newDevice) => newDevice.id === oldDevice.id));
-                        if (missingDevices.length > 0) {
-                            // Mark all missing devices as disconnected (silently)
-                            missingDevices.forEach((missingDevice) => {
-                                logger?.debug(`[${instanceId}] Confirmed disconnected device: ${missingDevice.name} (${missingDevice.id})`);
-                                AudioDeviceManager_1.audioDeviceManager.markDeviceAsDisconnected(missingDevice.id, false);
-                            });
-                        }
-                        // Notify listeners once with the final filtered state
-                        AudioDeviceManager_1.audioDeviceManager.notifyListeners();
-                    }
-                    catch (error) {
-                        logger?.warn(`[${instanceId}] Error in delayed device disconnection handling:`, error);
-                    }
-                }, 500); // 500ms delay to let native layer update
-            }
-            else if (event.reason === 'deviceConnected') {
-                // Device reconnected - force refresh to show it immediately
-                logger?.debug(`[${instanceId}] Device connected, forcing refresh`);
-                AudioDeviceManager_1.audioDeviceManager.forceRefreshDevices();
-            }
-            // Check if we have a callback configured
-            logger?.debug(`[${instanceId}] recordingConfigRef.current exists:`, !!recordingConfigRef.current);
-            if (recordingConfigRef.current?.onRecordingInterrupted) {
-                try {
-                    logger?.debug(`[${instanceId}] Calling recording interruption callback`);
-                    recordingConfigRef.current.onRecordingInterrupted(event);
-                }
-                catch (error) {
-                    logger?.error(`[${instanceId}] Error in recording interruption callback:`, error);
-                }
-            }
-            else {
-                logger?.debug(`[${instanceId}] No recording interruption callback configured`);
-            }
-        });
-        return () => {
-            logger?.debug(`[${instanceId}] Removing recording interruption listener`);
-            subscription.remove();
-        };
-    }, [instanceId, logger]); // Include instanceId and logger in dependencies
-    return {
-        prepareRecording,
-        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