react-native-davoice 1.0.15 → 1.0.16

package/TTSRNBridge.podspec

@@ -2,7 +2,7 @@ require 'json'
 
 Pod::Spec.new do |s|
     s.name         = "TTSRNBridge"
-    s.version      = "1.0.217" # Update to your package version
+    s.version      = "1.0.218" # Update to your package version
     s.summary      = "TTS for React Native."
     s.description  = <<-DESC
                      A React Native module for tts .

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "react-native-davoice",
-    "version": "1.0.15",
+    "version": "1.0.16",
     "description": "tts library for React Native",
     "main": "tts/index.js",
     "types": "tts/index.d.ts",

package/speech/index.ts

@@ -126,6 +126,7 @@ class Speech {
   private ttsChain: Promise<void> = Promise.resolve();
   private ttsPendingResolve: (() => void) | null = null;
   private ttsPendingTimeout: any = null;
+  private sttTransitionChain: Promise<void> = Promise.resolve();
 
   private dbgAsset(label: string, x: any) {
     try {
@@ -161,6 +162,22 @@ class Speech {
     return (NativeTTS as any).speak(text, speakerId, s);
   }
 
+  private enqueueSttTransition(opId: string, kind: 'pause' | 'unpause', work: () => Promise<void>): Promise<void> {
+    const previous = this.sttTransitionChain.catch(() => {});
+    const run = previous.then(async () => {
+      dbg('[sttTransition] begin', { opId, kind });
+      try {
+        await work();
+        dbg('[sttTransition] end', { opId, kind });
+      } catch (e) {
+        dbgErr('[sttTransition] failed', { opId, kind, error: String(e) });
+        throw e;
+      }
+    });
+    this.sttTransitionChain = run.catch(() => {});
+    return run;
+  }
+
   private _speakAndWait(text: string, speakerId: number, s: number, timeoutMs = 600000) {
     return new Promise<void>((resolve, reject) => {
       this.ttsPendingResolve = resolve;
@@ -632,43 +649,45 @@ class Speech {
     const mod: any = Platform.OS === 'ios' ? NativeSpeech : NativeSTT;
     const fn = mod?.pauseSpeechRecognitionLite;
 
-    if (!fn) {
-      dbg(`pauseSpeechRecognitionLite not available on ${Platform.OS === 'ios' ? 'NativeSpeech' : 'NativeSTT'}`);
-      return;
-    }
+    await this.enqueueSttTransition(opId, 'pause', async () => {
+      if (!fn) {
+        dbg(`pauseSpeechRecognitionLite not available on ${Platform.OS === 'ios' ? 'NativeSpeech' : 'NativeSTT'}`);
+        return;
+      }
+
+      if (Platform.OS === 'ios' && typeof mod?.pauseSpeechRecognitionLiteAsync === 'function') {
+        dbg('[pauseSpeechRecognitionLiteAsync] begin', { opId, timeoutMs: 1500 });
+        const result = await mod.pauseSpeechRecognitionLiteAsync(1500);
+        dbg('[pauseSpeechRecognitionLiteAsync] resolved', { opId, elapsedMs: Date.now() - startedAt, result });
+        if (result?.ok === false) dbgErr('pauseSpeechRecognitionLiteAsync failed', result?.reason);
+        return;
+      }
+      if (Platform.OS === 'ios') {
+        await new Promise<void>((resolve, reject) => {
+          try {
+            fn.call(mod, (ok: boolean) => {
+              if (!ok) dbgErr('pauseSpeechRecognitionLite returned false');
+              resolve();
+            });
+          } catch (e) {
+            reject(e as any);
+          }
+        });
+        return;
+      }
 
-    if (Platform.OS === 'ios' && typeof mod?.pauseSpeechRecognitionLiteAsync === 'function') {
-      dbg('[pauseSpeechRecognitionLiteAsync] begin', { opId, timeoutMs: 1500 });
-      const result = await mod.pauseSpeechRecognitionLiteAsync(1500);
-      dbg('[pauseSpeechRecognitionLiteAsync] resolved', { opId, elapsedMs: Date.now() - startedAt, result });
-      if (result?.ok === false) dbgErr('pauseSpeechRecognitionLiteAsync failed', result?.reason);
-      return;
-    }
-    if (Platform.OS === 'ios') {
       await new Promise<void>((resolve, reject) => {
         try {
-          fn.call(mod, (ok: boolean) => {
+          fn.call(mod, async (ok: boolean) => {
             if (!ok) dbgErr('pauseSpeechRecognitionLite returned false');
+            // ✅ ANDROID: small delay before resolving
+            if (Platform.OS === 'android') await sleep(500);
             resolve();
           });
         } catch (e) {
           reject(e as any);
         }
       });
-      return;
-    }
-
-    await new Promise<void>((resolve, reject) => {
-      try {
-        fn.call(mod, async (ok: boolean) => {
-          if (!ok) dbgErr('pauseSpeechRecognitionLite returned false');
-          // ✅ ANDROID: small delay before resolving
-          if (Platform.OS === 'android') await sleep(500);
-          resolve();
-        });
-      } catch (e) {
-        reject(e as any);
-      }
     });
   }
 
@@ -684,64 +703,66 @@ class Speech {
     const mod: any = Platform.OS === 'ios' ? NativeSpeech : NativeSTT;
     const fn = mod?.unPauseSpeechRecognitionLite;
 
-    if (!fn) {
-      dbg(`unPauseSpeechRecognitionLite(times) not available on ${Platform.OS === 'ios' ? 'NativeSpeech' : 'NativeSTT'}`);
-      return;
-    }
+    await this.enqueueSttTransition(opId, 'unpause', async () => {
+      if (!fn) {
+        dbg(`unPauseSpeechRecognitionLite(times) not available on ${Platform.OS === 'ios' ? 'NativeSpeech' : 'NativeSTT'}`);
+        return;
+      }
 
-    if (Platform.OS === 'ios' && typeof mod?.unPauseSpeechRecognitionLiteAsync === 'function') {
-      dbg('[unPauseSpeechRecognitionLiteAsync] begin', { opId, times, preFetchMs, timeoutMs });
-      const result = await mod.unPauseSpeechRecognitionLiteAsync(times, preFetchMs, timeoutMs);
-      dbg('[unPauseSpeechRecognitionLiteAsync] resolved', {
-        opId,
-        times,
-        preFetchMs,
-        elapsedMs: Date.now() - startedAt,
-        result,
-      });
-      if (result?.ok === false) dbgErr('unPauseSpeechRecognitionLiteAsync failed', result?.reason);
-      return;
-    }
+      if (Platform.OS === 'ios' && typeof mod?.unPauseSpeechRecognitionLiteAsync === 'function') {
+        dbg('[unPauseSpeechRecognitionLiteAsync] begin', { opId, times, preFetchMs, timeoutMs });
+        const result = await mod.unPauseSpeechRecognitionLiteAsync(times, preFetchMs, timeoutMs);
+        dbg('[unPauseSpeechRecognitionLiteAsync] resolved', {
+          opId,
+          times,
+          preFetchMs,
+          elapsedMs: Date.now() - startedAt,
+          result,
+        });
+        if (result?.ok === false) dbgErr('unPauseSpeechRecognitionLiteAsync failed', result?.reason);
+        return;
+      }
 
-    if (Platform.OS === 'ios') {
+      if (Platform.OS === 'ios') {
+        await new Promise<void>((resolve, reject) => {
+          try {
+            const done = (ok: boolean) => {
+              if (!ok) dbgErr('unPauseSpeechRecognitionLite(times) returned false');
+              dbg('[CALL unPauseSpeechRecognitionLite] native callback fired', { times, preFetchMs, ok });
+              resolve();
+            };
+            if (preFetchMs > 0 && typeof mod?.unPauseSpeechRecognitionLiteWithPreFetch === 'function') {
+              dbg('[CALL unPauseSpeechRecognitionLite] invoking iOS prefetch bridge', { times, preFetchMs });
+              mod.unPauseSpeechRecognitionLiteWithPreFetch(times, preFetchMs, done);
+              return;
+            }
+            dbg('[CALL unPauseSpeechRecognitionLite] invoking iOS legacy bridge', { times, preFetchMs });
+            fn.call(mod, times, done);
+            dbg('[CALL unPauseSpeechRecognitionLite] returned from JS->native invocation', { times, preFetchMs });
+          } catch (e) {
+            dbgErr('[CALL unPauseSpeechRecognitionLite] exception before native callback', String(e));
+            reject(e as any);
+          }
+        });
+        return;
+      }
       await new Promise<void>((resolve, reject) => {
         try {
-          const done = (ok: boolean) => {
+          const done = async (ok: boolean) => {
             if (!ok) dbgErr('unPauseSpeechRecognitionLite(times) returned false');
-            dbg('[CALL unPauseSpeechRecognitionLite] native callback fired', { times, preFetchMs, ok });
+            // ✅ ANDROID: small delay before resolving
+            if (Platform.OS === 'android') await sleep(500);
             resolve();
           };
-          if (preFetchMs > 0 && typeof mod?.unPauseSpeechRecognitionLiteWithPreFetch === 'function') {
-            dbg('[CALL unPauseSpeechRecognitionLite] invoking iOS prefetch bridge', { times, preFetchMs });
+          if (Platform.OS === 'android' && preFetchMs > 0 && typeof mod?.unPauseSpeechRecognitionLiteWithPreFetch === 'function') {
             mod.unPauseSpeechRecognitionLiteWithPreFetch(times, preFetchMs, done);
             return;
           }
-          dbg('[CALL unPauseSpeechRecognitionLite] invoking iOS legacy bridge', { times, preFetchMs });
           fn.call(mod, times, done);
-          dbg('[CALL unPauseSpeechRecognitionLite] returned from JS->native invocation', { times, preFetchMs });
         } catch (e) {
-          dbgErr('[CALL unPauseSpeechRecognitionLite] exception before native callback', String(e));
           reject(e as any);
         }
       });
-      return;
-    }
-    await new Promise<void>((resolve, reject) => {
-      try {
-        const done = async (ok: boolean) => {
-          if (!ok) dbgErr('unPauseSpeechRecognitionLite(times) returned false');
-          // ✅ ANDROID: small delay before resolving
-          if (Platform.OS === 'android') await sleep(500);
-          resolve();
-        };
-        if (Platform.OS === 'android' && preFetchMs > 0 && typeof mod?.unPauseSpeechRecognitionLiteWithPreFetch === 'function') {
-          mod.unPauseSpeechRecognitionLiteWithPreFetch(times, preFetchMs, done);
-          return;
-        }
-        fn.call(mod, times, done);
-      } catch (e) {
-        reject(e as any);
-      }
     });
   }
   /** Pause mic/STT (Android native; iOS unified if present) */