@gmessier/nitro-speech 0.3.3 → 0.4.1

package/ios/Shared/Log.swift

@@ -0,0 +1,41 @@
+import Foundation
+import os.log
+
+enum Log {
+   static let isLogging = false
+   static let subsystem = "com.margelo.nitro.nitrospeech"
+   static let category = "NitroSpeech"
+   static func log(_ text: String) {
+       if isLogging {
+           let tn = Thread.current.isMainThread ? "main" : "bg"
+           Logger(subsystem: subsystem, category: category).info(
+            "[thread]: \(tn) | \(text)"
+           )
+       }
+   }
+}
+
+final class Lg {
+    private let disable: Bool
+    static let isLogging = false
+    static let subsystem = "com.margelo.nitro.nitrospeech"
+    static let category = "NitroSpeech"
+    let prefix: String
+    init(prefix: String, disable: Bool? = false) {
+        self.prefix = prefix
+        self.disable = disable ?? false
+    }
+    var prevMs: Double?
+    func log(_ text: String) {
+        if Self.isLogging && !self.disable {
+            let nowMs = ProcessInfo.processInfo.systemUptime * 1000
+            let diff = Int(round(nowMs - (self.prevMs ?? nowMs)))
+            self.prevMs = nowMs
+            let tn = Thread.current.isMainThread ? "main" : "bg"
+            Logger(
+                subsystem: Self.subsystem,
+                category: Self.category
+            ).info("[thread]: \(tn) | {\(self.prefix)} diff: \(diff) | \(text)")
+        }
+    }
+}

package/ios/Shared/Permissions.swift

@@ -0,0 +1,59 @@
+import Foundation
+import Speech
+import AVFoundation
+
+final class Permissions {
+    private let onGranted: () async -> Void
+    private let onDenied: (() -> Void)?
+    private let onError: ((String) -> Void)?
+    
+    init(
+        onGranted: @escaping () async -> Void,
+        onDenied: (() -> Void)?,
+        onError: ((String) -> Void)?
+    ) {
+        self.onGranted = onGranted
+        self.onDenied = onDenied
+        self.onError = onError
+    }
+    
+    private func requestMicrophonePermission() async {
+        // Request permission to record.
+        if #available(iOS 17.0, *) {
+            if await AVAudioApplication.requestRecordPermission() {
+                await self.onGranted()
+                return
+            }
+            self.onDenied?()
+            return
+        }
+        AVAudioSession.sharedInstance().requestRecordPermission { [weak self] granted in
+            Task { @MainActor in
+                guard let self else { return }
+                if granted {
+                    await self.onGranted()
+                    return
+                }
+                self.onDenied?()
+            }
+        }
+    }
+    
+    func requestAuthorization() {
+        SFSpeechRecognizer.requestAuthorization { authStatus in
+            Task { @MainActor in
+                switch authStatus {
+                    case .authorized:
+                        await self.requestMicrophonePermission()
+                    case .denied, .restricted:
+                        self.onDenied?()
+                    case .notDetermined:
+                        self.onError?("Speech recognition not determined")
+                    @unknown default:
+                        self.onError?("Unknown authorization status")
+                }
+            }
+        }
+    }
+    
+}

package/ios/Shared/Utils.swift

@@ -0,0 +1,58 @@
+import Foundation
+
+enum Utils {
+    static func repeatingFilter(_ text: String) -> String {
+        var subStrings = text.split { $0.isWhitespace }.map { String($0) }
+        if #available(iOS 16.0, *) {
+            var shift = 0
+            while shift < subStrings.count, !subStrings[shift].contains(/\w+/) {
+                shift += 1
+            }
+            if shift > 0, shift < subStrings.count {
+                subStrings = Array(subStrings.suffix(subStrings.count - shift))
+            }
+        }
+        guard !subStrings.isEmpty else { return text }
+        
+        var joiner = ""
+        if subStrings.count >= 10 {
+            joiner = subStrings.prefix(subStrings.count - 9).joined(separator: " ")
+            subStrings = Array(subStrings.suffix(10))
+        } else {
+            joiner = subStrings.first ?? ""
+        }
+        for i in subStrings.indices {
+            if i == 0 { continue }
+            if #available(iOS 16.0, *), subStrings[i].contains(/\d+/) {
+                joiner += " \(subStrings[i])"
+                continue
+            }
+            if subStrings[i] == subStrings[i - 1] { continue }
+            joiner += " \(subStrings[i])"
+        }
+        return joiner
+    }
+
+    // hash only params that affect transcriber preference
+    static func hashParams(_ params: SpeechRecognitionConfig?) -> String {
+        guard let params else { return "n" }
+        let locale = params.locale ?? "en-US"
+        let addPunctuation = switch params.iosAddPunctuation {
+            case nil: "n"
+            case false: "f"
+            case true: "t"
+        }
+        let preset = switch params.iosPreset {
+            case nil: "n"
+            case .shortform: "s"
+            case .general: "g"
+        }
+        let atypicalSpeech = switch params.iosAtypicalSpeech {
+            case nil: "n"
+            case false: "f"
+            case true: "t"
+        }
+        
+        return [locale, addPunctuation, preset, atypicalSpeech].joined(separator: "|")
+    }
+}

