@internetarchive/bookreader 5.0.0-88-alpha.7 → 5.0.0-88-alpha.9

package/dist/esm/plugins/tts/FestivalTTSEngine.js

@@ -0,0 +1,192 @@
+function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
+function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
+import AbstractTTSEngine from './AbstractTTSEngine.js';
+import { sleep } from '../../BookReader/utils.js';
+/* global soundManager */
+import 'soundmanager2';
+import 'jquery.browser';
+
+/** @typedef {import("./AbstractTTSEngine.js").TTSEngineOptions} TTSEngineOptions */
+/** @typedef {import("./AbstractTTSEngine.js").AbstractTTSSound} AbstractTTSSound */
+
+/**
+ * @extends AbstractTTSEngine
+ * TTS using Festival endpoint
+ **/
+export default class FestivalTTSEngine extends AbstractTTSEngine {
+  /** @override */
+  static isSupported() {
+    return typeof soundManager !== 'undefined' && soundManager.supported();
+  }
+
+  /** @param {TTSEngineOptions} options */
+  constructor(options) {
+    var _$$browser;
+    super(options);
+    // $.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 = $.browser) !== null && _$$browser !== void 0 && _$$browser.mozilla ? 'ogg' : 'mp3'; //eslint-disable-line no-jquery/no-browser
+  }
+
+  /** @override */
+  getVoices() {
+    return [{
+      default: true,
+      lang: "en-US",
+      localService: false,
+      name: "Festival - English (US)",
+      voiceURI: null
+    }];
+  }
+
+  /** @override */
+  init() {
+    // setup sound manager
+    soundManager.setup({
+      debugMode: false,
+      // Note, there's a bug in Chrome regarding range requests.
+      // Flash is used as a workaround.
+      // See https://bugs.chromium.org/p/chromium/issues/detail?id=505707
+      preferFlash: true,
+      url: '/bookreader/BookReader/soundmanager/swf',
+      useHTML5Audio: true,
+      //flash 8 version of swf is buggy when calling play() on a sound that is still loading
+      flashVersion: 9
+    });
+  }
+
+  /**
+   * @override
+   * @param {number} leafIndex
+   * @param {number} numLeafs total number of leafs in the current book
+   */
+  start(leafIndex, numLeafs) {
+    var promise = null;
+
+    // Hack for iOS
+    if (navigator.userAgent.match(/mobile/i)) {
+      promise = this.iOSCaptureUserIntentHack();
+    }
+    promise = promise || Promise.resolve();
+    promise.then(() => super.start(leafIndex, numLeafs));
+  }
+
+  /** @override */
+  createSound(chunk) {
+    return new FestivalTTSSound(this.getSoundUrl(chunk.text));
+  }
+
+  /**
+   * @private
+   * Get URL for audio that says this text
+   * @param {String} dataString the thing to say
+   * @return {String} url
+   */
+  getSoundUrl(dataString) {
+    return 'https://' + this.opts.server + '/BookReader/BookReaderGetTTS.php?string=' + encodeURIComponent(dataString) + '&format=.' + this.audioFormat;
+  }
+
+  /**
+   * @private
+   * Security restrictions require playback to be triggered
+   * by a user click/touch. This intention gets lost in the async calls
+   * on iOS, but, for some reason, if we start the audio here, it works.
+   * See https://stackoverflow.com/questions/12206631/html5-audio-cant-play-through-javascript-unless-triggered-manually-once
+   * @return {PromiseLike}
+   */
+  iOSCaptureUserIntentHack() {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      var sound = soundManager.createSound({
+        url: SILENCE_1MS[_this.audioFormat]
+      });
+      yield new Promise(res => sound.play({
+        onfinish: res
+      }));
+      sound.destruct();
+    })();
+  }
+}
+
+/** @extends AbstractTTSSound */
+class FestivalTTSSound {
+  /** @param {string} soundUrl **/
+  constructor(soundUrl) {
+    this.soundUrl = soundUrl;
+    /** @type {SMSound} */
+    this.sound = null;
+    this.rate = 1;
+    /** @type {function} calling this resolves the "play" promise */
+    this._finishResolver = null;
+  }
+  get loaded() {
+    return this.sound && this.sound.loaded;
+  }
+  load(_onload) {
+    var _this2 = this;
+    this.sound = soundManager.createSound({
+      url: this.soundUrl,
+      // API recommended, but only fires once play started on safari
+      onload: () => {
+        if (this.rate != 1) this.sound.setPlaybackRate(this.rate);
+        _onload();
+      },
+      onresume: function () {
+        var _onresume = _asyncToGenerator(function* () {
+          yield sleep(25);
+          if (_this2.rate != 1) _this2.sound.setPlaybackRate(_this2.rate);
+        });
+        function onresume() {
+          return _onresume.apply(this, arguments);
+        }
+        return onresume;
+      }()
+    });
+    return this.sound.load();
+  }
+  play() {
+    var _this3 = this;
+    return _asyncToGenerator(function* () {
+      yield new Promise(res => {
+        _this3._finishResolver = res;
+        _this3.sound.play({
+          onfinish: res
+        });
+      });
+      _this3.sound.destruct();
+    })();
+  }
+
+  /** @override */
+  stop() {
+    this.sound.stop();
+    return Promise.resolve();
+  }
+
+  /** @override */
+  pause() {
+    this.sound.pause();
+  }
+  /** @override */
+  resume() {
+    this.sound.resume();
+  }
+  /** @override */
+  setPlaybackRate(rate) {
+    this.rate = rate;
+    this.sound.setPlaybackRate(rate);
+  }
+
+  /** @override */
+  finish() {
+    this.sound.stop();
+    this._finishResolver();
+  }
+}
+
+/** Needed to capture the audio context for iOS hack. Generated using Audacity. */
+var SILENCE_1MS = {
+  mp3: 'data:audio/mp3;base64,//uQxAAAAAAAAAAAAAAAAAAAAAAAWGluZwAAAA8AAAACAAACcQCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA//////////////////////////////////////////////////////////////////8AAAAeTEFNRTMuOTlyBJwAAAAAAAAAADUgJAaUQQABrgAAAnHIf8sZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//sQxAADwlwBKGAAACAAAD/AAAAEAAAAH///////////////+UBAMExBTUUzLjk5LjOqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqr/+xDEIAPAAAGkAAAAIAAANIAAAASqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqg==',
+  ogg: 'data:audio/ogg;base64,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'
+};

