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

package/dist/esm/BookNavigator/bookmarks/ia-bookmarks.js

@@ -0,0 +1,521 @@
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+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); }); }; }
+function _taggedTemplateLiteral(e, t) { return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, { raw: { value: Object.freeze(t) } })); }
+import { LitElement, html, css, render } from 'lit';
+// eslint-disable-next-line no-unused-vars
+import { ModalConfig, ModalManager } from '@internetarchive/modal-manager';
+import buttonStyles from '../assets/button-base.js';
+import './bookmarks-loginCTA.js';
+var api = {
+  endpoint: '/services/bookmarks.php',
+  headers: {
+    'Content-Type': 'application/json'
+  },
+  delete(page) {
+    return fetch("".concat(this.endpoint, "?identifier=").concat(this.identifier, "&page_num=").concat(page), {
+      credentials: 'same-origin',
+      method: 'DELETE',
+      headers: this.headers
+    });
+  },
+  get(page) {
+    return fetch("".concat(this.endpoint, "?identifier=").concat(this.identifier, "&page_num=").concat(page), {
+      credentials: 'same-origin',
+      method: 'GET',
+      headers: this.headers
+    });
+  },
+  getAll() {
+    return fetch("".concat(this.endpoint, "?identifier=").concat(this.identifier), {
+      credentials: 'same-origin',
+      method: 'GET',
+      headers: this.headers
+    });
+  },
+  post(bookmark) {
+    return this.sendBookmarkData(bookmark, 'POST');
+  },
+  put(bookmark) {
+    return this.sendBookmarkData(bookmark, 'POST');
+  },
+  sendBookmarkData(bookmark, method) {
+    var notes = {
+      note: bookmark.note,
+      color: bookmark.color
+    };
+    return fetch("".concat(this.endpoint, "?identifier=").concat(this.identifier, "&page_num=").concat(bookmark.id), {
+      credentials: 'same-origin',
+      method,
+      headers: this.headers,
+      body: JSON.stringify({
+        notes
+      })
+    });
+  }
+};
+class IABookmarks extends LitElement {
+  static get properties() {
+    return {
+      activeBookmarkID: {
+        type: String
+      },
+      bookmarks: {
+        type: Array
+      },
+      bookreader: {
+        type: Object
+      },
+      displayMode: {
+        type: String
+      },
+      editedBookmark: {
+        type: Object
+      },
+      deleteModalConfig: {
+        type: Object
+      },
+      modal: {
+        attribute: false
+      },
+      loginOptions: {
+        type: Object,
+        attribute: false
+      }
+    };
+  }
+  static get styles() {
+    var mainCss = css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n      .bookmarks {\n        height: 100%;\n        overflow: hidden;\n        padding-bottom: 20px;\n      }\n\n      .list ia-bookmark-edit {\n        display: none;\n      }\n\n      .edit ia-bookmarks-list {\n        display: none;\n      }\n    "])));
+    return [buttonStyles, mainCss];
+  }
+  static formatPage(page) {
+    return isNaN(+page) ? "(".concat(page.replace(/\D/g, ''), ")") : page;
+  }
+  constructor() {
+    super();
+    this.bookmarks = [];
+    this.bookreader = {};
+    this.editedBookmark = {};
+    /** @type {ModalManager} */
+    this.modal = undefined;
+    this.loginOptions = {
+      loginClicked: () => {},
+      loginUrl: ''
+    };
+    /**
+     * Toggles display to either bookmarks or login cta
+     * @param {('bookmarks'|'login')} displayMode
+     */
+    this.displayMode = 'bookmarks';
+    this.bookmarkColors = [{
+      id: 0,
+      className: 'red'
+    }, {
+      id: 1,
+      className: 'blue'
+    }, {
+      id: 2,
+      className: 'green'
+    }];
+
+    // eslint-disable-next-line
+    this.defaultColor = this.bookmarkColors[0];
+    this.api = api;
+    this.deleteModalConfig = new ModalConfig({
+      title: 'Delete Bookmark',
+      headline: 'This bookmark contains a note. Deleting it will permanently delete the note. Are you sure?',
+      headerColor: '#194880'
+    });
+  }
+  updated(changed) {
+    if (changed.has('displayMode')) {
+      this.updateDisplay();
+    }
+    this.emitBookmarksChanged();
+  }
+  setup() {
+    this.api.identifier = this.getIdentifier();
+    if (this.displayMode === 'login') {
+      return;
+    }
+    this.fetchUserBookmarks();
+    this.setBREventListeners();
+  }
+
+  /**
+   * get identifier for current book including sub-files
+   *
+   * @returns Identifer
+   */
+  getIdentifier() {
+    if (this.bookreader.bookId !== this.bookreader.subPrefix) {
+      return "".concat(this.bookreader.bookId, "/").concat(this.bookreader.subPrefix);
+    }
+    return this.bookreader.bookId;
+  }
+  updateDisplay() {
+    if (this.displayMode === 'bookmarks') {
+      this.fetchUserBookmarks();
+    }
+  }
+  fetchUserBookmarks() {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      if (!_this.api.identifier) {
+        return;
+      }
+      yield _this.fetchBookmarks();
+      _this.initializeBookmarks();
+    })();
+  }
+  setBREventListeners() {
+    ['3PageViewSelected'].forEach(event => {
+      window.addEventListener("BookReader:".concat(event), e => {
+        setTimeout(() => {
+          // wait a lil bit so bookreader can draw its DOM to attach onto
+          this.renderBookmarkButtons();
+        }, 100);
+      });
+    });
+    ['pageChanged', '1PageViewSelected', '2PageViewSelected'].forEach(event => {
+      window.addEventListener("BookReader:".concat(event), e => {
+        setTimeout(() => {
+          // wait a lil bit so bookreader can draw its DOM to attach onto
+          this.renderBookmarkButtons();
+          this.markActiveBookmark();
+        }, 100);
+      });
+    });
+    ['zoomOut', 'zoomIn', 'resize'].forEach(event => {
+      window.addEventListener("BookReader:".concat(event), () => {
+        this.renderBookmarkButtons();
+      });
+    });
+  }
+  initializeBookmarks() {
+    this.renderBookmarkButtons();
+    this.markActiveBookmark(true);
+    this.emitBookmarksChanged();
+  }
+
+  /**
+   * @typedef {object} Bookmark
+   * @property {number} id - bookreader page index, becomes key store
+   * @property {number} color - color number
+   * @property {string} page - bookmark's page label to display
+   * @property {string} note - optional, note that one can add
+   * @property {string} thumbnail - optional, image url
+   */
+  /**
+   * Formats bookmark view model
+   * @param {Object} bookmarkAttrs
+   * @param {number} bookmarkAttrs.leafNum
+   * @param {string} bookmarkAttrs.notes
+   *
+   * @returns Bookmark
+   */
+  formatBookmark(_ref) {
+    var {
+      leafNum = '',
+      notes = {}
+    } = _ref;
+    var {
+      note = '',
+      color
+    } = notes;
+    var nomalizedParams = {
+      note,
+      color: this.getBookmarkColor(color) ? color : this.defaultColor.id
+    };
+    var page = IABookmarks.formatPage(this.bookreader.book.getPageNum(leafNum));
+    var thumbnail = this.bookreader.book.getPageURI("".concat(leafNum).replace(/\D/g, ''), 32); // Request thumbnail 1/32 the size of original image
+    var bookmark = _objectSpread(_objectSpread({}, nomalizedParams), {}, {
+      id: leafNum,
+      leafNum,
+      page,
+      thumbnail
+    });
+    return bookmark;
+  }
+  fetchBookmarks() {
+    var _this2 = this;
+    return _asyncToGenerator(function* () {
+      var resText = yield _this2.api.getAll().then(r => r.text());
+      var parsedResponse;
+      try {
+        parsedResponse = JSON.parse(resText);
+      } catch (e) {
+        parsedResponse = {
+          error: e.message
+        };
+      }
+      var {
+        success,
+        error = 'Something happened while fetching bookmarks.',
+        value: bkmrks = []
+      } = parsedResponse;
+      if (!success) {
+        var _console;
+        (_console = console) === null || _console === void 0 || _console.warn('Error fetching bookmarks', error);
+      }
+      var bookmarks = {};
+      Object.keys(bkmrks).forEach(leafNum => {
+        var bookmark = bkmrks[leafNum];
+        var formattedLeafNum = parseInt(leafNum, 10);
+        var formattedBookmark = _this2.formatBookmark(_objectSpread(_objectSpread({}, bookmark), {}, {
+          leafNum: formattedLeafNum
+        }));
+        bookmarks[leafNum] = formattedBookmark;
+      });
+      _this2.bookmarks = bookmarks;
+      return bookmarks;
+    })();
+  }
+  emitBookmarksChanged() {
+    this.dispatchEvent(new CustomEvent('bookmarksChanged', {
+      bubbles: true,
+      composed: true,
+      detail: {
+        bookmarks: this.bookmarks
+      }
+    }));
+  }
+  emitBookmarkButtonClicked() {
+    this.dispatchEvent(new CustomEvent('bookmarkButtonClicked', {
+      bubbles: true,
+      composed: true,
+      detail: {
+        editedBookmark: this.editedBookmark
+      }
+    }));
+  }
+  bookmarkButtonClicked(pageID) {
+    if (this.getBookmark(pageID)) {
+      this.confirmDeletion(pageID);
+    } else {
+      this.createBookmark(pageID);
+    }
+  }
+  renderBookmarkButtons() {
+    var pages = this.bookreader.$('.BRpagecontainer').not('.BRemptypage').get();
+    pages.forEach(pageEl => {
+      var existingButton = pageEl.querySelector('.bookmark-button');
+      if (existingButton) {
+        existingButton.remove();
+      }
+      var pageID = +pageEl.classList.value.match(/pagediv\d+/)[0].replace(/\D/g, '');
+      var pageBookmark = this.getBookmark(pageID);
+      var bookmarkState = pageBookmark ? 'filled' : 'hollow';
+      // eslint-disable-next-line
+      var pageData = this.bookreader.book.getPage(pageID);
+      var {
+        isViewable
+      } = pageData;
+      if (!isViewable) {
+        return;
+      }
+      var bookmarkButton = document.createElement('div');
+      ['mousedown', 'mouseup'].forEach(event => {
+        bookmarkButton.addEventListener(event, e => e.stopPropagation());
+      });
+      bookmarkButton.classList.add('bookmark-button', bookmarkState);
+      if (pageBookmark) {
+        bookmarkButton.classList.add(this.getBookmarkColor(pageBookmark.color));
+      }
+      var pageSide = pageEl.getAttribute('data-side') === 'L' && this.bookreader.mode === this.bookreader.constMode2up ? 'left' : 'right';
+      render(html(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n        <bookmark-button\n          @bookmarkButtonClicked=", "\n          state=", "\n          side=", "\n        ></bookmark-button>"])), () => this.bookmarkButtonClicked(pageID), bookmarkState, pageSide), bookmarkButton);
+      pageEl.appendChild(bookmarkButton);
+    });
+  }
+
+  /**
+   * Notes which bookmark is active
+   *
+   * @param {boolean} atSetup - denotes the first time this is fired
+   */
+  markActiveBookmark() {
+    var atSetup = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    var {
+      mode,
+      constMode2up,
+      constModeThumb
+    } = this.bookreader;
+    var currentIndex = this.bookreader.currentIndex();
+    if (mode === constModeThumb) {
+      // keep active bookmark the same
+      // no syncing until we can verify when a bookmark is "in view"
+      var requestedPageHasBookmark = this.bookmarks[currentIndex];
+      if (atSetup && requestedPageHasBookmark) {
+        this.activeBookmarkID = currentIndex;
+      }
+      return;
+    }
+    // In 2up, we prefer the right side of the page to bookmark
+    // so let's make sure we light that one up.
+    if (mode === constMode2up) {
+      var pagesInView = this.bookreader.displayedIndices;
+      var pagesHaveActiveBookmark = pagesInView.includes(+this.activeBookmarkID);
+      if (pagesHaveActiveBookmark) {
+        return;
+      }
+    }
+
+    // If a bookmark exists with the current index, set it as active
+    if (this.bookmarks[currentIndex]) {
+      this.activeBookmarkID = currentIndex;
+      return;
+    }
+
+    // No bookmark for this page
+    this.activeBookmarkID = '';
+  }
+  bookmarkEdited(_ref2) {
+    var {
+      detail
+    } = _ref2;
+    var closeEdit = detail.bookmark.id === this.editedBookmark.id;
+    this.editedBookmark = closeEdit ? {} : detail.bookmark;
+  }
+
+  /**
+   * Gets bookmark by pageindex
+   * @param {number} id
+   */
+  getBookmark(id) {
+    return this.bookmarks[id];
+  }
+  getBookmarkColor(id) {
+    var _this$bookmarkColors$;
+    return (_this$bookmarkColors$ = this.bookmarkColors.find(m => m.id === id)) === null || _this$bookmarkColors$ === void 0 ? void 0 : _this$bookmarkColors$.className;
+  }
+
+  /**
+   * Adds bookmark for current page
+   */
+  addBookmark() {
+    var pageID = this.bookreader.currentIndex();
+    if (this.bookreader.mode === this.bookreader.constMode2up) {
+      var pagesInView = this.bookreader.displayedIndices;
+
+      // add bookmark to right hand page
+      pageID = pagesInView[pagesInView.length - 1];
+    }
+    this.createBookmark(pageID);
+  }
+
+  /**
+   * Creates bookmark for a given page
+   * @param {number} pageID
+   */
+  createBookmark(pageID) {
+    var existingBookmark = this.getBookmark(pageID);
+    if (existingBookmark) {
+      this.bookmarkEdited({
+        detail: {
+          bookmark: existingBookmark
+        }
+      });
+      this.emitBookmarkButtonClicked();
+      return;
+    }
+    this.editedBookmark = this.formatBookmark({
+      leafNum: pageID
+    });
+    this.api.post(this.editedBookmark);
+    this.bookmarks[pageID] = this.editedBookmark;
+    this.activeBookmarkID = pageID;
+    this.disableAddBookmarkButton = true;
+    this.renderBookmarkButtons();
+    this.emitBookmarkButtonClicked();
+  }
+  bookmarkSelected(_ref3) {
+    var {
+      detail
+    } = _ref3;
+    var {
+      leafNum
+    } = detail.bookmark;
+    this.bookreader.jumpToPage("".concat(this.bookreader.book.getPageNum("".concat(leafNum).replace(/\D/g, ''))));
+    this.activeBookmarkID = leafNum;
+  }
+  saveBookmark(_ref4) {
+    var {
+      detail
+    } = _ref4;
+    var existingBookmark = this.bookmarks[detail.bookmark.id];
+    Object.assign(existingBookmark, detail.bookmark);
+    this.api.put(existingBookmark);
+    this.editedBookmark = {};
+    this.renderBookmarkButtons();
+  }
+  confirmDeletion(pageID) {
+    var existingBookmark = this.getBookmark(pageID);
+    if (existingBookmark.note) {
+      this.displayDeletionModal(pageID);
+      return;
+    }
+    this.deleteBookmark({
+      detail: {
+        id: "".concat(pageID)
+      }
+    });
+  }
+  displayDeletionModal(pageID) {
+    var customModalContent = html(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n      <delete-modal-actions\n        .deleteAction=", "\n        .cancelAction=", "\n        .pageID=", "\n      ></delete-modal-actions>\n    "])), () => this.deleteBookmark({
+      detail: {
+        id: "".concat(pageID)
+      }
+    }), () => this.modal.closeModal(), pageID);
+    this.modal.showModal({
+      config: this.deleteModalConfig,
+      customModalContent
+    });
+  }
+  deleteBookmark(_ref5) {
+    var {
+      detail
+    } = _ref5;
+    var {
+      id
+    } = detail;
+    var currBookmarks = this.bookmarks;
+    delete currBookmarks[id];
+    this.bookmarks = _objectSpread({}, currBookmarks);
+    this.api.delete(detail.id);
+    this.editedBookmark = {};
+    this.modal.closeModal();
+    this.renderBookmarkButtons();
+  }
+
+  /**
+   * Tells us if we should allow user to add bookmark via menu panel
+   * returns { Boolean }
+   */
+  get shouldEnableAddBookmarkButton() {
+    var pageToCheck = this.bookreader.mode === this.bookreader.constMode2up ? this.bookreader.displayedIndices[this.bookreader.displayedIndices.length - 1] : this.bookreader.currentIndex();
+    var pageHasBookmark = this.getBookmark(pageToCheck);
+    return !!pageHasBookmark;
+  }
+  get allowAddingBookmark() {
+    return this.bookreader.mode !== this.bookreader.constModeThumb;
+  }
+  get addBookmarkButton() {
+    return html(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n      <button\n        class=\"ia-button primary\"\n        tabindex=\"-1\"\n        ?disabled=", "\n        @click=", ">\n        Add bookmark\n      </button>\n    "])), this.shouldEnableAddBookmarkButton, this.addBookmark);
+  }
+  get bookmarksList() {
+    return html(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n      <ia-bookmarks-list\n        @bookmarkEdited=", "\n        @bookmarkSelected=", "\n        @saveBookmark=", "\n        @deleteBookmark=", "\n        .editedBookmark=", "\n        .bookmarks=", "\n        .activeBookmarkID=", "\n        .bookmarkColors=", "\n        .defaultBookmarkColor=", ">\n      </ia-bookmarks-list>\n    "])), this.bookmarkEdited, this.bookmarkSelected, this.saveBookmark, this.deleteBookmark, this.editedBookmark, _objectSpread({}, this.bookmarks), this.activeBookmarkID, this.bookmarkColors, this.defaultColor);
+  }
+  get bookmarkHelperMessage() {
+    return html(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["<p>Please use 1up or 2up view modes to add bookmark.</p>"])));
+  }
+  render() {
+    var bookmarks = html(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["\n      ", "\n      ", "\n    "])), this.bookmarksList, this.allowAddingBookmark ? this.addBookmarkButton : this.bookmarkHelperMessage);
+    return html(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["\n      <section class=\"bookmarks\">\n      ", "\n      </section>\n    "])), this.displayMode === 'login' ? html(_templateObject9 || (_templateObject9 = _taggedTemplateLiteral(["<bookmarks-login\n        @click=", "\n        .url=", "></bookmarks-login>"])), () => this.loginOptions.loginClicked(), this.loginOptions.loginUrl) : bookmarks);
+  }
+}
+customElements.define('ia-bookmarks', IABookmarks);