package/lib/NitroSpeech.d.ts

@@ -0,0 +1,2 @@
+import type { NitroSpeech as NitroSpeechSpec } from './specs/NitroSpeech.nitro';
+export declare const NitroSpeech: NitroSpeechSpec;

package/lib/NitroSpeech.js

@@ -0,0 +1,2 @@
+import { NitroModules } from 'react-native-nitro-modules';
+export const NitroSpeech = NitroModules.createHybridObject('NitroSpeech');

package/lib/Recognizer/RecognizerRef.d.ts

@@ -0,0 +1,7 @@
+import type { RecognizerMethods } from './types';
+/**
+ * Safe cross-component reference to the Speech Recognizer methods.
+ *
+ * All methods support worklets and UI thread calls
+ */
+export declare const RecognizerRef: RecognizerMethods;

package/lib/Recognizer/RecognizerRef.js

@@ -0,0 +1,16 @@
+import { recognizerAddAutoFinishTime, recognizerGetSupportedLocalesIOS, recognizerGetIsActive, recognizerResetAutoFinishTime, recognizerStartListening, recognizerStopListening, recognizerUpdateConfig, recognizerGetVoiceInputVolume, } from './methods';
+/**
+ * Safe cross-component reference to the Speech Recognizer methods.
+ *
+ * All methods support worklets and UI thread calls
+ */
+export const RecognizerRef = {
+    startListening: recognizerStartListening,
+    stopListening: recognizerStopListening,
+    resetAutoFinishTime: recognizerResetAutoFinishTime,
+    addAutoFinishTime: recognizerAddAutoFinishTime,
+    updateConfig: recognizerUpdateConfig,
+    getIsActive: recognizerGetIsActive,
+    getVoiceInputVolume: recognizerGetVoiceInputVolume,
+    getSupportedLocalesIOS: recognizerGetSupportedLocalesIOS,
+};

package/lib/Recognizer/SpeechRecognizer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Static Speech Recognizer instance.
+ *
+ * Direct access to the all Speech Recognizer methods and callbacks.
+ *
+ * @note unsafe, might lead to race conditions
+ */
+export declare const SpeechRecognizer: import("./types").RecognizerSpec;

package/lib/Recognizer/SpeechRecognizer.js

@@ -0,0 +1,9 @@
+import { NitroSpeech } from '../NitroSpeech';
+/**
+ * Static Speech Recognizer instance.
+ *
+ * Direct access to the all Speech Recognizer methods and callbacks.
+ *
+ * @note unsafe, might lead to race conditions
+ */
+export const SpeechRecognizer = NitroSpeech.recognizer;

package/lib/Recognizer/methods.d.ts

@@ -0,0 +1,9 @@
+import type { SpeechRecognitionConfig } from './types';
+export declare const recognizerStartListening: (params: SpeechRecognitionConfig) => void;
+export declare const recognizerStopListening: () => void;
+export declare const recognizerResetAutoFinishTime: () => void;
+export declare const recognizerAddAutoFinishTime: (additionalTimeMs?: number) => void;
+export declare const recognizerUpdateConfig: (newConfig: SpeechRecognitionConfig, resetAutoFinishTime?: boolean) => void;
+export declare const recognizerGetIsActive: () => boolean;
+export declare const recognizerGetVoiceInputVolume: () => import("./types").VolumeChangeEvent;
+export declare const recognizerGetSupportedLocalesIOS: () => string[];

package/lib/Recognizer/methods.js

