fix: resumeInfinity/onresume interaction

index.d.ts

@@ -54,6 +54,18 @@ declare module '@lightningjs/blits' {
      * @default 1
      */
     volume?: number,
+    /**
+     * Whether to cancel previous announcements when adding this one
+     *
+     * @default false
+     */
+    cancelPrevious?: boolean,
+    /**
+     * Whether to enable utterance keep-alive (prevents pausing on some platforms)
+     *
+     * @default undefined
+     */
+    enableUtteranceKeepAlive?: boolean
   }
 
   export interface AnnouncerUtterance<T = any> extends Promise<T> {

src/announcer/announcer.js

@@ -25,8 +25,13 @@ let isProcessing = false
 let currentId = null
 let debounce = null
 
+const isAndroid = /android/i.test((window.navigator || {}).userAgent || '')
+const defaultUtteranceKeepAlive = !isAndroid
+
 // Global default utterance options
-let globalDefaultOptions = {}
+let globalDefaultOptions = {
+  enableUtteranceKeepAlive: defaultUtteranceKeepAlive,
+}
 
 const noopAnnouncement = {
   then() {},
@@ -51,6 +56,11 @@ const toggle = (v) => {
 const speak = (message, politeness = 'off', options = {}) => {
   if (active === false) return noopAnnouncement
 
+  // if cancelPrevious option is set, clear the queue and stop current speech
+  if (options.cancelPrevious === true) {
+    clear()
+  }
+
   return addToQueue(message, politeness, false, options)
 }
 
@@ -106,18 +116,22 @@ const addToQueue = (message, politeness, delay = false, options = {}) => {
   return done
 }
 
+let currentResolveFn = null
+
 const processQueue = async () => {
   if (isProcessing === true || queue.length === 0) return
   isProcessing = true
 
   const { message, resolveFn, delay, id, options = {} } = queue.shift()
 
   currentId = id
+  currentResolveFn = resolveFn
 
   if (delay) {
     setTimeout(() => {
       isProcessing = false
       currentId = null
+      currentResolveFn = null
       resolveFn('finished')
       processQueue()
     }, delay)
@@ -134,37 +148,86 @@ const processQueue = async () => {
           ...globalDefaultOptions,
           ...options,
         })
-        .then(() => {
+        .then((result) => {
           Log.debug(`Announcer - finished speaking: "${message}" (id: ${id})`)
+          Log.debug('Announcer - finished result: ', result)
 
           currentId = null
+          currentResolveFn = null
           isProcessing = false
           resolveFn('finished')
           processQueue()
         })
         .catch((e) => {
           currentId = null
+          currentResolveFn = null
           isProcessing = false
           Log.debug(`Announcer - error ("${e.error}") while speaking: "${message}" (id: ${id})`)
           resolveFn(e.error)
           processQueue()
         })
       debounce = null
-    }, 200)
+    }, 300)
   }
 }
 
 const polite = (message, options = {}) => speak(message, 'polite', options)
 
 const assertive = (message, options = {}) => speak(message, 'assertive', options)
 
+// Clear debounce timer
+const clearDebounceTimer = () => {
+  if (debounce !== null) {
+    clearTimeout(debounce)
+    debounce = null
+  }
+}
+
 const stop = () => {
+  Log.debug('Announcer - stop() called')
+
+  // Clear debounce timer if speech hasn't started yet
+  clearDebounceTimer()
+
+  // Always cancel speech synthesis to ensure clean state
   speechSynthesis.cancel()
+
+  // Store resolve function before resetting state
+  const prevResolveFn = currentResolveFn
+
+  // Reset state
+  currentId = null
+  currentResolveFn = null
+  isProcessing = false
+
+  // Resolve promise if there was an active utterance
+  if (prevResolveFn) {
+    prevResolveFn('interrupted')
+  }
 }
 
 const clear = () => {
+  Log.debug('Announcer - clear() called')
+
+  // Clear debounce timer
+  clearDebounceTimer()
+
+  // Cancel any active speech synthesis
+  speechSynthesis.cancel()
+
+  // Resolve all pending items in queue
+  while (queue.length > 0) {
+    const item = queue.shift()
+    if (item.resolveFn) {
+      Log.debug(`Announcer - clearing queued item: "${item.message}" (id: ${item.id})`)
+      item.resolveFn('cleared')
+    }
+  }
+
+  // Reset state
+  currentId = null
+  currentResolveFn = null
   isProcessing = false
-  queue.length = 0
 }
 
 const configure = (options = {}) => {