@internetarchive/bookreader 5.0.0-95 → 5.0.0-96

package/src/BookReader/DragScrollable.js

@@ -0,0 +1,233 @@
+// @ts-check
+/*
+ * jQuery dragscrollable Plugin
+ * Based off version: 1.0 (25-Jun-2009)
+ * Copyright (c) 2009 Miquel Herrera
+ *
+ * Portions Copyright (c) 2010 Reg Braithwaite
+ *          Copyright (c) 2010 Internet Archive / Michael Ang
+ *          Copyright (c) 2016 Internet Archive / Richard Caceres
+ *
+ * Dual licensed under the MIT and GPL licenses:
+ *   http://www.opensource.org/licenses/mit-license.php
+ *   http://www.gnu.org/licenses/gpl.html
+ */
+
+/**
+ * @param {string} string_of_events
+ * @param {string} ns
+ * @returns
+ */
+function append_namespace(string_of_events, ns) {
+  return string_of_events
+    .split(' ')
+    .map(event_name => event_name + ns)
+    .join(' ');
+}
+
+function left_top(event) {
+  /** @type {number} */
+  let x;
+  /** @type {number} */
+  let y;
+  if (typeof(event.clientX) != 'undefined') {
+    x = event.clientX;
+    y = event.clientY;
+  }
+  else if (typeof(event.screenX) != 'undefined') {
+    x = event.screenX;
+    y = event.screenY;
+  }
+  else if (typeof(event.targetTouches) != 'undefined') {
+    x = event.targetTouches[0].pageX;
+    y = event.targetTouches[0].pageY;
+  }
+  else if (typeof(event.originalEvent) == 'undefined') {
+    console.error("don't understand x and y for " + event.type, event);
+  }
+  else if (typeof(event.originalEvent.clientX) != 'undefined') {
+    x = event.originalEvent.clientX;
+    y = event.originalEvent.clientY;
+  }
+  else if (typeof(event.originalEvent.screenX) != 'undefined') {
+    x = event.originalEvent.screenX;
+    y = event.originalEvent.screenY;
+  }
+  else if (typeof(event.originalEvent.targetTouches) != 'undefined') {
+    x = event.originalEvent.targetTouches[0].pageX;
+    y = event.originalEvent.targetTouches[0].pageY;
+  }
+
+  return { left: x, top: y };
+}
+
+const DEFAULT_OPTIONS = {
+  /**
+   * @type {String|HTMLElement} jQuery selector to apply to each wrapped element to
+   * find which will be the dragging elements. Defaults to the first child of scrollable
+   * element
+   */
+  dragSelector: '>:first',
+
+  /** Will the dragging element accept propagated events? default is yes, a propagated
+   * mouse event on a inner element will be accepted and processed. If set to false,
+   * only events originated on the draggable elements will be processed. */
+  acceptPropagatedEvent: true,
+
+  /**
+   * Prevents the event to propagate further effectively disabling other default actions
+   */
+  preventDefault: true,
+
+  dragstart: 'mousedown touchstart',
+  dragcontinue: 'mousemove touchmove',
+  dragend: 'mouseup touchend', // mouseleave
+  dragMinDistance: 5,
+  namespace: '.ds',
+
+  /** Scroll the window rather than the element */
+  scrollWindow: false,
+};
+
+/**
+ * Adds the ability to manage elements scroll by dragging
+ * one or more of its descendant elements. Options parameter
+ * allow to specifically select which inner elements will
+ * respond to the drag events.
+ *  usage examples:
+ *
+ *  To add the scroll by drag to the element id=viewport when dragging its
+ *  first child accepting any propagated events
+ *	`new DragScrollable($('#viewport')[0]);`
+ *
+ *  To add the scroll by drag ability to any element div of class viewport
+ *  when dragging its first descendant of class dragMe responding only to
+ *  evcents originated on the '.dragMe' elements.
+ *	```js
+ *  new DragScrollable($('div.viewport')[0], {
+ *      dragSelector: '.dragMe:first',
+ *	    acceptPropagatedEvent: false
+ *  });
+ * ```
+ *
+ *  Notice that some 'viewports' could be nested within others but events
+ *  would not interfere as acceptPropagatedEvent is set to false.
+ */
+export class DragScrollable {
+  /**
+   * @param {HTMLElement} element
+   * @param {Partial<DEFAULT_OPTIONS>} options
+   */
+  constructor(element, options = {}) {
+    this.handling_element = $(element);
+    /** @type {typeof DEFAULT_OPTIONS} */
+    this.settings = $.extend({}, DEFAULT_OPTIONS, options || {});
+    this.firstCoord = { left: 0, top: 0 };
+    this.lastCoord = { left: 0, top: 0 };
+
+    this.settings.dragstart = append_namespace(this.settings.dragstart, this.settings.namespace);
+    this.settings.dragcontinue = append_namespace(this.settings.dragcontinue, this.settings.namespace);
+    //settings.dragend = append_namespace(settings.dragend, settings.namespace);
+
+    // Set mouse initiating event on the desired descendant
+    this.handling_element.find(this.settings.dragSelector)
+      .on(this.settings.dragstart, this._dragStartHandler);
+  }
+
+  _shouldAbort() {
+    const isTouchDevice = !!('ontouchstart' in window) || !!('msmaxtouchpoints' in window.navigator);
+    return isTouchDevice;
+  }
+
+  /** @param {MouseEvent} event */
+  _dragStartHandler = (event) => {
+    if (this._shouldAbort()) { return true; }
+
+    // mousedown, left click, check propagation
+    if (event.which > 1 ||
+    (!this.settings.acceptPropagatedEvent && event.target != this.handling_element[0])) {
+      return false;
+    }
+
+    // Initial coordinates will be the last when dragging
+    this.lastCoord = this.firstCoord = left_top(event);
+
+    this.handling_element
+      .on(this.settings.dragcontinue, this._dragContinueHandler)
+    //.on(this.settings.dragend, this._dragEndHandler)
+    ;
+
+    // Note, we bind using addEventListener so we can use "capture" binding
+    // instead of "bubble" binding
+    this.settings.dragend.split(' ').forEach(event_name => {
+      this.handling_element[0].addEventListener(event_name, this._dragEndHandler, true);
+    });
+
+    if (this.settings.preventDefault) {
+      event.preventDefault();
+      return false;
+    }
+  }
+
+  /** @param {MouseEvent} event */
+  _dragContinueHandler = (event) => { // User is dragging
+    // console.log('drag continue');
+    if (this._shouldAbort()) { return true; }
+
+    const lt = left_top(event);
+
+    // How much did the mouse move?
+    const delta = {
+      left: (lt.left - this.lastCoord.left),
+      top: (lt.top - this.lastCoord.top),
+    };
+
+    const scrollTarget = this.settings.scrollWindow ? $(window) : this.handling_element;
+
+    // Set the scroll position relative to what ever the scroll is now
+    scrollTarget.scrollLeft( scrollTarget.scrollLeft() - delta.left );
+    scrollTarget.scrollTop(	scrollTarget.scrollTop() - delta.top );
+
+    // Save where the cursor is
+    this.lastCoord = lt;
+
+    if (this.settings.preventDefault) {
+      event.preventDefault();
+      return false;
+    }
+  }
+
+  /** @param {MouseEvent} event */
+  _dragEndHandler = (event) => { // Stop scrolling
+    //console.log('dragEndHandler');
+
+    if (this._shouldAbort()) { return true; }
+
+    this.handling_element
+      .off(this.settings.dragcontinue)
+      // Note, for some reason, even though I removeEventListener below,
+      // this call to unbind is still necessary. I don't know why.
+      .off(this.settings.dragend);
+
+    // Note, we bind using addEventListener so we can use "capture" binding
+    // instead of "bubble" binding
+    this.settings.dragend.split(' ').forEach(event_name => {
+      this.handling_element[0].removeEventListener(event_name, this._dragEndHandler, true);
+    });
+
+    // How much did the mouse move total?
+    const delta = {
+      left: Math.abs(this.lastCoord.left - this.firstCoord.left),
+      top: Math.abs(this.lastCoord.top - this.firstCoord.top),
+    };
+    const distance = Math.max(delta.left, delta.top);
+
+    // Allow event to propagate if min distance was not achieved
+    if (this.settings.preventDefault && distance > this.settings.dragMinDistance) {
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      event.stopPropagation();
+      return false;
+    }
+  }
+}