package/dist/esm/BookNavigator/delete-modal-actions.js

@@ -0,0 +1,29 @@
+var _templateObject, _templateObject2;
+function _taggedTemplateLiteral(e, t) { return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, { raw: { value: Object.freeze(t) } })); }
+import { LitElement, html, css } from 'lit';
+export default class DeleteModalActions extends LitElement {
+  static get styles() {
+    return css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n      div {\n        display: flex;\n        justify-content: center;\n        padding-top: 2rem;\n      }\n\n      button {\n        appearance: none;\n        padding: 0.5rem 1rem;\n        margin: 0 .5rem;\n        box-sizing: border-box;\n        font: 1.3rem \"Helvetica Neue\", Helvetica, Arial, sans-serif;\n        color: var(--primaryTextColor);\n        border: none;\n        border-radius: 4px;\n        cursor: pointer;\n        background: var(--primaryCTAFill);\n      }\n\n      .delete {\n        background: var(--primaryErrorCTAFill);\n      }\n    "])));
+  }
+  static get properties() {
+    return {
+      cancelAction: {
+        type: Function
+      },
+      deleteAction: {
+        type: Function
+      },
+      pageID: {
+        type: String
+      }
+    };
+  }
+  render() {
+    return html(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n      <div>\n        <button class=\"delete\" @click=", ">Delete</button>\n        <button @click=", ">Cancel</button>\n      </div>\n    "])), () => this.deleteAction({
+      detail: {
+        id: "".concat(this.pageID)
+      }
+    }), () => this.cancelAction());
+  }
+}
+customElements.define('delete-modal-actions', DeleteModalActions);

