react-native-voice-ts 1.0.1 → 1.0.3

package/dist/components/VoiceMicrophone.js

@@ -27,33 +27,77 @@ import Voice from '../index';
  * </VoiceMicrophone>
  * ```
  */
-const VoiceMicrophone = ({ onSpeechResult, onPartialResult, onStart, onStop, onError, locale = 'en-US', autoStart = false, enablePartialResults = true, children, }) => {
+const VoiceMicrophone = ({ onSpeechResult, onPartialResult, onStart, onStop, onError, locale = 'en-US', autoStart = false, enablePartialResults = true, continuous = false, maxSilenceDuration = 5000, children, }) => {
     const [isRecording, setIsRecording] = useState(false);
     const [recognizedText, setRecognizedText] = useState('');
     const [partialText, setPartialText] = useState('');
     const [error, setError] = useState(null);
+    const [shouldContinue, setShouldContinue] = useState(false);
+    const silenceTimerRef = React.useRef(null);
+    useEffect(() => {
+        // Clear any existing timers on cleanup
+        return () => {
+            if (silenceTimerRef.current) {
+                clearTimeout(silenceTimerRef.current);
+            }
+        };
+    }, []);
     useEffect(() => {
         // Set up event listeners
         Voice.onSpeechStart = () => {
             setIsRecording(true);
             setError(null);
+            if (silenceTimerRef.current) {
+                clearTimeout(silenceTimerRef.current);
+            }
             onStart?.();
         };
-        Voice.onSpeechEnd = () => {
+        Voice.onSpeechEnd = async () => {
             setIsRecording(false);
-            onStop?.();
+            // In continuous mode, restart listening after results
+            if (continuous && shouldContinue) {
+                // Small delay before restarting
+                setTimeout(async () => {
+                    if (shouldContinue) {
+                        try {
+                            await Voice.start(locale, {
+                                EXTRA_PARTIAL_RESULTS: enablePartialResults,
+                            });
+                        }
+                        catch (err) {
+                            console.error('Failed to restart voice recognition:', err);
+                        }
+                    }
+                }, 100);
+            }
+            else {
+                onStop?.();
+            }
         };
         Voice.onSpeechError = (e) => {
             const errorMessage = e.error?.message || 'Unknown error';
             setError(errorMessage);
             setIsRecording(false);
+            setShouldContinue(false);
+            if (silenceTimerRef.current) {
+                clearTimeout(silenceTimerRef.current);
+            }
             onError?.(errorMessage);
         };
         Voice.onSpeechResults = (e) => {
             if (e.value && e.value.length > 0) {
                 const text = e.value[0];
-                setRecognizedText(text);
-                onSpeechResult?.(text);
+                // In continuous mode, append new text to existing
+                if (continuous && recognizedText) {
+                    const updatedText = recognizedText + ' ' + text;
+                    setRecognizedText(updatedText);
+                    onSpeechResult?.(updatedText);
+                }
+                else {
+                    setRecognizedText(text);
+                    onSpeechResult?.(text);
+                }
+                setPartialText('');
             }
         };
         if (enablePartialResults) {
@@ -62,6 +106,15 @@ const VoiceMicrophone = ({ onSpeechResult, onPartialResult, onStart, onStop, onE
                     const text = e.value[0];
                     setPartialText(text);
                     onPartialResult?.(text);
+                    // Reset silence timer on partial results (user is speaking)
+                    if (continuous && silenceTimerRef.current) {
+                        clearTimeout(silenceTimerRef.current);
+                        silenceTimerRef.current = setTimeout(() => {
+                            if (shouldContinue) {
+                                stop();
+                            }
+                        }, maxSilenceDuration);
+                    }
                 }
             };
         }
@@ -76,6 +129,11 @@ const VoiceMicrophone = ({ onSpeechResult, onPartialResult, onStart, onStop, onE
         onStop,
         onError,
         enablePartialResults,
+        continuous,
+        shouldContinue,
+        recognizedText,
+        locale,
+        maxSilenceDuration,
     ]);
     // Auto-start if enabled
     useEffect(() => {
@@ -87,8 +145,11 @@ const VoiceMicrophone = ({ onSpeechResult, onPartialResult, onStart, onStop, onE
     const start = useCallback(async () => {
         try {
             setError(null);
-            setRecognizedText('');
-            setPartialText('');
+            if (!continuous) {
+                setRecognizedText('');
+                setPartialText('');
+            }
+            setShouldContinue(true);
             // Check permission (Android only)
             const hasPermission = await Voice.checkMicrophonePermission();
             if (!hasPermission) {
@@ -101,25 +162,52 @@ const VoiceMicrophone = ({ onSpeechResult, onPartialResult, onStart, onStop, onE
             await Voice.start(locale, {
                 EXTRA_PARTIAL_RESULTS: enablePartialResults,
             });
+            // Start silence timer if in continuous mode
+            if (continuous) {
+                silenceTimerRef.current = setTimeout(() => {
+                    if (shouldContinue) {
+                        stop();
+                    }
+                }, maxSilenceDuration);
+            }
         }
         catch (e) {
             const errorMessage = e instanceof Error ? e.message : 'Failed to start recording';
             setError(errorMessage);
+            setShouldContinue(false);
             onError?.(errorMessage);
         }
-    }, [locale, enablePartialResults, onError]);
+    }, [
+        locale,
+        enablePartialResults,
+        onError,
+        continuous,
+        maxSilenceDuration,
+        shouldContinue,
+    ]);
     const stop = useCallback(async () => {
         try {
+            setShouldContinue(false);
+            if (silenceTimerRef.current) {
+                clearTimeout(silenceTimerRef.current);
+                silenceTimerRef.current = null;
+            }
             await Voice.stop();
+            onStop?.();
         }
         catch (e) {
             const errorMessage = e instanceof Error ? e.message : 'Failed to stop recording';
             setError(errorMessage);
             onError?.(errorMessage);
         }
-    }, [onError]);
+    }, [onError, onStop]);
     const cancel = useCallback(async () => {
         try {
+            setShouldContinue(false);
+            if (silenceTimerRef.current) {
+                clearTimeout(silenceTimerRef.current);
+                silenceTimerRef.current = null;
+            }
             await Voice.cancel();
             setRecognizedText('');
             setPartialText('');
@@ -148,4 +236,3 @@ const VoiceMicrophone = ({ onSpeechResult, onPartialResult, onStart, onStop, onE
     return null;
 };
 export default VoiceMicrophone;
-//# sourceMappingURL=VoiceMicrophone.js.map

package/dist/components/index.d.ts

@@ -1,5 +1,4 @@
 export { default as VoiceMicrophone } from './VoiceMicrophone';
 export type { VoiceMicrophoneProps } from './VoiceMicrophone';
-export { MicIcon, MicOffIcon } from './MicIcon';
+export { MicIcon, MicOffIcon, MicIconFilled, MicOffIconFilled, MicIconWave, MicOffIconWave, } from './MicIcon';
 export type { MicIconProps, MicOffIconProps } from './MicIcon';
-//# sourceMappingURL=index.d.ts.map

package/dist/components/index.js

@@ -1,3 +1,2 @@
 export { default as VoiceMicrophone } from './VoiceMicrophone';
-export { MicIcon, MicOffIcon } from './MicIcon';
-//# sourceMappingURL=index.js.map
+export { MicIcon, MicOffIcon, MicIconFilled, MicOffIconFilled, MicIconWave, MicOffIconWave, } from './MicIcon';

package/dist/hooks/index.d.ts

@@ -1,3 +1,2 @@
 export { useVoiceRecognition } from './useVoiceRecognition';
 export type { UseVoiceRecognitionOptions, UseVoiceRecognitionReturn, } from './useVoiceRecognition';
-//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.js

@@ -1,2 +1 @@
 export { useVoiceRecognition } from './useVoiceRecognition';
-//# sourceMappingURL=index.js.map

package/dist/hooks/useVoiceRecognition.d.ts

@@ -9,6 +9,18 @@ export interface UseVoiceRecognitionOptions {
      * @default true
      */
     enablePartialResults?: boolean;
+    /**
+     * Whether to continue listening after getting results (continuous mode)
+     * When enabled, the microphone will automatically restart after getting results
+     * @default false
+     */
+    continuous?: boolean;
+    /**
+     * Maximum silence duration in milliseconds before stopping (continuous mode)
+     * Only applies when continuous mode is enabled
+     * @default 5000 (5 seconds)
+     */
+    maxSilenceDuration?: number;
     /**
      * Callback fired when speech is recognized
      */
@@ -74,4 +86,3 @@ export interface UseVoiceRecognitionReturn {
  * ```
  */
 export declare const useVoiceRecognition: (options?: UseVoiceRecognitionOptions) => UseVoiceRecognitionReturn;