@@ -0,0 +1,33 @@
+import { SpeechRecognizer } from './SpeechRecognizer';
+export const recognizerStartListening = (params) => {
+    'worklet';
+    SpeechRecognizer.startListening(params);
+};
+export const recognizerStopListening = () => {
+    'worklet';
+    SpeechRecognizer.stopListening();
+};
+export const recognizerResetAutoFinishTime = () => {
+    'worklet';
+    SpeechRecognizer.resetAutoFinishTime();
+};
+export const recognizerAddAutoFinishTime = (additionalTimeMs) => {
+    'worklet';
+    SpeechRecognizer.addAutoFinishTime(additionalTimeMs);
+};
+export const recognizerUpdateConfig = (newConfig, resetAutoFinishTime) => {
+    'worklet';
+    SpeechRecognizer.updateConfig(newConfig, resetAutoFinishTime);
+};
+export const recognizerGetIsActive = () => {
+    'worklet';
+    return SpeechRecognizer.getIsActive();
+};
+export const recognizerGetVoiceInputVolume = () => {
+    'worklet';
+    return SpeechRecognizer.getVoiceInputVolume();
+};
+export const recognizerGetSupportedLocalesIOS = () => {
+    'worklet';
+    return SpeechRecognizer.getSupportedLocalesIOS().sort();
+};

package/lib/Recognizer/types.d.ts

@@ -0,0 +1,6 @@
+import type { Recognizer as RecognizerSpec } from '../specs/Recognizer.nitro';
+import type { SpeechRecognitionConfig } from '../specs/SpeechRecognitionConfig';
+import type { VolumeChangeEvent } from '../specs/VolumeChangeEvent';
+type RecognizerCallbacks = Pick<RecognizerSpec, 'onReadyForSpeech' | 'onRecordingStopped' | 'onResult' | 'onAutoFinishProgress' | 'onError' | 'onPermissionDenied' | 'onVolumeChange'>;
+type RecognizerMethods = Pick<RecognizerSpec, 'startListening' | 'stopListening' | 'resetAutoFinishTime' | 'addAutoFinishTime' | 'updateConfig' | 'getIsActive' | 'getVoiceInputVolume' | 'getSupportedLocalesIOS'>;
+export type { RecognizerSpec, SpeechRecognitionConfig, VolumeChangeEvent, RecognizerCallbacks, RecognizerMethods, };

package/lib/Recognizer/types.js

@@ -0,0 +1 @@
+export {};

package/lib/Recognizer/useRecognizer.d.ts

@@ -0,0 +1,16 @@
+import { type DependencyList } from 'react';
+import type { RecognizerCallbacks, RecognizerMethods } from './types';
+/**
+ * Safe, lifecycle-aware hook to use the recognizer.
+ *
+ * @param callbacks - The callbacks to use for the recognizer.
+ * @param destroyDeps - The additional dependencies to use for the cleanup effect.
+ *
+ * Example: To cleanup when the screen is unfocused.
+ *
+ * ```typescript
+ * const isFocused = useIsFocused()
+ * useRecognizer({ ... }, [isFocused])
+ * ```
+ */
+export declare const useRecognizer: (callbacks: RecognizerCallbacks, destroyDeps?: DependencyList) => RecognizerMethods;

package/lib/Recognizer/useRecognizer.js