package/dist/esm/BookNavigator/downloads/downloads-provider.js

@@ -0,0 +1,84 @@
+var _templateObject, _templateObject2;
+function _taggedTemplateLiteral(e, t) { return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, { raw: { value: Object.freeze(t) } })); }
+import { html } from 'lit';
+import '@internetarchive/icon-dl/icon-dl';
+import './downloads';
+var menuBase = {
+  pdf: {
+    type: 'Encrypted Adobe PDF',
+    url: '#',
+    note: 'PDF files contain high quality images of pages.'
+  },
+  lcppdf: {
+    type: 'Get LCP PDF',
+    url: '#',
+    note: 'PDF files contain high quality images of pages.'
+  },
+  lcpepub: {
+    type: 'Get LCP ePub',
+    url: '#',
+    note: 'ePub files are smaller in size, but may contain errors.'
+  },
+  epub: {
+    type: 'Encrypted Adobe ePub',
+    url: '#',
+    note: 'ePub files are smaller in size, but may contain errors.'
+  }
+};
+var publicMenuBase = {
+  pdf: "PDF",
+  epub: "ePub",
+  lcppdf: "LCP PDF",
+  lcpepub: "LCP ePub"
+};
+export default class DownloadsProvider {
+  constructor(_ref) {
+    var _bookreader$options;
+    var {
+      bookreader
+    } = _ref;
+    this.icon = html(_templateObject || (_templateObject = _taggedTemplateLiteral(["<ia-icon-dl style=\"width: var(--iconWidth); height: var(--iconHeight);\"></ia-icon-dl>"])));
+    this.label = 'Downloadable files';
+    this.menuDetails = '';
+    this.downloads = [];
+    this.id = 'downloads';
+    this.component = '';
+    this.isBookProtected = (bookreader === null || bookreader === void 0 || (_bookreader$options = bookreader.options) === null || _bookreader$options === void 0 ? void 0 : _bookreader$options.isProtected) || false;
+  }
+  update(downloadTypes) {
+    this.computeAvailableTypes(downloadTypes);
+    this.component = this.menu;
+    this.component.isBookProtected = this.isBookProtected;
+    var ending = this.downloads.length === 1 ? '' : 's';
+    this.menuDetails = "(".concat(this.downloads.length, " format").concat(ending, ")");
+  }
+
+  /**
+   * Generates Download Menu Info for available types
+   * sets global `downloads`
+   * @param  availableTypes
+   */
+  computeAvailableTypes() {
+    var _this = this;
+    var availableTypes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    var menuData = availableTypes.reduce(function (found) {
+      var incoming = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+      var [type = '', link = ''] = incoming;
+      var formattedType = type.toLowerCase();
+      var downloadOption = menuBase[formattedType] || null;
+      if (downloadOption) {
+        var menuButtonText = _this.isBookProtected ? menuBase[formattedType].type : publicMenuBase[formattedType];
+        var menuInfo = Object.assign({}, downloadOption, {
+          url: link,
+          type: menuButtonText
+        });
+        found.push(menuInfo);
+      }
+      return found;
+    }, []);
+    this.downloads = menuData;
+  }
+  get menu() {
+    return html(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["<ia-book-downloads .downloads=", "></ia-book-downloads>"])), this.downloads);
+  }
+}