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

package/dist/esm/BookReader/BookModel.js

@@ -0,0 +1,575 @@
+// @ts-check
+import { DEFAULT_OPTIONS } from './options.js';
+import { clamp } from './utils.js';
+/** @typedef {import('./options.js').PageData} PageData */
+/** @typedef {import('../BookReader.js').default} BookReader */
+
+/**
+ * Contains information about the Book/Document independent of the way it is
+ * being rendering. Nothing here should reference e.g. the mode, zoom, etc.
+ * It's just information about the book and its pages (usually as specified
+ * in the BookReader data option.)
+ */
+export class BookModel {
+  /**
+   * @param {BookReader} br
+   */
+  constructor(br) {
+    var _br$options$ppi, _br$options, _br$options$pageProgr, _br$options2;
+    this.br = br;
+    this.reduceSet = br.reduceSet;
+    this.ppi = (_br$options$ppi = (_br$options = br.options) === null || _br$options === void 0 ? void 0 : _br$options.ppi) !== null && _br$options$ppi !== void 0 ? _br$options$ppi : DEFAULT_OPTIONS.ppi;
+    /** @type {'lr' | 'rl'} Page progression */
+    this.pageProgression = (_br$options$pageProgr = (_br$options2 = br.options) === null || _br$options2 === void 0 ? void 0 : _br$options2.pageProgression) !== null && _br$options$pageProgr !== void 0 ? _br$options$pageProgr : DEFAULT_OPTIONS.pageProgression;
+
+    /** @type {{width: number, height: number}} memoize storage */
+    this._medianPageSize = null;
+    /** @type {[PageData[], number]} */
+    this._getDataFlattenedCached = null;
+  }
+
+  /** Get median width/height of page in inches. Memoized for performance. */
+  getMedianPageSizeInches() {
+    if (this._medianPageSize) {
+      return this._medianPageSize;
+    }
+    var widths = [];
+    var heights = [];
+    for (var page of this.pagesIterator()) {
+      widths.push(page.widthInches);
+      heights.push(page.heightInches);
+    }
+    widths.sort((a, b) => a - b);
+    heights.sort((a, b) => a - b);
+    this._medianPageSize = {
+      width: widths[Math.floor(widths.length / 2)],
+      height: heights[Math.floor(heights.length / 2)]
+    };
+    return this._medianPageSize;
+  }
+
+  /**
+   * Returns the page width for the given index, or first or last page if out of range
+   * @deprecated see getPageWidth
+   * @param {PageIndex} index
+   */
+  _getPageWidth(index) {
+    // Synthesize a page width for pages not actually present in book.
+    // May or may not be the best approach.
+    // If index is out of range we return the width of first or last page
+    index = clamp(index, 0, this.getNumLeafs() - 1);
+    return this.getPageWidth(index);
+  }
+
+  /**
+   * Returns the page height for the given index, or first or last page if out of range
+   * @deprecated see getPageHeight
+   * @param {PageIndex} index
+   */
+  _getPageHeight(index) {
+    var clampedIndex = clamp(index, 0, this.getNumLeafs() - 1);
+    return this.getPageHeight(clampedIndex);
+  }
+
+  /**
+   * Returns the *highest* index the given page number, or undefined
+   * @param {PageNumString} pageNum
+   * @return {PageIndex|undefined}
+   */
+  getPageIndex(pageNum) {
+    var pageIndices = this.getPageIndices(pageNum);
+    return pageIndices.length ? pageIndices[pageIndices.length - 1] : undefined;
+  }
+
+  /**
+   * Returns an array (possibly empty) of the indices with the given page number
+   * @param {PageNumString} pageNum
+   * @return {PageIndex[]}
+   */
+  getPageIndices(pageNum) {
+    var indices = [];
+
+    // Check for special "nXX" page number
+    if (pageNum.slice(0, 1) == 'n') {
+      try {
+        var pageIntStr = pageNum.slice(1, pageNum.length);
+        var pageIndex = parseInt(pageIntStr);
+        indices.push(pageIndex);
+        return indices;
+      } catch (err) {
+        // Do nothing... will run through page names and see if one matches
+      }
+    }
+    for (var i = 0; i < this.getNumLeafs(); i++) {
+      if (this.getPageNum(i) == pageNum) {
+        indices.push(i);
+      }
+    }
+    return indices;
+  }
+
+  /**
+   * Returns the name of the page as it should be displayed in the user interface
+   * @param {PageIndex} index
+   * @return {string}
+   */
+  getPageName(index) {
+    return 'Page ' + this.getPageNum(index);
+  }
+
+  /**
+   * @return {number} the total number of leafs (like an array length)
+   */
+  getNumLeafs() {
+    // For deprecated interface support, if numLeafs is set, use that.
+    if (this.br.numLeafs !== undefined) return this.br.numLeafs;
+    return this._getDataFlattened().length;
+  }
+
+  /**
+   * @param  {PageIndex} index
+   * @return {Number|undefined}
+   */
+  getPageWidth(index) {
+    return this.getPageProp(index, 'width');
+  }
+
+  /**
+   * @param  {PageIndex} index
+   * @return {Number|undefined}
+   */
+  getPageHeight(index) {
+    return this.getPageProp(index, 'height');
+  }
+
+  /**
+   * @param  {PageIndex} index
+   * @param  {number} reduce - not used in default implementation
+   * @param  {number} rotate - not used in default implementation
+   * @return {string|undefined}
+   */
+  // eslint-disable-next-line no-unused-vars
+  getPageURI(index, reduce, rotate) {
+    if (!this.getPageProp(index, 'viewable', true)) {
+      var uri = this.br.options.unviewablePageURI;
+      if (uri.startsWith('.')) {
+        // It's a relative path, so make it relative to the images path
+        return this.br.options.imagesBaseURL + uri;
+      } else {
+        return uri;
+      }
+    } else {
+      return this.getPageProp(index, 'uri');
+    }
+  }
+
+  /**
+   * @param {PageIndex} index
+   * @return {'L' | 'R'}
+   */
+  getPageSide(index) {
+    return this.getPageProp(index, 'pageSide') || (index % 2 === 0 ? 'R' : 'L');
+  }
+
+  /**
+   * @param {PageIndex} index
+   * @return {PageNumString}
+   */
+  getPageNum(index) {
+    var pageNum = this.getPageProp(index, 'pageNum');
+    return pageNum === undefined ? "n".concat(index) : pageNum;
+  }
+
+  /**
+   * Generalized property accessor.
+   * @param  {PageIndex} index
+   * @param {keyof PageData} propName
+   * @param {*} [fallbackValue] return if undefined
+   * @return {*|undefined}
+   */
+  getPageProp(index, propName) {
+    var fallbackValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+    return this._getDataProp(index, propName, fallbackValue);
+  }
+
+  /**
+   * This function returns the left and right indices for the user-visible
+   * spread that contains the given index.
+   * @note Can return indices out of range of what's in the book.
+   * @param  {PageIndex} pindex
+   * @return {[PageIndex, PageIndex]} eg [0, 1]
+   */
+  getSpreadIndices(pindex) {
+    if (this.pageProgression == 'rl') {
+      return this.getPageSide(pindex) == 'R' ? [pindex + 1, pindex] : [pindex, pindex - 1];
+    } else {
+      return this.getPageSide(pindex) == 'L' ? [pindex, pindex + 1] : [pindex - 1, pindex];
+    }
+  }
+
+  /**
+   * Single images in the Internet Archive scandata.xml metadata are (somewhat incorrectly)
+   * given a "leaf" number.  Some of these images from the scanning process should not
+   * be displayed in the BookReader (for example colour calibration cards).  Since some
+   * of the scanned images will not be displayed in the BookReader (those marked with
+   * addToAccessFormats false in the scandata.xml) leaf numbers and BookReader page
+   * indexes are generally not the same.  This function returns the BookReader page
+   * index given a scanned leaf number.
+   *
+   * This function is used, for example, to map between search results (that use the
+   * leaf numbers) and the displayed pages in the BookReader.
+   * @param {LeafNum} leafNum
+   * @return {PageIndex}
+   */
+  leafNumToIndex(leafNum) {
+    var index = this._getDataFlattened().findIndex(d => d.leafNum == leafNum);
+    // If no match is found, fall back to the leafNum provide (leafNum == index)
+    return index > -1 ? index : leafNum;
+  }
+
+  /**
+   * Parses the pageString format
+   * @param {PageString} pageString
+   * @return {PageIndex|undefined}
+   */
+  parsePageString(pageString) {
+    var pageIndex;
+    // Check for special "leaf"
+    var leafMatch = /^leaf(\d+)/.exec(pageString);
+    if (leafMatch) {
+      pageIndex = this.leafNumToIndex(parseInt(leafMatch[1], 10));
+      if (pageIndex === null) {
+        pageIndex = undefined; // to match return type of getPageIndex
+      }
+    } else {
+      pageIndex = this.getPageIndex(pageString);
+    }
+    return pageIndex;
+  }
+
+  /**
+   * @param {number} index use negatives to get page relative to end
+   * @param loop whether to loop (i.e. -1 == last page)
+   */
+  getPage(index) {
+    var loop = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    var numLeafs = this.getNumLeafs();
+    if (!loop && (index < 0 || index >= numLeafs)) {
+      return undefined;
+    }
+    if (index < 0 && index >= -numLeafs) {
+      index += numLeafs;
+    }
+    index = index % numLeafs;
+    return new PageModel(this, index);
+  }
+
+  /**
+   * @param {object} [arg0]
+   * @param {number} [arg0.start] inclusive
+   * @param {number} [arg0.end] exclusive
+   * @param {boolean} [arg0.combineConsecutiveUnviewables] Yield only first unviewable
+   * of a chunk of unviewable pages instead of each page
+   */
+  pagesIterator() {
+    var _this = this;
+    var {
+      start = 0,
+      end = Infinity,
+      combineConsecutiveUnviewables = false
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return function* () {
+      start = Math.max(0, start);
+      end = Math.min(end, _this.getNumLeafs());
+      for (var i = start; i < end; i++) {
+        var page = _this.getPage(i);
+        if (combineConsecutiveUnviewables && page.isConsecutiveUnviewable) continue;
+        yield page;
+      }
+    }();
+  }
+
+  /**
+   * Flatten the nested structure (make 1d array), and also add pageSide prop
+   * @return {PageData[]}
+   */
+  _getDataFlattened() {
+    if (this._getDataFlattenedCached && this._getDataFlattenedCached[1] === this.br.data.length) return this._getDataFlattenedCached[0];
+    var prevPageSide = null;
+    /** @type {number|null} */
+    var unviewablesChunkStart = null;
+    var index = 0;
+    // @ts-ignore TS doesn't know about flatMap for some reason
+    var flattened = this.br.data.flatMap(spread => {
+      return spread.map(page => {
+        if (!page.pageSide) {
+          if (prevPageSide === null) {
+            page.pageSide = spread.length === 2 ? 'L' : 'R';
+          } else {
+            page.pageSide = prevPageSide === 'L' ? 'R' : 'L';
+          }
+        }
+        prevPageSide = page.pageSide;
+        if (page.viewable === false) {
+          if (unviewablesChunkStart === null) {
+            page.unviewablesStart = unviewablesChunkStart = index;
+          } else {
+            page.unviewablesStart = unviewablesChunkStart;
+          }
+        } else {
+          unviewablesChunkStart = null;
+        }
+        index++;
+        return page;
+      });
+    });
+
+    // length is used as a cache breaker
+    this._getDataFlattenedCached = [flattened, this.br.data.length];
+    return flattened;
+  }
+
+  /**
+   * Helper. Return a prop for a given index. Returns `fallbackValue` if index is invalid or
+   * property not on page.
+   * @param {PageIndex} index
+   * @param {keyof PageData} prop
+   * @param {*} fallbackValue return if property not on the record
+   * @return {*}
+   */
+  _getDataProp(index, prop) {
+    var fallbackValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+    var dataf = this._getDataFlattened();
+    var invalidIndex = isNaN(index) || index < 0 || index >= dataf.length;
+    if (invalidIndex || 'undefined' == typeof dataf[index][prop]) return fallbackValue;
+    return dataf[index][prop];
+  }
+}
+
+/**
+ * A controlled schema for page data.
+ */
+export class PageModel {
+  /**
+   * @param {BookModel} book
+   * @param {PageIndex} index
+   */
+  constructor(book, index) {
+    // Values less than 10 cause the UI to not work correctly
+    var pagePPI = book._getDataProp(index, 'ppi', book.ppi);
+    this.ppi = Math.max(pagePPI < 10 ? book.ppi : pagePPI, 10);
+    this.book = book;
+    this.index = index;
+    this.width = book.getPageWidth(index);
+    this.widthInches = this.width / this.ppi;
+    this.height = book.getPageHeight(index);
+    this.heightInches = this.height / this.ppi;
+    this.pageSide = book.getPageSide(index);
+    this.leafNum = book._getDataProp(index, 'leafNum', this.index);
+
+    /** @type {boolean} */
+    this.isViewable = book._getDataProp(index, 'viewable', true);
+    /** @type {PageIndex} The first in the series of unviewable pages this is in. */
+    this.unviewablesStart = book._getDataProp(index, 'unviewablesStart') || null;
+    /**
+     * Consecutive unviewable pages are pages in an unviewable "chunk" which are not the first
+     * of that chunk.
+     */
+    this.isConsecutiveUnviewable = !this.isViewable && this.unviewablesStart != this.index;
+    this._rawData = this.book._getDataFlattened()[this.index];
+  }
+
+  /**
+   * Updates the page to no longer be unviewable. Assumes the
+   * Page's URI is already set/correct.
+   */
+  makeViewable() {
+    var newViewableState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    if (this.isViewable == newViewableState) return;
+    if (newViewableState) {
+      this._rawData.viewable = true;
+      delete this._rawData.unviewablesStart;
+      // Update any subsequent page to now point to the right "start"
+      for (var page of this.book.pagesIterator({
+        start: this.index + 1
+      })) {
+        if (page.isViewable) break;
+        page._rawData.unviewablesStart = this.index + 1;
+      }
+    } else {
+      this._rawData.viewable = false;
+      this._rawData.unviewablesStart = this.prev && !this.prev.isViewable ? this.prev.unviewablesStart : this.index;
+      // Update any subsequent page to now point to the right "start"
+      for (var _page of this.book.pagesIterator({
+        start: this.index + 1
+      })) {
+        if (!_page.isViewable) break;
+        _page._rawData.unviewablesStart = this._rawData.unviewablesStart;
+      }
+    }
+  }
+  get prev() {
+    return this.findPrev();
+  }
+  get next() {
+    return this.findNext();
+  }
+
+  /** @type {PageModel | null} */
+  get left() {
+    return this.book.pageProgression === 'lr' ? this.prev : this.next;
+  }
+
+  /** @type {PageModel | null} */
+  get right() {
+    return this.book.pageProgression === 'lr' ? this.next : this.prev;
+  }
+
+  /**
+   * @type {{left: PageModel | null, right: PageModel | null}}
+   */
+  get spread() {
+    return {
+      left: this.pageSide === 'L' ? this : this.left,
+      right: this.pageSide === 'R' ? this : this.right
+    };
+  }
+
+  /**
+   * @param {number} pages
+   */
+  goLeft(pages) {
+    var newIndex = this.book.pageProgression === 'lr' ? this.index - pages : this.index + pages;
+    return this.book.getPage(newIndex);
+  }
+
+  /**
+   * @param {number} pages
+   */
+  goRight(pages) {
+    var newIndex = this.book.pageProgression === 'lr' ? this.index + pages : this.index - pages;
+    return this.book.getPage(newIndex);
+  }
+
+  /**
+   * @param {number} reduce
+   * @param {number} rotate
+   */
+  getURI(reduce, rotate) {
+    return this.book.getPageURI(this.index, reduce, rotate);
+  }
+
+  /**
+   * Returns the srcset with correct URIs or void string if out of range
+   * @param {number} reduce
+   * @param {number} [rotate]
+   */
+  getURISrcSet(reduce) {
+    var rotate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    var {
+      reduceSet
+    } = this.book;
+    var initialReduce = reduceSet.floor(reduce);
+    // We don't need to repeat the initial reduce in the srcset
+    var topReduce = reduceSet.decr(initialReduce);
+    var reduces = [];
+    for (var r = topReduce; r >= 1; r = reduceSet.decr(r)) {
+      reduces.push(r);
+    }
+    return reduces.map(r => "".concat(this.getURI(r, rotate), " ").concat(initialReduce / r, "x")).join(', ');
+  }
+
+  /**
+   * @param {object} [arg0]
+   * @param {boolean} [arg0.combineConsecutiveUnviewables] Whether to only yield the first page
+   * of a series of unviewable pages instead of each page
+   * @return {PageModel|void}
+   */
+  findNext() {
+    var {
+      combineConsecutiveUnviewables = false
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return this.book.pagesIterator({
+      start: this.index + 1,
+      combineConsecutiveUnviewables
+    }).next().value;
+  }
+
+  /**
+   * @param {object} [arg0]
+   * @param {boolean} [arg0.combineConsecutiveUnviewables] Whether to only yield the first page
+   * of a series of unviewable pages instead of each page
+   * @return {PageModel|void}
+   */
+  findPrev() {
+    var {
+      combineConsecutiveUnviewables = false
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    if (this.index == 0) return undefined;
+    if (combineConsecutiveUnviewables) {
+      if (this.isConsecutiveUnviewable) {
+        return this.book.getPage(this.unviewablesStart);
+      } else {
+        // Recursively goes backward through the book
+        // TODO make a reverse iterator to make it look identical to findNext
+        var prev = new PageModel(this.book, this.index - 1);
+        return prev.isViewable ? prev : prev.findPrev({
+          combineConsecutiveUnviewables
+        });
+      }
+    } else {
+      return new PageModel(this.book, this.index - 1);
+    }
+  }
+
+  /**
+   * @param {object} [arg0]
+   * @param {boolean} [arg0.combineConsecutiveUnviewables] Whether to only yield the first page
+   * of a series of unviewable pages instead of each page
+   * @return {PageModel|void}
+   */
+  findLeft() {
+    var {
+      combineConsecutiveUnviewables = false
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return this.book.pageProgression === 'lr' ? this.findPrev({
+      combineConsecutiveUnviewables
+    }) : this.findNext({
+      combineConsecutiveUnviewables
+    });
+  }
+
+  /**
+   * @param {object} [arg0]
+   * @param {boolean} [arg0.combineConsecutiveUnviewables] Whether to only yield the first page
+   * of a series of unviewable pages instead of each page
+   * @return {PageModel|void}
+   */
+  findRight() {
+    var {
+      combineConsecutiveUnviewables = false
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return this.book.pageProgression === 'lr' ? this.findNext({
+      combineConsecutiveUnviewables
+    }) : this.findPrev({
+      combineConsecutiveUnviewables
+    });
+  }
+}
+
+// There are a few main ways we can reference a specific page in a book:
+/**
+ * @typedef {string} PageNumString
+ * Possible values: /^n?\d+$/. Example: 'n7', '18'
+ * Not necessarily unique
+ */
+/**
+ * @typedef {number} LeafNum
+ * No clue if 0 or 1 indexed or consecutive; generally from IA book info.
+ */
+/**
+ * @typedef {string} PageString
+ * Possible values: /^(leaf)?\d+$/ Example: 'leaf7', '18'
+ * If leaf-prefixed, then the number is a LeafNum. Otherwise it's a PageNumString
+ */
+/** @typedef {number} PageIndex 0-based index of all the pages */