@internetarchive/bookreader 5.0.0-7 → 5.0.0-70

package/src/plugins/tts/AbstractTTSEngine.js

@@ -28,6 +28,7 @@ import PageChunkIterator from './PageChunkIterator.js';
  * @property {() => void} resume
  * @property {() => void} finish force the sound to 'finish'
  * @property {number => void} setPlaybackRate
+ * @property {SpeechSynthesisVoice => void} setVoice
  **/
 
 /** Handling bookreader's text-to-speech */
@@ -50,9 +51,7 @@ export default class AbstractTTSEngine {
     /** @type {SpeechSynthesisVoice} */
     this.voice = null;
     // Listen for voice changes (fired by subclasses)
-    this.events.on('voiceschanged', () => {
-      this.voice = AbstractTTSEngine.getBestBookVoice(this.getVoices(), this.opts.bookLanguage);
-    });
+    this.events.on('voiceschanged', this.updateBestVoice);
     this.events.trigger('voiceschanged');
   }
 
@@ -71,6 +70,10 @@ export default class AbstractTTSEngine {
   /** @abstract */
   init() { return null; }
 
+  updateBestVoice = () => {
+    this.voice = AbstractTTSEngine.getBestBookVoice(this.getVoices(), this.opts.bookLanguage);
+  }
+
   /**
    * @param {number} leafIndex
    * @param {number} numLeafs total number of leafs in the current book
@@ -124,13 +127,26 @@ export default class AbstractTTSEngine {
   }
 
   /** @public */
-  jumpBackward() {
-    Promise.all([
+  async jumpBackward() {
+    await Promise.all([
       this.activeSound.stop(),
       this._chunkIterator.decrement()
         .then(() => this._chunkIterator.decrement())
-    ])
-      .then(() => this.step());
+    ]);
+    this.step();
+  }
+
+  /** @param {string} voiceURI */
+  setVoice(voiceURI) {
+    // if the user actively selects a voice, don't re-choose best voice anymore
+    // MS Edge fires voices changed randomly very often
+    this.events.off('voiceschanged', this.updateBestVoice);
+    this.voice = this.getVoices().find(voice => voice.voiceURI === voiceURI);
+    // if the current book has a language set, store the selected voice with the book language as a suffix
+    if (this.opts.bookLanguage) {
+      localStorage.setItem(`BRtts-voice-${this.opts.bookLanguage}`, this.voice.voiceURI);
+    }
+    if (this.activeSound) this.activeSound.setVoice(this.voice);
   }
 
   /** @param {number} newRate */
@@ -140,36 +156,33 @@ export default class AbstractTTSEngine {
   }
 
   /** @private */
-  step() {
-    this._chunkIterator.next()
-      .then(chunk => {
-        if (chunk == PageChunkIterator.AT_END) {
-          this.stop();
-          this.opts.onDone();
-          return;
-        }
-
-        this.opts.onLoadingStart();
-        const sound = this.createSound(chunk);
-        sound.chunk = chunk;
-        sound.rate = this.playbackRate;
-        sound.voice = this.voice;
-        sound.load(() => this.opts.onLoadingComplete());
-
-        this.opts.onLoadingComplete();
-        return this.opts.beforeChunkPlay(chunk).then(() => sound);
-      })
-      .then(sound => {
-        if (!this.playing) return;
-
-        const playPromise = this.playSound(sound)
-          .then(() => this.opts.afterChunkPlay(sound.chunk));
-        if (this.paused) this.pause();
-        return playPromise;
-      })
-      .then(() => {
-        if (this.playing) return this.step();
-      });
+  async step() {
+    const chunk = await  this._chunkIterator.next();
+    if (chunk == PageChunkIterator.AT_END) {
+      this.stop();
+      this.opts.onDone();
+      return;
+    }
+    this.opts.onLoadingStart();
+    const sound = this.createSound(chunk);
+    sound.chunk = chunk;
+    sound.rate = this.playbackRate;
+    sound.voice = this.voice;
+    sound.load(() => this.opts.onLoadingComplete());
+
+    this.opts.onLoadingComplete();
+
+    await this.opts.beforeChunkPlay(chunk);
+
+    if (!this.playing) return;
+
+    const playPromise = await this.playSound(sound)
+      .then(()=> this.opts.afterChunkPlay(sound.chunk));
+
+    if (this.paused) this.pause();
+    await playPromise;
+
+    if (this.playing) return this.step();
   }
 
   /**
@@ -212,10 +225,12 @@ export default class AbstractTTSEngine {
     // user languages that match the book language
     const matchingUserLangs = userLanguages.filter(lang => lang.startsWith(bookLanguage));
 
-    // Try to find voices that intersect these two sets
-    return AbstractTTSEngine.getMatchingVoice(matchingUserLangs, bookLangVoices) ||
+    // First try to find the last chosen voice from localStorage for the current book language
+    return AbstractTTSEngine.getMatchingStoredVoice(bookLangVoices, bookLanguage)
+        // Try to find voices that intersect these two sets
+        || AbstractTTSEngine.getMatchingVoice(matchingUserLangs, bookLangVoices)
         // no user languages match the books; let's return the best voice for the book language
-        (bookLangVoices.find(v => v.default) || bookLangVoices[0])
+        || (bookLangVoices.find(v => v.default) || bookLangVoices[0])
         // No voices match the book language? let's find a voice in the user's language
         // and ignore book lang
         || AbstractTTSEngine.getMatchingVoice(userLanguages, voices)
@@ -223,6 +238,19 @@ export default class AbstractTTSEngine {
         || (voices.find(v => v.default) || voices[0]);
   }
 
+  /**
+   * @private
+   * Get the voice last selected by the user for the book language from localStorage.
+   * Returns undefined if no voice is stored or found.
+   * @param {SpeechSynthesisVoice[]} voices  browser voices to choose from
+   * @param {ISO6391} bookLanguage  book language to look for
+   * @return {SpeechSynthesisVoice | undefined}
+   */
+  static getMatchingStoredVoice(voices, bookLanguage) {
+    const storedVoice = localStorage.getItem(`BRtts-voice-${bookLanguage}`);
+    return (storedVoice ? voices.find(v => v.voiceURI === storedVoice) : undefined);
+  }
+
   /**
      * @private
      * Get the best voice that matches one of the BCP47 languages (order by preference)

package/src/plugins/tts/FestivalTTSEngine.js

@@ -1,5 +1,5 @@
 import AbstractTTSEngine from './AbstractTTSEngine.js';
-import { sleep } from './utils.js';
+import { sleep } from '../../BookReader/utils.js';
 /* global soundManager */
 import 'soundmanager2';
 import 'jquery.browser';
@@ -23,7 +23,7 @@ export default class FestivalTTSEngine extends AbstractTTSEngine {
     // $.browsers is sometimes undefined on some Android browsers :/
     // Likely related to when $.browser was moved to npm
     /** @type {'mp3' | 'ogg'} format of audio to get */
-    this.audioFormat = $.browser?.mozilla ? 'ogg' : 'mp3';
+    this.audioFormat = $.browser?.mozilla ? 'ogg' : 'mp3'; //eslint-disable-line no-jquery/no-browser
   }
 
   /** @override */
@@ -91,10 +91,10 @@ export default class FestivalTTSEngine extends AbstractTTSEngine {
    * See https://stackoverflow.com/questions/12206631/html5-audio-cant-play-through-javascript-unless-triggered-manually-once
    * @return {PromiseLike}
    */
-  iOSCaptureUserIntentHack() {
+  async iOSCaptureUserIntentHack() {
     const sound = soundManager.createSound({ url: SILENCE_1MS[this.audioFormat] });
-    return new Promise(res => sound.play({onfinish: res}))
-      .then(() => sound.destruct());
+    await new Promise(res => sound.play({onfinish: res}));
+    sound.destruct();
   }
 }
 
@@ -107,7 +107,7 @@ class FestivalTTSSound {
     this.sound = null;
     this.rate = 1;
     /** @type {function} calling this resolves the "play" promise */
-    this._finishResolver = null
+    this._finishResolver = null;
   }
 
   get loaded() {
@@ -122,21 +122,20 @@ class FestivalTTSSound {
         if (this.rate != 1) this.sound.setPlaybackRate(this.rate);
         onload();
       },
-      onresume: () => {
-        sleep(25).then(() => {
-          if (this.rate != 1) this.sound.setPlaybackRate(this.rate);
-        });
+      onresume: async () => {
+        await sleep(25);
+        if (this.rate != 1) this.sound.setPlaybackRate(this.rate);
       }
     });
     return this.sound.load();
   }
 
-  play() {
-    return new Promise(res => {
+  async play() {
+    await new Promise(res => {
       this._finishResolver = res;
       this.sound.play({ onfinish: res });
-    })
-      .then(() => this.sound.destruct());
+    });
+    this.sound.destruct();
   }
 
   /** @override */

package/src/plugins/tts/PageChunk.js

@@ -21,27 +21,18 @@ export default class PageChunk {
    * @param {number} leafIndex
    * @return {Promise<PageChunk[]>}
    */
-  static fetch(server, bookPath, leafIndex) {
-    // jquery's ajax "PromiseLike" implementation is inconsistent with
-    // modern Promises, so convert it to a full promise (it doesn't forward
-    // a returned promise to the next handler in the chain, which kind of
-    // defeats the entire point of using promises to avoid "callback hell")
-    return new Promise((res, rej) => {
-      $.ajax({
-        type: 'GET',
-        url: `https://${server}/BookReader/BookReaderGetTextWrapper.php`,
-        dataType:'jsonp',
-        cache: true,
-        data: {
-          path: `${bookPath}_djvu.xml`,
-          page: leafIndex
-        },
-        error: rej,
-      })
-        .then(chunks => {
-          res(PageChunk._fromTextWrapperResponse(leafIndex, chunks));
-        });
+  static async fetch(server, bookPath, leafIndex) {
+    const chunks = await $.ajax({
+      type: 'GET',
+      url: `https://${server}/BookReader/BookReaderGetTextWrapper.php`,
+      dataType:'jsonp',
+      cache: true,
+      data: {
+        path: `${bookPath}_djvu.xml`,
+        page: leafIndex
+      }
     });
+    return PageChunk._fromTextWrapperResponse(leafIndex, chunks);
   }
 
   /**
@@ -97,7 +88,10 @@ export default class PageChunk {
    * @return {string}
    */
   static _removeDanglingHyphens(text) {
-    return text.replace(/-\s+/g, '');
+    // Some books mis-OCR a dangling hyphen as a ¬ (mathematical not sign) . Since in math
+    // the not sign should not appear followed by a space, we think we can safely assume
+    // this should be replaced.
+    return text.replace(/[-¬]\s+/g, '');
   }
 }
 

package/src/plugins/tts/PageChunkIterator.js

@@ -53,22 +53,18 @@ export default class PageChunkIterator {
    * in the correct order.
    * @return {PromiseLike<"__PageChunkIterator.AT_END__" | PageChunk>}
    */
-  _nextUncontrolled() {
+  async  _nextUncontrolled() {
     if (this._cursor.page == this.pageCount) {
       return Promise.resolve(PageChunkIterator.AT_END);
     }
-
     this._recenterBuffer(this._cursor.page);
-
-    return this._fetchPageChunks(this._cursor.page)
-      .then(chunks => {
-        if (this._cursor.chunk == chunks.length) {
-          this._cursor.page++;
-          this._cursor.chunk = 0;
-          return this._nextUncontrolled();
-        }
-        return chunks[this._cursor.chunk++];
-      });
+    const chunks = await this._fetchPageChunks(this._cursor.page);
+    if (this._cursor.chunk == chunks.length) {
+      this._cursor.page++;
+      this._cursor.chunk = 0;
+      return this._nextUncontrolled();
+    }
+    return chunks[this._cursor.chunk++];
   }
 
   /**

package/src/plugins/tts/WebTTSEngine.js

@@ -1,6 +1,7 @@
 /* global br */
 import { isChrome, isFirefox } from '../../util/browserSniffing.js';
-import { sleep, promisifyEvent, isAndroid } from './utils.js';
+import { isAndroid } from './utils.js';
+import { promisifyEvent, sleep } from '../../BookReader/utils.js';
 import AbstractTTSEngine from './AbstractTTSEngine.js';
 /** @typedef {import("./AbstractTTSEngine.js").PageChunk} PageChunk */
 /** @typedef {import("./AbstractTTSEngine.js").AbstractTTSSound} AbstractTTSSound */
@@ -70,7 +71,22 @@ export default class WebTTSEngine extends AbstractTTSEngine {
   }
 
   /** @override */
-  getVoices() { return speechSynthesis.getVoices(); }
+  getVoices() {
+    const voices = speechSynthesis.getVoices();
+    if (voices.filter(v => v.default).length != 1) {
+      // iOS bug where the default system voice is sometimes
+      // missing from the list
+      voices.unshift({
+        voiceURI: 'bookreader.SystemDefault',
+        name: 'System Default',
+        // Not necessarily true, but very likely
+        lang: navigator.language,
+        default: true,
+        localService: true,
+      });
+    }
+    return voices;
+  }
 
   /** @override */
   createSound(chunk) {
@@ -121,7 +137,11 @@ export class WebTTSSound {
     this.started = false;
 
     this.utterance = new SpeechSynthesisUtterance(this.text.slice(this._charIndex));
-    this.utterance.voice = this.voice;
+    // iOS bug where the default system voice is sometimes
+    // missing from the list
+    if (this.voice?.voiceURI !== 'bookreader.SystemDefault') {
+      this.utterance.voice = this.voice;
+    }
     // Need to also set lang (for some reason); won't set voice on Chrome@Android otherwise
     if (this.voice) this.utterance.lang = this.voice.lang;
     this.utterance.rate = this.rate;
@@ -167,7 +187,7 @@ export class WebTTSSound {
    * left off.
    * @return {Promise<void>}
    */
-  reload() {
+  async reload() {
     // We'll restore the pause state, so copy it here
     const wasPaused = this.paused;
     // Use recent event to determine where we'll restart from
@@ -179,14 +199,12 @@ export class WebTTSSound {
     }
 
     // We can't modify the utterance object, so we have to make a new one
-    return this.stop()
-      .then(() => {
-        this.load();
-        // Instead of playing and immediately pausing, we don't start playing. Note
-        // this is a requirement because pause doesn't work consistently across
-        // browsers.
-        if (!wasPaused) this.play();
-      });
+    await this.stop();
+    this.load();
+    // Instead of playing and immediately pausing, we don't start playing. Note
+    // this is a requirement because pause doesn't work consistently across
+    // browsers.
+    if (!wasPaused) this.play();
   }
 
   play() {
@@ -222,15 +240,16 @@ export class WebTTSSound {
     return endPromise;
   }
 
-  finish() {
-    this.stop().then(() => this.utterance.dispatchEvent(new Event('finish')));
+  async finish() {
+    await this.stop();
+    this.utterance.dispatchEvent(new Event('finish'));
   }
 
   /**
    * @override
    * Will fire a pause event unless already paused
    **/
-  pause() {
+  async pause() {
     if (this.paused) return;
 
     const pausePromise = promisifyEvent(this.utterance, 'pause');
@@ -246,19 +265,18 @@ export class WebTTSSound {
     if (pauseMightNotFire) {
       // wait for it just in case
       const timeoutPromise = sleep(100).then(() => 'timeout');
-      Promise.race([pausePromise, timeoutPromise])
-        .then(result => {
-          // We got our pause event; nothing to do!
-          if (result != 'timeout') return;
-
-          this.utterance.dispatchEvent(new CustomEvent('pause', this._lastEvents.start));
-          // if pause might not work, then we'll stop entirely and restart later
-          if (pauseMightNotWork) this.stop();
-        });
+      const result = await Promise.race([pausePromise, timeoutPromise]);
+      // We got our pause event; nothing to do!
+      if (result != 'timeout') return;
+
+      this.utterance.dispatchEvent(new CustomEvent('pause', this._lastEvents.start));
+
+      // if pause might not work, then we'll stop entirely and restart later
+      if (pauseMightNotWork) this.stop();
     }
   }
 
-  resume() {
+  async resume() {
     if (!this.started) {
       this.play();
       return;
@@ -278,16 +296,15 @@ export class WebTTSSound {
     speechSynthesis.resume();
 
     if (resumeMightNotFire) {
-      Promise.race([resumePromise, sleep(100).then(() => 'timeout')])
-        .then(result => {
-          if (result != 'timeout') return;
-
-          this.utterance.dispatchEvent(new CustomEvent('resume', {}));
-          if (resumeMightNotWork) {
-            const reloadPromise = this.reload();
-            reloadPromise.then(() => this.play());
-          }
-        });
+      const result = await Promise.race([resumePromise, sleep(100).then(() => 'timeout')]);
+
+      if (result != 'timeout') return;
+
+      this.utterance.dispatchEvent(new CustomEvent('resume', {}));
+      if (resumeMightNotWork) {
+        await this.reload();
+        this.play();
+      }
     }
   }
 
@@ -296,6 +313,11 @@ export class WebTTSSound {
     this.reload();
   }
 
+  /** @param {SpeechSynthesisVoice} voice */
+  setVoice(voice) {
+    this.voice = voice;
+    this.reload();
+  }
   /**
    * @private
    * Chrome has a bug where it only plays 15 seconds of TTS and then
@@ -303,45 +325,39 @@ export class WebTTSSound {
    * We avoid this (as described here: https://bugs.chromium.org/p/chromium/issues/detail?id=679437#c15 )
    * by pausing after 14 seconds and ~instantly resuming.
    */
-  _chromePausingBugFix() {
+  async _chromePausingBugFix() {
     const timeoutPromise = sleep(14000).then(() => 'timeout');
     const pausePromise = promisifyEvent(this.utterance, 'pause').then(() => 'paused');
     const endPromise = promisifyEvent(this.utterance, 'end').then(() => 'ended');
-    return Promise.race([timeoutPromise, pausePromise, endPromise])
-      .then(result => {
-        if (location.toString().indexOf('_debugReadAloud=true') != -1) {
-          console.log(`CHROME-PAUSE-HACK: ${result}`);
-        }
-        switch (result) {
-        case 'ended':
-          // audio was stopped/finished; nothing to do
-          break;
-        case 'paused':
-          // audio was paused; wait for resume
-          // Chrome won't let you resume the audio if 14s have passed 🤷‍
-          // We could do the same as before (but resume+pause instead of pause+resume),
-          // but that means we'd _constantly_ be running in the background. So in that
-          // case, let's just restart the chunk
-          Promise.race([
-            promisifyEvent(this.utterance, 'resume'),
-            sleep(14000).then(() => 'timeout'),
-          ])
-            .then(result => {
-              result == 'timeout' ? this.reload() : this._chromePausingBugFix();
-            });
-          break;
-        case 'timeout':
-          // We hit Chrome's secret cut off time. Pause/resume
-          // to be able to keep TTS-ing
-          speechSynthesis.pause();
-          sleep(25)
-            .then(() => {
-              speechSynthesis.resume();
-              this._chromePausingBugFix();
-            });
-          break;
-        }
-      });
+    const result = await Promise.race([timeoutPromise, pausePromise, endPromise]);
+    if (location.toString().indexOf('_debugReadAloud=true') != -1) {
+      console.log(`CHROME-PAUSE-HACK: ${result}`);
+    }
+    switch (result) {
+    case 'ended':
+      // audio was stopped/finished; nothing to do
+      break;
+    case 'paused':
+      // audio was paused; wait for resume
+      // Chrome won't let you resume the audio if 14s have passed 🤷‍
+      // We could do the same as before (but resume+pause instead of pause+resume),
+      // but that means we'd _constantly_ be running in the background. So in that
+      // case, let's just restart the chunk
+      await Promise.race([
+        promisifyEvent(this.utterance, 'resume'),
+        sleep(14000).then(() => 'timeout'),
+      ]);
+      result == 'timeout' ? this.reload() : this._chromePausingBugFix();
+      break;
+    case 'timeout':
+      // We hit Chrome's secret cut off time. Pause/resume
+      // to be able to keep TTS-ing
+      speechSynthesis.pause();
+      await sleep(25);
+      speechSynthesis.resume();
+      this._chromePausingBugFix();
+      break;
+    }
   }
 }