package/dist/esm/plugins/tts/PageChunk.js

@@ -0,0 +1,105 @@
+function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
+function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
+/**
+ * Class to manage a 'chunk' (approximately a paragraph) of text on a page.
+ */
+export default class PageChunk {
+  /**
+   * @param {number} leafIndex
+   * @param {number} chunkIndex
+   * @param {string} text
+   * @param {DJVURect[]} lineRects
+   */
+  constructor(leafIndex, chunkIndex, text, lineRects) {
+    this.leafIndex = leafIndex;
+    this.chunkIndex = chunkIndex;
+    this.text = text;
+    this.lineRects = lineRects;
+  }
+
+  /**
+   * @param {string} server
+   * @param {string} bookPath
+   * @param {number} leafIndex
+   * @return {Promise<PageChunk[]>}
+   */
+  static fetch(server, bookPath, leafIndex) {
+    return _asyncToGenerator(function* () {
+      var chunks = yield $.ajax({
+        type: 'GET',
+        url: "https://".concat(server, "/BookReader/BookReaderGetTextWrapper.php"),
+        cache: true,
+        xhrFields: {
+          withCredentials: window.br.protected
+        },
+        data: {
+          path: "".concat(bookPath, "_djvu.xml"),
+          page: leafIndex,
+          callback: 'false'
+        }
+      });
+      return PageChunk._fromTextWrapperResponse(leafIndex, chunks);
+    })();
+  }
+
+  /**
+   * Convert the response from BookReaderGetTextWrapper.php into a {@link PageChunk} instance
+   * @param {number} leafIndex
+   * @param {Array<[String, ...DJVURect[]]>} chunksResponse
+   * @return {PageChunk[]}
+   */
+  static _fromTextWrapperResponse(leafIndex, chunksResponse) {
+    return chunksResponse.map((c, i) => {
+      var correctedLineRects = PageChunk._fixChunkRects(c.slice(1));
+      var correctedText = PageChunk._removeDanglingHyphens(c[0]);
+      return new PageChunk(leafIndex, i, correctedText, correctedLineRects);
+    });
+  }
+
+  /**
+   * @private
+   * Sometimes the first rectangle will be ridiculously wide/tall. Find those and fix them
+   * *NOTE*: Modifies the original array and returns it.
+   * *NOTE*: This should probably be fixed on the petabox side, and then removed here
+   * Has 2 problems:
+   *  - If the rect is the last rect on the page (and hence the only rect in the array),
+   *    the rect's size isn't fixed
+   * - Because this relies on the second rect, there's a chance it won't be the right
+   *   width
+   * @param {DJVURect[]} rects
+   * @return {DJVURect[]}
+   */
+  static _fixChunkRects(rects) {
+    if (rects.length < 2) return rects;
+    var [firstRect, secondRect] = rects;
+    var [left, bottom, right] = firstRect;
+    var width = right - left;
+    var secondHeight = secondRect[1] - secondRect[3];
+    var secondWidth = secondRect[2] - secondRect[0];
+    var secondRight = secondRect[2];
+    if (width > secondWidth * 30) {
+      // Set the end to be the same
+      firstRect[2] = secondRight;
+      // And the top to be the same height
+      firstRect[3] = bottom - secondHeight;
+    }
+    return rects;
+  }
+
+  /**
+   * Remove "dangling" hyphens from read aloud text to avoid TTS stuttering
+   * @param {string} text
+   * @return {string}
+   */
+  static _removeDanglingHyphens(text) {
+    // 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, '');
+  }
+}
+
+/**
+ * @typedef {[number, number, number, number]} DJVURect
+ * coords are in l,b,r,t order
+ */