@@ -0,0 +1,71 @@
+import { useEffect } from 'react';
+import { recognizerResetAutoFinishTime, recognizerAddAutoFinishTime, recognizerUpdateConfig, recognizerGetIsActive, recognizerGetSupportedLocalesIOS, recognizerStartListening, recognizerStopListening, recognizerGetVoiceInputVolume, } from './methods';
+import { SpeechRecognizer } from './SpeechRecognizer';
+import { speechRecognizerVolumeChangeHandler } from './useVoiceInputVolume';
+import { speechRecognizerActiveStateHandler } from './useRecognizerIsActive';
+/**
+ * Safe, lifecycle-aware hook to use the recognizer.
+ *
+ * @param callbacks - The callbacks to use for the recognizer.
+ * @param destroyDeps - The additional dependencies to use for the cleanup effect.
+ *
+ * Example: To cleanup when the screen is unfocused.
+ *
+ * ```typescript
+ * const isFocused = useIsFocused()
+ * useRecognizer({ ... }, [isFocused])
+ * ```
+ */
+export const useRecognizer = (callbacks, destroyDeps = []) => {
+    useEffect(() => {
+        SpeechRecognizer.onReadyForSpeech = () => {
+            speechRecognizerActiveStateHandler(true);
+            callbacks.onReadyForSpeech?.();
+        };
+        SpeechRecognizer.onRecordingStopped = () => {
+            speechRecognizerActiveStateHandler(false);
+            callbacks.onRecordingStopped?.();
+        };
+        SpeechRecognizer.onResult = (resultBatches) => {
+            callbacks.onResult?.(resultBatches);
+        };
+        SpeechRecognizer.onAutoFinishProgress = (timeLeftMs) => {
+            callbacks.onAutoFinishProgress?.(timeLeftMs);
+        };
+        SpeechRecognizer.onError = (message) => {
+            callbacks.onError?.(message);
+        };
+        SpeechRecognizer.onPermissionDenied = () => {
+            callbacks.onPermissionDenied?.();
+        };
+        SpeechRecognizer.onVolumeChange = (event) => {
+            speechRecognizerVolumeChangeHandler(event);
+            callbacks.onVolumeChange?.(event);
+        };
+        return () => {
+            SpeechRecognizer.onReadyForSpeech = undefined;
+            SpeechRecognizer.onRecordingStopped = undefined;
+            SpeechRecognizer.onResult = undefined;
+            SpeechRecognizer.onAutoFinishProgress = undefined;
+            SpeechRecognizer.onError = undefined;
+            SpeechRecognizer.onPermissionDenied = undefined;
+            SpeechRecognizer.onVolumeChange = undefined;
+        };
+    }, [callbacks]);
+    useEffect(() => {
+        return () => {
+            SpeechRecognizer.stopListening();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [...destroyDeps]);
+    return {
+        startListening: recognizerStartListening,
+        stopListening: recognizerStopListening,
+        resetAutoFinishTime: recognizerResetAutoFinishTime,
+        addAutoFinishTime: recognizerAddAutoFinishTime,
+        updateConfig: recognizerUpdateConfig,
+        getIsActive: recognizerGetIsActive,
+        getVoiceInputVolume: recognizerGetVoiceInputVolume,
+        getSupportedLocalesIOS: recognizerGetSupportedLocalesIOS,
+    };
+};

package/lib/Recognizer/useRecognizerIsActive.d.ts

@@ -0,0 +1,25 @@
+type OnActiveStateChange = (isActive: boolean) => void;
+/**
+ * Returns true if the speech recognition session is active.
+ */
+export declare const useRecognizerIsActive: () => boolean;
+/**
+ * Direct access to default Speech Recognizer isActive state change handler.
+ *
+ * In case you use static Speech Recognizer:
+ *
+ * ```typescript
+ * import { speechRecognizerActiveStateHandler } from '@gmessier/nitro-speech'
+ *
+ * SpeechRecognizer.onReadyForSpeech = () => {
+ *   speechRecognizerActiveStateHandler(true)
+ * }
+ * SpeechRecognizer.onRecordingStopped = () => {
+ *   speechRecognizerActiveStateHandler(false)
+ * }
+ * ... // setup everything else
+ * SpeechRecognizer.startListening({ locale: 'en-US' })
+ * ```
+ */
+export declare const speechRecognizerActiveStateHandler: OnActiveStateChange;
+export {};

package/lib/Recognizer/useRecognizerIsActive.js

@@ -0,0 +1,40 @@
+import { useSyncExternalStore } from 'react';
+const subscribers = new Set();
+let recognizerIsActive = false;
+const getSnapshot = () => {
+    return recognizerIsActive;
+};
+/**
+ * Returns true if the speech recognition session is active.
+ */
+export const useRecognizerIsActive = () => {
+    return useSyncExternalStore((subscriber) => {
+        subscribers.add(subscriber);
+        return () => subscribers.delete(subscriber);
+    }, getSnapshot);
+};
+/**
+ * Direct access to default Speech Recognizer isActive state change handler.
+ *
+ * In case you use static Speech Recognizer:
+ *
+ * ```typescript
+ * import { speechRecognizerActiveStateHandler } from '@gmessier/nitro-speech'
+ *
+ * SpeechRecognizer.onReadyForSpeech = () => {
+ *   speechRecognizerActiveStateHandler(true)
+ * }
+ * SpeechRecognizer.onRecordingStopped = () => {
+ *   speechRecognizerActiveStateHandler(false)
+ * }
+ * ... // setup everything else
+ * SpeechRecognizer.startListening({ locale: 'en-US' })
+ * ```
+ */
+export const speechRecognizerActiveStateHandler = (isActive) => {
+    if (isActive === recognizerIsActive) {
+        return;
+    }
+    recognizerIsActive = isActive;
+    subscribers.forEach((subscriber) => subscriber?.(isActive));
+};

package/lib/Recognizer/useVoiceInputVolume.d.ts

@@ -0,0 +1,25 @@
+import type { RecognizerSpec, VolumeChangeEvent } from './types';
+type OnVolumeChange = Exclude<RecognizerSpec['onVolumeChange'], undefined>;
+/**
+ * Subscription to the voice input volume changes
+ *
+ * Updates with arbitrary frequency (many times per second) while audio recording is active.
+ *
+ * @returns The current voice input volume normalized to a range of 0 to 1.
+ */
+export declare const useVoiceInputVolume: () => VolumeChangeEvent;
+/**
+ * Direct access to default Speech Recognizer volume change handler.
+ *
+ * In case you use static Speech Recognizer:
+ *
+ * ```typescript
+ * import { speechRecognizerVolumeChangeHandler } from '@gmessier/nitro-speech'
+ *
+ * SpeechRecognizer.onVolumeChange = speechRecognizerVolumeChangeHandler
+ * ... // setup everything else
+ * SpeechRecognizer.startListening({ locale: 'en-US' })
+ * ```
+ */
+export declare const speechRecognizerVolumeChangeHandler: OnVolumeChange;
+export {};

package/lib/Recognizer/useVoiceInputVolume.js

@@ -0,0 +1,52 @@
+import { useSyncExternalStore } from 'react';
+const subscribers = new Set();
+let current = {
+    smoothedVolume: 0,
+    rawVolume: 0,
+    db: undefined,
+};
+let snapshot = { ...current };
+const getSnapshot = () => {
+    if (snapshot.smoothedVolume === current.smoothedVolume &&
+        snapshot.rawVolume === current.rawVolume &&
+        snapshot.db === current.db) {
+        return snapshot;
+    }
+    snapshot = { ...current };
+    return snapshot;
+};
+/**
+ * Subscription to the voice input volume changes
+ *
+ * Updates with arbitrary frequency (many times per second) while audio recording is active.
+ *
+ * @returns The current voice input volume normalized to a range of 0 to 1.
+ */
+export const useVoiceInputVolume = () => {
+    return useSyncExternalStore((subscriber) => {
+        subscribers.add(subscriber);
+        return () => subscribers.delete(subscriber);
+    }, getSnapshot);
+};
+/**
+ * Direct access to default Speech Recognizer volume change handler.
+ *
+ * In case you use static Speech Recognizer:
+ *
+ * ```typescript
+ * import { speechRecognizerVolumeChangeHandler } from '@gmessier/nitro-speech'
+ *
+ * SpeechRecognizer.onVolumeChange = speechRecognizerVolumeChangeHandler
+ * ... // setup everything else
+ * SpeechRecognizer.startListening({ locale: 'en-US' })
+ * ```
+ */
+export const speechRecognizerVolumeChangeHandler = (event) => {
+    if (event.smoothedVolume === current.smoothedVolume &&
+        event.rawVolume === current.rawVolume &&
+        event.db === current.db) {
+        return;
+    }
+    current = event;
+    subscribers.forEach((subscriber) => subscriber?.(event));
+};

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+export * from './Recognizer/types';
+export { useRecognizer } from './Recognizer/useRecognizer';
+export { useVoiceInputVolume, speechRecognizerVolumeChangeHandler, } from './Recognizer/useVoiceInputVolume';
+export { useRecognizerIsActive, speechRecognizerActiveStateHandler, } from './Recognizer/useRecognizerIsActive';
+export { SpeechRecognizer } from './Recognizer/SpeechRecognizer';
+export { RecognizerRef } from './Recognizer/RecognizerRef';
+export { NitroSpeech } from './NitroSpeech';

package/lib/index.js

@@ -0,0 +1,7 @@
+export * from './Recognizer/types';
+export { useRecognizer } from './Recognizer/useRecognizer';
+export { useVoiceInputVolume, speechRecognizerVolumeChangeHandler, } from './Recognizer/useVoiceInputVolume';
+export { useRecognizerIsActive, speechRecognizerActiveStateHandler, } from './Recognizer/useRecognizerIsActive';
+export { SpeechRecognizer } from './Recognizer/SpeechRecognizer';
+export { RecognizerRef } from './Recognizer/RecognizerRef';
+export { NitroSpeech } from './NitroSpeech';

package/lib/specs/NitroSpeech.nitro.d.ts

@@ -0,0 +1,8 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { Recognizer } from './Recognizer.nitro';
+export interface NitroSpeech extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    recognizer: Recognizer;
+}

package/lib/specs/NitroSpeech.nitro.js

@@ -0,0 +1 @@
+export {};

package/lib/specs/Recognizer.nitro.d.ts

@@ -0,0 +1,97 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { MutableSpeechRecognitionConfig, SpeechRecognitionConfig } from './SpeechRecognitionConfig';
+import type { VolumeChangeEvent } from './VolumeChangeEvent';
+export interface Recognizer extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    /**
+     * Prepare the speech recognition engine and the model for the given parameters.
+     *
+     * Omit the {@linkcode Promise} result if want to run synchronously.
+     * {@linkcode startListening} will start and resolve it automatically.
+     * Only `await` if run beforehand and want to react on the success
+     */
+    prewarm(defaultParams?: SpeechRecognitionConfig): Promise<void>;
+    /**
+     * Try to start the speech recognition.
+     *
+     * Not guaranteed to start the speech recognition.
+     *
+     * On success - {@linkcode onReadyForSpeech} is called
+     *
+     * On failure - {@linkcode onError} is called
+     */
+    startListening(params?: SpeechRecognitionConfig): void;
+    /**
+     * Stops the speech recognition. if not started, does nothing.
+     *
+     * Not a sync operation for android, delay about 250ms to polish the result.
+     *
+     * Use {@linkcode onRecordingStopped} to handle the stop event.
+     */
+    stopListening(): void;
+    /**
+     * Reset the auto finish timer to current {@linkcode SpeechRecognitionConfig.autoFinishRecognitionMs}.
+     */
+    resetAutoFinishTime(): void;
+    /**
+     * Add time to the auto finish timer once without changing the timer threshold.
+     *
+     * @param additionalTimeMs - time in ms to add to the current auto finish timer. If not set, will reset the timer to the original {@linkcode SpeechRecognitionConfig.autoFinishRecognitionMs}.
+     */
+    addAutoFinishTime(additionalTimeMs?: number): void;
+    /**
+     * Applies changes only within the active recognition session.
+     *
+     * @param newConfig - new dynamic params for the speech recognition.
+     * @param resetAutoFinishTime - if true, will reset auto finish time to actual {@linkcode SpeechRecognitionConfig.autoFinishRecognitionMs}.
+     */
+    updateConfig(newConfig?: MutableSpeechRecognitionConfig, resetAutoFinishTime?: boolean): void;
+    /**
+     * Returns true if the speech recognition is active.
+     */
+    getIsActive(): boolean;
+    /**
+     * Returns the current voice input volume.
+     */
+    getVoiceInputVolume(): VolumeChangeEvent;
+    /**
+     * Returns a list of supported locales.
+     *
+     * @platform iOS only
+     */
+    getSupportedLocalesIOS(): string[];
+    /**
+     * The speech recognition session has started.
+     */
+    onReadyForSpeech?: () => void;
+    /**
+     * The speech recognition session has stopped.
+     */
+    onRecordingStopped?: () => void;
+    /**
+     * Fires each time either a new batch has been added or the last batch has been updated.
+     */
+    onResult?: (resultBatches: string[]) => void;
+    /**
+     * Fires every {@linkcode SpeechRecognitionConfig.autoFinishProgressIntervalMs} or 1000ms
+     *
+     * Time left in milliseconds until the timer stops.
+     *
+     * @note not implemented for Android yet.
+     */
+    onAutoFinishProgress?: (timeLeftMs: number) => void;
+    /**
+     * Error of the speech recognition.
+     */
+    onError?: (message: string) => void;
+    /**
+     * The permission to use the microphone or recognize speech has been denied.
+     */
+    onPermissionDenied?: () => void;
+    /**
+     * Fires with high and arbitrary frequency (many times per second) while audio recording is active.
+     */
+    onVolumeChange?: (event: VolumeChangeEvent) => void;
+}

package/lib/specs/Recognizer.nitro.js

@@ -0,0 +1 @@
+export {};