package/src/BookReader/ImageCache.js

@@ -0,0 +1,149 @@
+// @ts-check
+/**
+ * Creates an image cache dictionary
+ * storing images in `<img>` tags so that
+ * BookReader can leverage browser caching
+ */
+/** @typedef {import("./BookModel").BookModel} BookModel */
+/** @typedef {import("./BookModel").PageIndex} PageIndex */
+/** @typedef {import("./ReduceSet").ReduceSet} ReduceSet */
+/** @typedef {import("./options").BookReaderOptions} BookReaderOptions */
+
+import { Pow2ReduceSet } from "./ReduceSet.js";
+import { DEFAULT_OPTIONS } from "./options.js";
+
+export class ImageCache {
+  /**
+   * @param {BookModel} book
+   * @param {object} opts
+   * @param {boolean} [opts.useSrcSet]
+   * @param {ReduceSet} [opts.reduceSet]
+   * @param {BookReaderOptions['renderPageURI']} [opts.renderPageURI]
+   */
+  constructor(
+    book,
+    {
+      useSrcSet = false,
+      reduceSet = Pow2ReduceSet,
+      renderPageURI = DEFAULT_OPTIONS.renderPageURI,
+    } = {},
+  ) {
+    /** @type {BookModel} */
+    this.book = book;
+    /** @type {boolean} */
+    this.useSrcSet = useSrcSet;
+    /** @type {ReduceSet} */
+    this.reduceSet = reduceSet;
+    /** @type {BookReaderOptions['renderPageURI']} */
+    this.renderPageURI = renderPageURI;
+
+    /** @type {{ [index: number]: { reduce: number, loaded: boolean }[] }} */
+    this.cache = {};
+    this.defaultScale = 8;
+  }
+
+  /**
+   * Get an image
+   * Checks cache first if image is available & of equal/better scale,
+   * if not, a new image gets created
+   *
+   * @param {PageIndex} index
+   * @param {Number} reduce
+   * @param {HTMLImageElement?} [img]
+   */
+  image(index, reduce, img = null) {
+    const finalReduce = this.getFinalReduce(index, reduce);
+    return this._serveImageElement(index, finalReduce, img);
+  }
+
+  /**
+   * Get the final reduce factor to use for the given index
+   *
+   * @param {PageIndex} index
+   * @param {Number} reduce
+   */
+  getFinalReduce(index, reduce) {
+    const cachedImages = this.cache[index] || [];
+    const sufficientImages = cachedImages
+      .filter(x => x.loaded && x.reduce <= reduce);
+
+    if (sufficientImages.length) {
+      // Choose the largest reduction factor that meets our needs
+      const bestReduce = Math.max(...sufficientImages.map(e => e.reduce));
+      // Don't need to floor here, since we know the image is in the cache
+      // and hence was already floor'd by the below `else` clause before
+      // it was added
+      return bestReduce;
+    } else {
+      // Don't use a cache entry; i.e. a fresh fetch will be made
+      // for this reduce
+      return this.reduceSet.floor(reduce);
+    }
+  }
+
+  /**
+   * Checks if an image of equal or greater quality has been loaded
+   * @param {PageIndex} index
+   * @param {Number} reduce
+   * @returns {Boolean}
+   */
+  imageLoaded(index, reduce) {
+    const cacheImg = this.cache[index]?.find(e => e.reduce <= reduce);
+    return cacheImg?.loaded ?? false;
+  }
+
+  /**
+   * Get the best image that's already loaded for the given index,
+   * trying to choose values less that the given reduce
+   * @param {PageIndex} index
+   * @param idealMaxReduce
+   * @returns {null | number}
+   */
+  getBestLoadedReduce(index, idealMaxReduce = Infinity) {
+    const candidates = this.cache[index]?.filter(x => x.loaded) || [];
+    if (!candidates.length) return null;
+
+    const lowerResImages = candidates.filter(e => e.reduce >= idealMaxReduce);
+    if (lowerResImages.length) {
+      // Choose the highest quality loaded lower res image
+      return Math.min(...lowerResImages.map(e => e.reduce));
+    }
+    // Otherwise choose whatever is closest to the reduce
+    const higherRestImages = candidates.filter(e => e.reduce < idealMaxReduce);
+    return Math.max(...higherRestImages.map(e => e.reduce));
+  }
+
+  /**
+   * @private
+   * Generates an image element on the fly from image info in cache
+   *
+   * @param {PageIndex} index
+   * @param {number} reduce
+   * @param {HTMLImageElement?} [img]
+   * @returns {JQuery<HTMLImageElement>} with base image classes
+   */
+  _serveImageElement(index, reduce, img = null) {
+    let cacheEntry = this.cache[index]?.find(e => e.reduce == reduce);
+    if (!cacheEntry) {
+      cacheEntry = { reduce, loaded: false };
+      const entries = this.cache[index] || (this.cache[index] = []);
+      entries.push(cacheEntry);
+    }
+    const page = this.book.getPage(index);
+
+    const uri = page.getURI(reduce, 0);
+    const $img = $(img || document.createElement('img'))
+      .addClass('BRpageimage')
+      .attr('alt', 'Book page image')
+      .data('reduce', reduce)
+      .data('src', uri);
+    this.renderPageURI($img[0], uri);
+    if (this.useSrcSet) {
+      $img.attr('srcset', page.getURISrcSet(reduce));
+    }
+    if (!cacheEntry.loaded) {
+      $img.one('load', () => cacheEntry.loaded = true);
+    }
+    return $img;
+  }
+}