-//# sourceMappingURL=useVoiceRecognition.d.ts.map

package/dist/hooks/useVoiceRecognition.js

@@ -1,4 +1,4 @@
-import { useEffect, useState, useCallback } from 'react';
+import React, { useEffect, useState, useCallback } from 'react';
 import Voice from '../index';
 /**
  * Custom hook for voice recognition
@@ -22,32 +22,76 @@ import Voice from '../index';
  * ```
  */
 export const useVoiceRecognition = (options = {}) => {
-    const { locale = 'en-US', enablePartialResults = true, onResult, onError, } = options;
+    const { locale = 'en-US', enablePartialResults = true, continuous = false, maxSilenceDuration = 5000, onResult, onError, } = options;
     const [isRecording, setIsRecording] = useState(false);
     const [results, setResults] = useState([]);
     const [partialResults, setPartialResults] = useState([]);
     const [error, setError] = useState(null);
+    const [shouldContinue, setShouldContinue] = useState(false);
+    const silenceTimerRef = React.useRef(null);
+    const accumulatedTextRef = React.useRef('');
+    useEffect(() => {
+        // Clear any existing timers on cleanup
+        return () => {
+            if (silenceTimerRef.current) {
+                clearTimeout(silenceTimerRef.current);
+            }
+        };
+    }, []);
     useEffect(() => {
         // Set up event listeners
         Voice.onSpeechStart = () => {
             setIsRecording(true);
             setError(null);
+            if (silenceTimerRef.current) {
+                clearTimeout(silenceTimerRef.current);
+            }
         };
-        Voice.onSpeechEnd = () => {
+        Voice.onSpeechEnd = async () => {
             setIsRecording(false);
+            // In continuous mode, restart listening after results
+            if (continuous && shouldContinue) {
+                setTimeout(async () => {
+                    if (shouldContinue) {
+                        try {
+                            await Voice.start(locale, {
+                                EXTRA_PARTIAL_RESULTS: enablePartialResults,
+                            });
+                        }
+                        catch (err) {
+                            console.error('Failed to restart voice recognition:', err);
+                        }
+                    }
+                }, 100);
+            }
         };
         Voice.onSpeechError = (e) => {
             const errorMessage = e.error?.message || 'Unknown error';
             setError(errorMessage);
             setIsRecording(false);
+            setShouldContinue(false);
+            if (silenceTimerRef.current) {
+                clearTimeout(silenceTimerRef.current);
+            }
             onError?.(errorMessage);
         };
         Voice.onSpeechResults = (e) => {
             if (e.value && e.value.length > 0) {
-                setResults(e.value);
-                const firstResult = e.value[0];
-                if (firstResult) {
-                    onResult?.(firstResult);
+                if (continuous) {
+                    // Append new text to accumulated text
+                    const newText = e.value[0];
+                    accumulatedTextRef.current = accumulatedTextRef.current
+                        ? accumulatedTextRef.current + ' ' + newText
+                        : newText;
+                    setResults([accumulatedTextRef.current, ...e.value.slice(1)]);
+                    onResult?.(accumulatedTextRef.current);
+                }
+                else {
+                    setResults(e.value);
+                    const firstResult = e.value[0];
+                    if (firstResult) {
+                        onResult?.(firstResult);
+                    }
                 }
             }
         };
@@ -55,6 +99,15 @@ export const useVoiceRecognition = (options = {}) => {
             Voice.onSpeechPartialResults = (e) => {
                 if (e.value && e.value.length > 0) {
                     setPartialResults(e.value);
+                    // Reset silence timer on partial results (user is speaking)
+                    if (continuous && silenceTimerRef.current) {
+                        clearTimeout(silenceTimerRef.current);
+                        silenceTimerRef.current = setTimeout(() => {
+                            if (shouldContinue) {
+                                stop();
+                            }
+                        }, maxSilenceDuration);
+                    }
                 }
             };
         }
@@ -62,12 +115,24 @@ export const useVoiceRecognition = (options = {}) => {
         return () => {
             Voice.destroy().then(Voice.removeAllListeners);
         };
-    }, [enablePartialResults, onResult, onError]);
+    }, [
+        enablePartialResults,
+        onResult,
+        onError,
+        continuous,
+        shouldContinue,
+        locale,
+        maxSilenceDuration,
+    ]);
     const start = useCallback(async () => {
         try {
             setError(null);
-            setResults([]);
-            setPartialResults([]);
+            if (!continuous) {
+                setResults([]);
+                setPartialResults([]);
+                accumulatedTextRef.current = '';
+            }
+            setShouldContinue(true);
             // Check permission (Android only)
             const hasPermission = await Voice.checkMicrophonePermission();
             if (!hasPermission) {
@@ -80,15 +145,36 @@ export const useVoiceRecognition = (options = {}) => {
             await Voice.start(locale, {
                 EXTRA_PARTIAL_RESULTS: enablePartialResults,
             });
+            // Start silence timer if in continuous mode
+            if (continuous) {
+                silenceTimerRef.current = setTimeout(() => {
+                    if (shouldContinue) {
+                        stop();
+                    }
+                }, maxSilenceDuration);
+            }
         }
         catch (e) {
             const errorMessage = e instanceof Error ? e.message : 'Failed to start recording';
             setError(errorMessage);
+            setShouldContinue(false);
             onError?.(errorMessage);
         }
-    }, [locale, enablePartialResults, onError]);
+    }, [
+        locale,
+        enablePartialResults,
+        onError,
+        continuous,
+        maxSilenceDuration,
+        shouldContinue,
+    ]);
     const stop = useCallback(async () => {
         try {
+            setShouldContinue(false);
+            if (silenceTimerRef.current) {
+                clearTimeout(silenceTimerRef.current);
+                silenceTimerRef.current = null;
+            }
             await Voice.stop();
         }
         catch (e) {
@@ -99,9 +185,15 @@ export const useVoiceRecognition = (options = {}) => {
     }, [onError]);
     const cancel = useCallback(async () => {
         try {
+            setShouldContinue(false);
+            if (silenceTimerRef.current) {
+                clearTimeout(silenceTimerRef.current);
+                silenceTimerRef.current = null;
+            }
             await Voice.cancel();
             setResults([]);
             setPartialResults([]);
+            accumulatedTextRef.current = '';
         }
         catch (e) {
             const errorMessage = e instanceof Error ? e.message : 'Failed to cancel recording';
@@ -114,6 +206,12 @@ export const useVoiceRecognition = (options = {}) => {
         setPartialResults([]);
         setError(null);
         setIsRecording(false);
+        accumulatedTextRef.current = '';
+        setShouldContinue(false);
+        if (silenceTimerRef.current) {
+            clearTimeout(silenceTimerRef.current);
+            silenceTimerRef.current = null;
+        }
     }, []);
     return {
         isRecording,
@@ -126,4 +224,3 @@ export const useVoiceRecognition = (options = {}) => {
         reset,
     };
 };
-//# sourceMappingURL=useVoiceRecognition.js.map

package/dist/index.d.ts

@@ -67,10 +67,9 @@ declare class RCTVoice {
 }
 export type { SpeechEndEvent, SpeechErrorEvent, SpeechEvents, SpeechStartEvent, SpeechRecognizedEvent, SpeechResultsEvent, SpeechVolumeChangeEvent, TranscriptionEndEvent, TranscriptionErrorEvent, TranscriptionEvents, TranscriptionStartEvent, TranscriptionResultsEvent, };
 export type { VoiceOptions, RecognitionStats, PermissionResult, Language, } from './VoiceUtilTypes';
-export { VoiceMicrophone, MicIcon, MicOffIcon } from './components';
+export { VoiceMicrophone, MicIcon, MicOffIcon, MicIconFilled, MicOffIconFilled, MicIconWave, MicOffIconWave, } from './components';
 export type { VoiceMicrophoneProps, MicIconProps, MicOffIconProps, } from './components';
 export { useVoiceRecognition } from './hooks';
 export type { UseVoiceRecognitionOptions, UseVoiceRecognitionReturn, } from './hooks';
 declare const _default: RCTVoice;
 export default _default;
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -392,8 +392,7 @@ class RCTVoice {
     }
 }
 // Export components
-export { VoiceMicrophone, MicIcon, MicOffIcon } from './components';
+export { VoiceMicrophone, MicIcon, MicOffIcon, MicIconFilled, MicOffIconFilled, MicIconWave, MicOffIconWave, } from './components';
 // Export hooks
 export { useVoiceRecognition } from './hooks';
 export default new RCTVoice();
-//# sourceMappingURL=index.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-native-voice-ts",
   "description": "Advanced Speech-to-Text library for React Native with TypeScript support. Features ready-to-use components (VoiceMicrophone), custom hooks (useVoiceRecognition), real-time transcription, multi-language support, and comprehensive voice recognition capabilities for iOS and Android.",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "author": "Noor Mohammad <noor.jsdivs@gmail.com>",
   "private": false,
   "homepage": "https://github.com/noorjsdivs/react-native-voice-ts",
@@ -22,7 +22,7 @@
     "react": "^19.2.1",
     "react-native": "^0.83.0",
     "react-native-svg": "^15.15.1",
-    "semantic-release": "^25.0.2",
+    "semantic-release": "^23.0.0",
     "typescript": "5.9.3"
   },
   "keywords": [
@@ -46,17 +46,13 @@
   "types": "dist/index.d.ts",
   "files": [
     "dist",
-    "src",
     "android",
     "ios",
-    "plugin",
+    "plugin/build",
     "app.plugin.js",
     "react-native-voice.podspec",
     "README.md",
-    "LICENSE",
-    "COMPONENT_USAGE.md",
-    "CONTRIBUTING.md",
-    "MIGRATION_SUMMARY.md"
+    "LICENSE"
   ],
   "peerDependencies": {
     "expo": ">=48.0.0",