react-native-davoice-tts 1.0.395 → 1.0.397

package/speech/index.ts

@@ -41,36 +41,45 @@ function sleep(ms: number) {
 
 // Android's pauseSpeechRecognitionLite/unPauseSpeechRecognitionLite native callbacks have
 // no native-JS-visible timeout contract of their own (unlike iOS's ...LiteAsync). This
-// guarantees the wrapping promise always settles: on timeout it logs and resolves with
-// undefined rather than rejecting, so callers that never expected this call to throw don't
-// suddenly start seeing exceptions - the only change is a bounded wait instead of an
-// unbounded one.
-function androidCallbackWithTimeout<T>(
-  invoke: (done: (value: T) => void) => void,
+// guarantees the wrapping promise always settles with the same structured result used by
+// the iOS async bridge.
+export type SpeechTransitionResult = {
+  ok: boolean;
+  reason: string;
+  elapsedMs: number;
+};
+
+function androidCallbackWithTimeout(
+  invoke: (done: (ok: boolean) => void) => void,
   timeoutMs: number,
   label: string,
-): Promise<T | undefined> {
-  return new Promise<T | undefined>((resolve) => {
+  startedAt: number,
+): Promise<SpeechTransitionResult> {
+  return new Promise<SpeechTransitionResult>((resolve) => {
     let settled = false;
     const timer = setTimeout(() => {
       if (settled) return;
       settled = true;
       dbgNotice(`IMPORTANT: ${label} reached timeout - please note this is not a bug`, { timeoutMs });
-      resolve(undefined);
+      resolve({ ok: false, reason: 'timeout', elapsedMs: Date.now() - startedAt });
     }, timeoutMs);
     try {
-      invoke((value) => {
+      invoke((ok) => {
         if (settled) return;
         settled = true;
         clearTimeout(timer);
-        resolve(value);
+        resolve({
+          ok: ok !== false,
+          reason: ok === false ? 'native_reported_failure' : '',
+          elapsedMs: Date.now() - startedAt,
+        });
       });
     } catch (e) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
       dbgErr(`${label} threw before native callback`, String(e));
-      resolve(undefined);
+      resolve({ ok: false, reason: 'native_exception', elapsedMs: Date.now() - startedAt });
     }
   });
 }
@@ -319,19 +328,20 @@ class Speech {
     return nativeTtsSpeak();
   }
 
-  private enqueueSttTransition(opId: string, kind: 'pause' | 'unpause', work: () => Promise<void>): Promise<void> {
+  private enqueueSttTransition<T>(opId: string, kind: 'pause' | 'unpause', work: () => Promise<T>): Promise<T> {
     const previous = this.sttTransitionChain.catch(() => {});
     const run = previous.then(async () => {
       dbg('[sttTransition] begin', { opId, kind });
       try {
-        await work();
+        const result = await work();
         dbg('[sttTransition] end', { opId, kind });
+        return result;
       } catch (e) {
         dbgErr('[sttTransition] failed', { opId, kind, error: String(e) });
         throw e;
       }
     });
-    this.sttTransitionChain = run.catch(() => {});
+    this.sttTransitionChain = run.then(() => undefined, () => undefined);
     return run;
   }
 
@@ -893,15 +903,16 @@ class Speech {
         return;
       }
 
-      await androidCallbackWithTimeout<void>(
+      await androidCallbackWithTimeout(
         (done) => {
           fn.call(mod, (ok: boolean) => {
             if (!ok) dbgNotice('IMPORTANT: pauseSpeechRecognitionLite reached timeout - please note this is not a bug');
-            done(undefined);
+            done(ok);
           });
         },
         effectiveTimeoutMs,
         'pauseSpeechRecognitionLite',
+        startedAt,
       );
     };
 
@@ -918,7 +929,7 @@ class Speech {
     times: number,
     preFetchMs: number = 0,
     timeoutMs: number = 500,
-  ): Promise<{ ok: boolean; reason: string; elapsedMs: number } | undefined> {
+  ): Promise<SpeechTransitionResult> {
     this.logCall('unPauseSpeechRecognitionLite', { times, preFetchMs });
     const startedAt = Date.now();
     // Previously hard-capped at 500ms regardless of the caller's requested timeoutMs, so the
@@ -934,12 +945,17 @@ class Speech {
     const work = async (opId?: string) => {
       if (!fn) {
         dbg(`unPauseSpeechRecognitionLite(times) not available on ${Platform.OS === 'ios' ? 'NativeSpeech' : 'NativeSTT'}`);
-        return;
+        return { ok: false, reason: 'unsupported', elapsedMs: Date.now() - startedAt };
       }
 
       if (Platform.OS === 'ios' && typeof mod?.unPauseSpeechRecognitionLiteAsync === 'function') {
         dbg('[unPauseSpeechRecognitionLiteAsync] begin', { ...(opId ? { opId } : {}), times, preFetchMs, timeoutMs: effectiveTimeoutMs });
-        const result = await mod.unPauseSpeechRecognitionLiteAsync(times, preFetchMs, effectiveTimeoutMs);
+        let result: any;
+        try {
+          result = await mod.unPauseSpeechRecognitionLiteAsync(times, preFetchMs, effectiveTimeoutMs);
+        } catch {
+          return { ok: false, reason: 'native_exception', elapsedMs: Date.now() - startedAt };
+        }
         dbg('[unPauseSpeechRecognitionLiteAsync] resolved', {
           ...(opId ? { opId } : {}),
           times,
@@ -963,12 +979,16 @@ class Speech {
       }
 
       if (Platform.OS === 'ios') {
-        await new Promise<void>((resolve, reject) => {
+        return new Promise<SpeechTransitionResult>((resolve) => {
           try {
             const done = (ok: boolean) => {
               if (!ok) dbgNotice('IMPORTANT: unPauseSpeechRecognitionLite reached timeout - please note this is not a bug');
               dbg('[CALL unPauseSpeechRecognitionLite] native callback fired', { times, preFetchMs, ok });
-              resolve();
+              resolve({
+                ok: ok !== false,
+                reason: ok === false ? 'native_reported_failure' : '',
+                elapsedMs: Date.now() - startedAt,
+              });
             };
             if (preFetchMs > 0 && typeof mod?.unPauseSpeechRecognitionLiteWithPreFetch === 'function') {
               dbg('[CALL unPauseSpeechRecognitionLite] invoking iOS prefetch bridge', { times, preFetchMs });
@@ -980,16 +1000,15 @@ class Speech {
             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);
+            resolve({ ok: false, reason: 'native_exception', elapsedMs: Date.now() - startedAt });
           }
         });
-        return;
       }
-      await androidCallbackWithTimeout<void>(
+      return androidCallbackWithTimeout(
         (done) => {
           const nativeDone = (ok: boolean) => {
             if (!ok) dbgNotice('IMPORTANT: unPauseSpeechRecognitionLite reached timeout - please note this is not a bug');
-            done(undefined);
+            done(ok);
           };
           if (Platform.OS === 'android' && preFetchMs > 0 && typeof mod?.unPauseSpeechRecognitionLiteWithPreFetch === 'function') {
             mod.unPauseSpeechRecognitionLiteWithPreFetch(times, preFetchMs, nativeDone);
@@ -999,13 +1018,13 @@ class Speech {
         },
         effectiveTimeoutMs,
         'unPauseSpeechRecognitionLite',
+        startedAt,
       );
     };
 
     if (PROBABLY_GPT_MISTAKE) {
       const opId = nextSpeechOpId('unpause-stt');
-      await this.enqueueSttTransition(opId, 'unpause', () => work(opId).then(() => undefined));
-      return undefined;
+      return this.enqueueSttTransition(opId, 'unpause', () => work(opId));
     }
 
     return work();
@@ -1506,7 +1525,9 @@ class Speech {
       };
       (Object.keys(sttMap) as (keyof typeof sttMap)[]).forEach((name) => {
         try {
-          const sub = this.sttEmitter!.addListener(name, sttMap[name]);
+          const handler = sttMap[name];
+          if (!handler) return;
+          const sub = this.sttEmitter!.addListener(name, handler);
           this.subs.push(sub);
         } catch {}
       });