@siteed/audio-studio 3.0.0

package/build/cjs/trimAudio.js

@@ -0,0 +1,76 @@
+"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 AudioStudioModule_1 = __importDefault(require("./AudioStudioModule"));
+const cleanNativeOptions_1 = require("./utils/cleanNativeOptions");
+// Create a single emitter instance
+const emitter = new expo_modules_core_1.LegacyEventEmitter(AudioStudioModule_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 AudioStudioModule_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

@@ -0,0 +1 @@
+{"version":3,"file":"trimAudio.js","sourceRoot":"","sources":["../../src/trimAudio.ts"],"names":[],"mappings":";;;;;AAwBA,8BAoDC;AAYD,0CAKC;AA7FD,yDAA8E;AAO9E,4EAAmD;AACnD,mEAA+D;AAE/D,mCAAmC;AACnC,MAAM,OAAO,GAAG,IAAI,sCAAkB,CAAC,2BAAiB,CAAC,CAAA;AAEzD;;;;;;;;;;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,2BAAiB,CAAC,SAAS,CAC5C,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 './AudioStudio.types'\nimport AudioStudioModule from './AudioStudioModule'\nimport { cleanNativeOptions } from './utils/cleanNativeOptions'\n\n// Create a single emitter instance\nconst emitter = new LegacyEventEmitter(AudioStudioModule)\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 AudioStudioModule.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

@@ -0,0 +1,535 @@
+"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 AudioStudioModule_1 = __importDefault(require("./AudioStudioModule"));
+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 audioStudio = expo_modules_core_1.Platform.OS === 'web'
+        ? (0, AudioStudioModule_1.default)({
+            audioWorkletUrl,
+            featuresExtratorUrl,
+            logger,
+        })
+        : AudioStudioModule_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, pcmFloat32, 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') {
+                const compressionPayload = 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;
+                if (pcmFloat32 != null) {
+                    // Android new arch delivers Float32Array; iOS delivers number[] — normalize both
+                    const float32 = pcmFloat32 instanceof Float32Array
+                        ? pcmFloat32
+                        : new Float32Array(pcmFloat32);
+                    onAudioStreamRef.current?.({
+                        data: float32,
+                        streamFormat: 'float32',
+                        position,
+                        fileUri,
+                        eventDataSize: deltaSize,
+                        totalSize,
+                        compression: compressionPayload,
+                    });
+                }
+                else {
+                    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: compressionPayload,
+                    });
+                }
+            }
+            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 = audioStudio.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);
+        }
+    }, [audioStudio, logger]); // Only depend on audioStudio 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 audioStudio.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 audioStudio.prepareRecording(cleanOptions);
+        logger?.debug(`recording prepared successfully`);
+    }, []);
+    const stopRecording = (0, react_1.useCallback)(async () => {
+        logger?.debug(`stoping recording`);
+        const stopResult = await audioStudio.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 audioStudio.pauseRecording();
+        dispatch({ type: 'PAUSE' });
+        return pauseResult;
+    }, [dispatch]);
+    const resumeRecording = (0, react_1.useCallback)(async () => {
+        logger?.debug(`resume recording`);
+        const resumeResult = await audioStudio.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