package/src/BookReader/Mode1Up.js

@@ -0,0 +1,110 @@
+// @ts-check
+import { Mode1UpLit } from './Mode1UpLit.js';
+import { DragScrollable } from './DragScrollable.js';
+/** @typedef {import('../BookReader.js').default} BookReader */
+/** @typedef {import('./BookModel.js').BookModel} BookModel */
+/** @typedef {import('./BookModel.js').PageIndex} PageIndex */
+
+export class Mode1Up {
+  name = '1up'
+
+  /**
+   * @param {BookReader} br
+   * @param {BookModel} bookModel
+   */
+  constructor(br, bookModel) {
+    this.br = br;
+    this.book = bookModel;
+    this.mode1UpLit = new Mode1UpLit(bookModel, br);
+
+    /** @private */
+    this.$el = $(this.mode1UpLit)
+      // We CANNOT use `br-mode-1up` as a class, because it's the same
+      // as the name of the web component, and the webcomponents polyfill
+      // uses the name of component as a class for style scoping 😒
+      .addClass('br-mode-1up__root BRmode1up');
+
+    /** Has mode1up ever been rendered before? */
+    this.everShown = false;
+  }
+
+  // TODO: Might not need this anymore? Might want to delete.
+  /** @private */
+  get $brContainer() { return this.br.refs.$brContainer; }
+
+  /**
+   * This is called when we switch to one page view
+   */
+  prepare() {
+    const startLeaf = this.br.currentIndex();
+    this.$brContainer
+      .empty()
+      .css({ overflow: 'hidden' })
+      .append(this.$el);
+
+    // Need this in a setTimeout so that it happens after the browser has _actually_
+    // appended the element to the DOM
+    setTimeout(async () => {
+      if (!this.everShown) {
+        this.mode1UpLit.initFirstRender(startLeaf);
+        this.everShown = true;
+        this.mode1UpLit.requestUpdate();
+        await this.mode1UpLit.updateComplete;
+        new DragScrollable(this.mode1UpLit, {
+          preventDefault: true,
+          dragSelector: '.br-mode-1up__visible-world',
+          // Only handle mouse events; let browser/interact.js handle touch
+          dragstart: 'mousedown',
+          dragcontinue: 'mousemove',
+          dragend: 'mouseup',
+        });
+      }
+      this.mode1UpLit.jumpToIndex(startLeaf);
+      setTimeout(() => {
+        // Must explicitly call updateVisibleRegion, since no
+        // scroll event seems to fire.
+        this.mode1UpLit.updateVisibleRegion();
+      });
+    });
+    this.br.updateBrClasses();
+  }
+
+  /**
+   * BREAKING CHANGE: No longer supports pageX/pageY
+   * @param {PageIndex} index
+   * @param {number} [pageX] x position on the page (in pixels) to center on
+   * @param {number} [pageY] y position on the page (in pixels) to center on
+   * @param {boolean} [noAnimate]
+   */
+  jumpToIndex(index, pageX, pageY, noAnimate) {
+    // Only smooth for small distances
+    const distance = Math.abs(this.br.currentIndex() - index);
+    const smooth = !noAnimate && distance > 0 && distance <= 4;
+    this.mode1UpLit.jumpToIndex(index, { smooth });
+  }
+
+  /**
+   * @param {'in' | 'out'} direction
+   */
+  zoom(direction) {
+    switch (direction) {
+    case 'in':
+      this.mode1UpLit.zoomIn();
+      break;
+    case 'out':
+      this.mode1UpLit.zoomOut();
+      break;
+    default:
+      console.error(`Unsupported direction: ${direction}`);
+    }
+  }
+
+  /**
+   * Resize the current one page view
+   * Note this calls drawLeafs
+   */
+  resizePageView() {
+    this.mode1UpLit.htmlDimensionsCacher.updateClientSizes();
+    this.mode1UpLit.requestUpdate();
+  }
+}