package/dist/esm/plugins/tts/PageChunkIterator.js

@@ -0,0 +1,155 @@
+function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
+function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
+import PageChunk from './PageChunk.js';
+
+/**
+ * Class that iterates over the page chunks of a book; caching/buffering
+ * as much as possible to try to ensure a smooth experience.
+ */
+export default class PageChunkIterator {
+  /**
+   * @param {number} pageCount total number of pages
+   * @param {number} start page to start on
+   * @param {PageChunkIteratorOptions} opts
+   */
+  constructor(pageCount, start, opts) {
+    this.pageCount = pageCount;
+    this.opts = Object.assign({}, DEFAULT_OPTS, opts);
+    /** Position in the chunk sequence */
+    this._cursor = {
+      page: start,
+      chunk: 0
+    };
+    /** @type {Object<number, PageChunk[]>} leaf index -> chunks*/
+    this._bufferedPages = {};
+    /** @type {Object<number, PromiseLike<PageChunk[]>} leaf index -> chunks*/
+    this._bufferingPages = {};
+    /**
+     * @type {Promise} promise that manages cursor modifications so that they
+     * happen in order triggered as opposed to order the server responds
+     **/
+    this._cursorLock = Promise.resolve();
+  }
+
+  /**
+   * Get the next chunk
+   * @return {PromiseLike<"__PageChunkIterator.AT_END__" | PageChunk>}
+   */
+  next() {
+    return this._cursorLock = this._cursorLock.then(() => this._nextUncontrolled());
+  }
+
+  /**
+   * Sends the cursor back 1
+   * @return {Promise}
+   **/
+  decrement() {
+    return this._cursorLock = this._cursorLock.then(() => this._decrementUncontrolled());
+  }
+
+  /**
+   * Gets without ensuring synchronization. Since this iterator has a lot of async
+   * code, calling e.g. "next" twice (before the first call to next has finished)
+   * would cause the system to be in a weird state. To avoid that, we make sure calls
+   * to next and decrement (functions that modify the cursor) are synchronized,
+   * so that regardless how long it takes for one to respond, they'll always be executed
+   * in the correct order.
+   * @return {PromiseLike<"__PageChunkIterator.AT_END__" | PageChunk>}
+   */
+  _nextUncontrolled() {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      if (_this._cursor.page == _this.pageCount) {
+        return Promise.resolve(PageChunkIterator.AT_END);
+      }
+      _this._recenterBuffer(_this._cursor.page);
+      var chunks = yield _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++];
+    })();
+  }
+
+  /**
+   * Decrements without ensuring synchronization. (See {@link PageChunkIterator._nextUncontrolled});
+   * @return {Promise}
+   */
+  _decrementUncontrolled() {
+    var cursorChangePromise = Promise.resolve();
+    if (this._cursor.chunk > 0) {
+      this._cursor.chunk--;
+    } else if (this._cursor.page > 0) {
+      this._cursor.page--;
+      // Go back possibly multiple pages, because pages can be blank
+      cursorChangePromise = this._fetchPageChunks(this._cursor.page).then(prevPageChunks => {
+        if (prevPageChunks.length == 0) return this._decrementUncontrolled();else this._cursor.chunk = prevPageChunks.length - 1;
+      });
+    }
+    return cursorChangePromise.then(() => this._fetchPageChunks(this._cursor.page));
+  }
+
+  /**
+   * Recenter the buffer around the provided page index
+   * @param {number} index
+   */
+  _recenterBuffer(index) {
+    var start = Math.max(0, index - this.opts.pageBufferSize);
+    var end = Math.min(this.pageCount, index + this.opts.pageBufferSize + 1);
+    for (var i = start; i < end; i++) {
+      this._fetchPageChunks(i);
+    }
+    this._removePageFromBuffer(start - 1);
+    this._removePageFromBuffer(end + 1);
+  }
+
+  /**
+   * @param {number} index
+   */
+  _removePageFromBuffer(index) {
+    delete this._bufferingPages[index];
+    delete this._bufferedPages[index];
+  }
+
+  /**
+   * Fetches the chunks on a page; checks the buffer, so it won't make unnecessary
+   * requests if it's called multiple times for the same index.
+   * @param {number} index
+   * @return {Promise<PageChunk[]>}
+   */
+  _fetchPageChunks(index) {
+    if (index in this._bufferingPages) return this._bufferingPages[index];
+    if (index in this._bufferedPages) return Promise.resolve(this._bufferedPages[index]);
+    this._bufferingPages[index] = this._fetchPageChunksDirect(index).then(chunks => {
+      delete this._bufferingPages[index];
+      this._bufferedPages[index] = chunks;
+      return chunks;
+    });
+    return this._bufferingPages[index];
+  }
+
+  /**
+   * Fetches a page without checking buffer
+   * @param {number} index
+   */
+  _fetchPageChunksDirect(index) {
+    return PageChunk.fetch(this.opts.server, this.opts.bookPath, index);
+  }
+}
+PageChunkIterator.AT_END = "__PageChunkIterator.AT_END__";
+
+/** @type {PageChunkIteratorOptions} */
+var DEFAULT_OPTS = {
+  server: null,
+  bookPath: null,
+  pageBufferSize: 2
+};
+
+/**
+ * @typedef {Object} PageChunkIteratorOptions
+ * @property {string} server
+ * @property {string} bookPath
+ * @property {number} [pageBufferSize] number of pages to buffer before/after the current page
+ */