@internetarchive/bookreader 5.0.0-4 → 5.0.0-40-a1

package/tests/karma/BookNavigator/downloads/downloads-provider.test.js

@@ -0,0 +1,67 @@
+import { expect, fixtureCleanup, fixtureSync } from '@open-wc/testing';
+import sinon from 'sinon';
+import DownloadsProvider from '../../../../src/BookNavigator/downloads/downloads-provider';
+
+const downloadableTypes = [
+  ["PDF", "//archive.org/download/theworksofplato01platiala/theworksofplato01platiala.pdf"],
+  ["ePub", "//archive.org/download/theworksofplato01platiala/theworksofplato01platiala.epub"],
+  ["Plain Text", "//archive.org/download/theworksofplato01platiala/theworksofplato01platiala_djvu.txt"],
+  ["DAISY", "//archive.org/download/theworksofplato01platiala/theworksofplato01platiala_daisy.zip"],
+  ["Kindle", "//archive.org/download/theworksofplato01platiala/theworksofplato01platiala.mobi"]
+];
+
+const downloads = [
+  {
+    type: "PDF",
+    url: "//archive.org/download/theworksofplato01platiala/theworksofplato01platiala.pdf",
+    note: "PDF files contain high quality images of pages."
+  },
+  {
+    type: "ePub",
+    url: "//archive.org/download/theworksofplato01platiala/theworksofplato01platiala.epub",
+    note: "ePub files are smaller in size, but may contain errors."
+  }
+];
+
+afterEach(() => {
+  sinon.restore();
+  fixtureCleanup();
+});
+
+describe('Downloads Provider', () => {
+  it('constructor - initial setup', () => {
+    const isBookProtected = false;
+    const provider = new DownloadsProvider(isBookProtected);
+
+    expect(provider.id).to.equal('downloads');
+    expect(provider.icon).to.exist;
+    expect(fixtureSync(provider.icon).tagName).to.equal('IA-ICON-DL');
+    expect(provider.label).to.equal('Downloadable files');
+    expect(provider.menuDetails).to.exist;
+    expect(provider.component).to.exist;
+
+    provider.update(downloadableTypes);
+
+    expect(provider.isBookProtected).to.equal(false);
+
+    expect(provider.downloads[0].type).to.equals("PDF");
+    expect(provider.downloads[1].type).to.equals("ePub");
+
+    expect(provider.menuDetails).to.equal(`(${downloads.length} formats)`);
+  });
+
+  it('render view if book is protected', () => {
+    const provider = new DownloadsProvider({
+      bookreader: { options: { isProtected: true } }
+    });
+
+    expect(provider.isBookProtected).to.equal(true);
+
+    provider.update(downloadableTypes);
+
+    expect(provider.downloads[0].type).to.equals("Encrypted Adobe PDF");
+    expect(provider.downloads[1].type).to.equals("Encrypted Adobe ePub");
+
+    expect(provider.downloads.length).to.equals(downloads.length);
+  });
+});

package/tests/karma/BookNavigator/downloads/downloads.test.js

@@ -0,0 +1,54 @@
+import {
+  html,
+  fixture,
+  expect,
+  fixtureCleanup,
+} from '@open-wc/testing';
+import sinon from 'sinon';
+import '../../../../src/BookNavigator/downloads/downloads';
+
+
+const downloads = [
+  {
+    type: "PDF",
+    url: "//archive.org/download/theworksofplato01platiala/theworksofplato01platiala.pdf",
+    note: "PDF files contain high quality images of pages."
+  },
+  {
+    type: "ePub",
+    url: "//archive.org/download/theworksofplato01platiala/theworksofplato01platiala.epub",
+    note: "ePub files are smaller in size, but may contain errors."
+  }
+];
+
+
+const container = (downloads) => (
+  html`
+    <ia-book-downloads .downloads=${downloads}></ia-book-downloads>
+  `
+);
+
+beforeEach(() => {
+  const body = document.querySelector('body');
+  const brHook = document.createElement('div');
+  brHook.setAttribute('id', 'BookReader');
+  body.appendChild(brHook);
+});
+
+afterEach(() => {
+  sinon.restore();
+  fixtureCleanup();
+});
+
+describe('<ia-book-downloads>', () => {
+  it('sets default properties', async () => {
+    const el = await fixture(container(downloads));
+    await el.updateComplete;
+
+    expect(el.downloads.length).to.equal(2);
+    expect(el.shadowRoot.querySelector("ul").childElementCount).to.equal(2);
+    expect(el.isBookProtected).to.equal(false);
+
+    expect(el.shadowRoot.querySelector("ul li a").textContent).to.include("Get PDF");
+  });
+});

package/tests/karma/BookNavigator/search/search-provider.test.js

@@ -0,0 +1,123 @@
+import { expect, fixtureCleanup, fixtureSync } from '@open-wc/testing';
+import sinon from 'sinon';
+import searchProvider from '../../../../src/BookNavigator/search/search-provider';
+
+afterEach(() => {
+  sinon.restore();
+  fixtureCleanup();
+});
+
+describe('Search Provider', () => {
+  describe('constructor', () => {
+    const provider = new searchProvider({
+      onProviderChange: sinon.fake(),
+      bookreader: {}
+    });
+
+    expect(provider.bookreader).to.exist;
+    expect(provider.onProviderChange).to.exist;
+    expect(provider.id).to.equal('search');
+    expect(provider.icon).to.exist;
+    expect(fixtureSync(provider.icon).tagName).to.equal('IA-ICON-SEARCH');
+    expect(provider.label).to.equal('Search inside');
+    expect(provider.menuDetails).to.exist;
+    expect(provider.component).to.exist;
+  });
+  describe('BR calls', () => {
+    it('`advanceToPage', () => {
+      const provider = new searchProvider({
+        onProviderChange: sinon.fake(),
+        bookreader: {
+          leafNumToIndex: sinon.fake(),
+          _searchPluginGoToResult: sinon.fake()
+        }
+      });
+
+      provider.advanceToPage(1);
+      expect(provider?.bookreader.leafNumToIndex.callCount).to.equal(1);
+      expect(provider?.bookreader._searchPluginGoToResult.callCount).to.equal(1);
+    });
+  });
+  describe('Search request life cycles', () => {
+    it('Event: catches `BookReader:SearchStarted`', async() => {
+      const provider = new searchProvider({
+        onProviderChange: sinon.fake(),
+        bookreader: {}
+      });
+      sinon.spy(provider, 'updateMenu');
+      window.dispatchEvent(new CustomEvent('BookReader:SearchStarted', { detail: { props: { term: 'foo' }}}));
+      expect(provider.updateMenu.callCount).to.equal(1);
+    });
+    it('Event: catches `BookReader:SearchCallback`', async() => {
+      const provider = new searchProvider({
+        onProviderChange: sinon.fake(),
+        bookreader: {}
+      });
+      sinon.spy(provider, 'updateMenu');
+      const brStub = {};
+      window.dispatchEvent(new CustomEvent('BookReader:SearchCallback', { detail: { props: { instance: brStub, results: { matches: []} }}}));
+      expect(provider.updateMenu.callCount).to.equal(1);
+      expect(provider.bookreader).to.equal(brStub);
+    });
+    it('Event: catches `BookReader:SearchCallbackEmpty`', async() => {
+      const provider = new searchProvider({
+        onProviderChange: sinon.fake(),
+        bookreader: {}
+      });
+      sinon.spy(provider, 'onSearchRequestError');
+      sinon.spy(provider, 'updateMenu');
+      const brStub = {};
+      window.dispatchEvent(new CustomEvent('BookReader:SearchCallbackEmpty', { detail: { props: { instance: brStub }}}));
+      expect(provider.onSearchRequestError.getCall(0).args[1]).to.equal('noResults');
+      expect(provider.updateMenu.callCount).to.equal(1);
+      expect(provider.bookreader).to.equal(brStub);
+    });
+    it('Event: catches `BookReader:SearchCallbackNotIndexed`', async() => {
+      const provider = new searchProvider({
+        onProviderChange: sinon.fake(),
+        bookreader: {}
+      });
+      const brStub = {};
+      sinon.spy(provider, 'onSearchRequestError');
+      sinon.spy(provider, 'updateMenu');
+      window.dispatchEvent(new CustomEvent('BookReader:SearchCallbackNotIndexed', { detail: { props: { instance: brStub }}}));
+      expect(provider.onSearchRequestError.getCall(0).args[1]).to.equal('notIndexed');
+      expect(provider.updateMenu.callCount).to.equal(1);
+      expect(provider.bookreader).to.equal(brStub);
+    });
+    it('Event: catches `BookReader:SearchCallbackError`', async() => {
+      const provider = new searchProvider({
+        onProviderChange: sinon.fake(),
+        bookreader: {}
+      });
+      sinon.spy(provider, 'onSearchRequestError');
+      sinon.spy(provider, 'updateMenu');
+      const brStub = {};
+      window.dispatchEvent(new CustomEvent('BookReader:SearchCallbackError', { detail: { props: { instance: brStub }}}));
+      expect(provider.onSearchRequestError.getCall(0).args[1]).to.equal(undefined);
+      expect(provider.updateMenu.callCount).to.equal(1);
+      expect(provider.bookreader).to.equal(brStub);
+    });
+    it('Event: catches `component@resultSelected` - user clicks result in side panel - & turns page', async() => {
+      const provider = new searchProvider({
+        onProviderChange: sinon.fake(),
+        bookreader: {
+          leafNumToIndex: sinon.fake(),
+          _searchPluginGoToResult: sinon.fake()
+        }
+      });
+      sinon.spy(provider, 'advanceToPage');
+
+      const searchResultStub = {
+        match: { par: [{ text: 'foo', page: 3 }] },
+      };
+      fixtureSync(provider.component).dispatchEvent(
+        new CustomEvent('resultSelected',
+          { detail: searchResultStub })
+      );
+
+      expect(provider.advanceToPage.callCount).to.equal(1);
+      expect(provider.bookreader._searchPluginGoToResult.callCount).to.equal(1);
+    });
+  });
+});

package/tests/karma/BookNavigator/{search-results.test.js → search/search-results.test.js}

@@ -5,15 +5,12 @@ import {
   oneEvent,
 } from '@open-wc/testing';
 import sinon from 'sinon';
-import { IABookSearchResults } from '../../../src/BookNavigator/search/search-results.js';
-customElements.define('ia-book-search-results', IABookSearchResults);
+import { IABookSearchResults } from '../../../../src/BookNavigator/search/search-results.js';
 
 const container = (results = [], query = '') => (
   html`<ia-book-search-results .results=${results} .query=${query}></ia-book-search-results>`
 );
 
-console.log("ia-book-search-results-test")
-
 const searchQuery = 'Bristol';
 
 const results = [{

package/tests/karma/BookNavigator/sharing/sharing-provider.test.js

@@ -0,0 +1,49 @@
+import { expect, fixtureSync } from '@open-wc/testing';
+import sinon from 'sinon';
+import SharingProvider from '../../../../src/BookNavigator/sharing.js';
+
+afterEach(() => {
+  sinon.restore();
+});
+
+const item = {
+  metadata: {
+    identifier: 'stubby-id',
+    creator: 'mr. big',
+    title: 'Stubby title',
+  }
+};
+
+const baseHost = 'foo.org';
+const subPrefix = 'beep-boop_12 4 5';
+
+describe('Sharing Provider', () => {
+  describe('constructor', () => {
+    const provider = new SharingProvider({
+      item,
+      baseHost,
+      bookreader: {
+        options: { subPrefix }
+      }
+    });
+
+    expect(provider.id).to.equal('share');
+    expect(provider.icon).to.exist;
+    expect(provider.label).to.equal('Share this book');
+    expect(fixtureSync(provider.component).tagName).to.contains('IA-SHARING-OPTIONS');
+  });
+
+  describe('Handles being a sub file/volume', () => {
+    it('encodes the subprefix if it has one', async () => {
+      const provider = new SharingProvider({
+        item,
+        baseHost,
+        bookreader: {
+          options: { subPrefix }
+        }
+      });
+
+      expect(fixtureSync(provider.component).fileSubPrefix).to.equal(subPrefix);
+    });
+  });
+});

package/tests/karma/BookNavigator/visual-adjustments.test.js

@@ -7,8 +7,6 @@ import {
 import sinon from 'sinon';
 import { IABookVisualAdjustments } from '../../../src/BookNavigator/visual-adjustments/visual-adjustments.js';
 
-customElements.define('ia-book-visual-adjustments', IABookVisualAdjustments);
-
 const options = [{
   id: 'contrast',
   name: 'Adjust contrast',

package/tests/karma/BookNavigator/volumes/volumes-provider.test.js

@@ -0,0 +1,184 @@
+import { expect, fixture, fixtureCleanup, fixtureSync } from '@open-wc/testing';
+import sinon from 'sinon';
+import volumesProvider from '../../../../src/BookNavigator/volumes/volumes-provider';
+
+const brOptions = {
+  "options": {
+    "enableMultipleBooks": true,
+    "multipleBooksList": {
+      "by_subprefix": {
+        "/details/SubBookTest": {
+          "url_path": "/details/SubBookTest",
+          "file_subprefix": "book1/GPORFP",
+          "orig_sort": 1,
+          "title": "book1/GPORFP.pdf",
+          "file_source": "/book1/GPORFP_jp2.zip"
+        },
+        "/details/SubBookTest/subdir/book2/brewster_kahle_internet_archive": {
+          "url_path": "/details/SubBookTest/subdir/book2/brewster_kahle_internet_archive",
+          "file_subprefix": "subdir/book2/brewster_kahle_internet_archive",
+          "orig_sort": 2,
+          "title": "subdir/book2/brewster_kahle_internet_archive.pdf",
+          "file_source": "/subdir/book2/brewster_kahle_internet_archive_jp2.zip"
+        },
+        "/details/SubBookTest/subdir/subsubdir/book3/Rfp008011ResponseInternetArchive-without-resume": {
+          "url_path": "/details/SubBookTest/subdir/subsubdir/book3/Rfp008011ResponseInternetArchive-without-resume",
+          "file_subprefix": "subdir/subsubdir/book3/Rfp008011ResponseInternetArchive-without-resume",
+          "orig_sort": 3,
+          "title": "subdir/subsubdir/book3/Rfp008011ResponseInternetArchive-without-resume.pdf",
+          "file_source": "/subdir/subsubdir/book3/Rfp008011ResponseInternetArchive-without-resume_jp2.zip"
+        }
+      }
+    }
+  }
+};
+
+afterEach(() => {
+  sinon.restore();
+  fixtureCleanup();
+});
+
+describe('Volumes Provider', () => {
+  it('constructor', () => {
+    const onProviderChange = sinon.fake();
+    const baseHost = "https://archive.org";
+    const provider = new volumesProvider({
+      baseHost,
+      bookreader: brOptions,
+      onProviderChange
+    });
+
+    const files = brOptions.options.multipleBooksList.by_subprefix;
+    const volumeCount = Object.keys(files).length;
+
+    expect(provider.onProviderChange).to.equal(onProviderChange);
+    expect(provider.id).to.equal('volumes');
+    expect(provider.icon).to.exist;
+    expect(fixtureSync(provider.icon).tagName).to.equal('svg');
+    expect(provider.label).to.equal(`Viewable files (${volumeCount})`);
+    expect(provider.viewableFiles).to.exist;
+    expect(provider.viewableFiles.length).to.equal(3);
+
+    expect(provider.component.hostUrl).to.exist;
+    expect(provider.component.hostUrl).to.equal(baseHost);
+    expect(provider.component).to.exist;
+  });
+
+  it('sorting cycles - render sort actionButton', async () => {
+    const onProviderChange = sinon.fake();
+    const baseHost = "https://archive.org";
+    const provider = new volumesProvider({
+      baseHost,
+      bookreader: brOptions,
+      onProviderChange
+    });
+
+    expect(provider.sortOrderBy).to.equal("default");
+
+    provider.sortVolumes("title_asc");
+    expect(provider.sortOrderBy).to.equal("title_asc");
+    expect(fixtureSync(provider.sortButton).outerHTML).includes("sort-by asc-icon");
+
+    provider.sortVolumes("title_desc");
+    expect(provider.sortOrderBy).to.equal("title_desc");
+    expect(fixtureSync(provider.sortButton).outerHTML).includes("sort-by desc-icon");
+
+    provider.sortVolumes("default");
+    expect(provider.sortOrderBy).to.equal("default");
+    expect(fixtureSync(provider.sortButton).outerHTML).includes("sort-by neutral-icon");
+  });
+
+  it('sort volumes in initial order', async () => {
+    const onProviderChange = sinon.fake();
+    const baseHost = "https://archive.org";
+    const provider = new volumesProvider({
+      baseHost,
+      bookreader: brOptions,
+      onProviderChange
+    });
+
+    const parsedFiles = brOptions.options.multipleBooksList.by_subprefix;
+    const files = Object.keys(parsedFiles).map(item => parsedFiles[item]).sort((a, b) => a.orig_sort - b.orig_sort);
+    const origSortTitles = files.map(item => item.title);
+
+    provider.sortVolumes("default");
+
+    expect(provider.sortOrderBy).to.equal("default");
+    expect(provider.actionButton).to.exist;
+
+    const providerFileTitles = provider.viewableFiles.map(item => item.title);
+    // use `.eql` for "lose equality" in order to deeply compare values.
+    expect(providerFileTitles).to.eql([...origSortTitles]);
+  });
+
+  it('sort volumes in ascending title order', async () => {
+    const onProviderChange = sinon.fake();
+    const baseHost = "https://archive.org";
+    const provider = new volumesProvider({
+      baseHost,
+      bookreader: brOptions,
+      onProviderChange
+    });
+
+    const parsedFiles = brOptions.options.multipleBooksList.by_subprefix;
+    const files = Object.keys(parsedFiles).map(item => parsedFiles[item]);
+    const ascendingTitles = files.map(item => item.title).sort((a, b) => a.localeCompare(b));
+
+    provider.sortVolumes("title_asc");
+
+    expect(provider.sortOrderBy).to.equal("title_asc");
+    expect(provider.actionButton).to.exist;
+
+    const providerFileTitles = provider.viewableFiles.map(item => item.title);
+    // use `.eql` for "lose equality" in order to deeply compare values.
+    expect(providerFileTitles).to.eql([...ascendingTitles]);
+  });
+
+  it('sort volumes in descending title order', async () => {
+    const onProviderChange = sinon.fake();
+    const baseHost = "https://archive.org";
+    const provider = new volumesProvider({
+      baseHost,
+      bookreader: brOptions,
+      onProviderChange
+    });
+    provider.isSortAscending = false;
+
+    const parsedFiles = brOptions.options.multipleBooksList.by_subprefix;
+    const files = Object.keys(parsedFiles).map(item => parsedFiles[item]);
+    const descendingTitles = files.map(item => item.title).sort((a, b) => b.localeCompare(a));
+
+    provider.sortVolumes("title_desc");
+
+    expect(provider.sortOrderBy).to.equals("title_desc");
+    expect(provider.actionButton).to.exist;
+
+    const providerFileTitles = provider.viewableFiles.map(item => item.title);
+    // use `.eql` for "lose equality" in order to deeply compare values.
+    expect(providerFileTitles).to.eql([...descendingTitles]);
+  });
+
+  describe('Sorting icons', () => {
+    it('has 3 icons', async () => {
+      const onProviderChange = sinon.fake();
+      const baseHost = "https://archive.org";
+      const provider = new volumesProvider({
+        baseHost,
+        bookreader: brOptions,
+        onProviderChange
+      });
+      provider.sortOrderBy = 'default';
+
+      const origSortButton = await fixture(provider.sortButton);
+      expect(origSortButton.classList.contains('neutral-icon')).to.be.true;
+
+      provider.sortOrderBy = 'title_asc';
+      const ascButton = await fixture(provider.sortButton);
+      expect(ascButton.classList.contains('asc-icon')).to.be.true;
+
+      provider.sortOrderBy = 'title_desc';
+      const descButton = await fixture(provider.sortButton);
+      expect(descButton.classList.contains('desc-icon')).to.be.true;
+    });
+  });
+});

package/tests/karma/BookNavigator/volumes/volumes.test.js

@@ -0,0 +1,98 @@
+import {
+  html,
+  fixture,
+  expect,
+  fixtureCleanup,
+} from '@open-wc/testing';
+import sinon from 'sinon';
+import '../../../../src/BookNavigator/volumes/volumes.js';
+
+
+const brOptions = {
+  "options": {
+    "enableMultipleBooks": true,
+    "multipleBooksList": {
+      "by_subprefix": {
+        "/details/SubBookTest": {
+          "url_path": "/details/SubBookTest",
+          "file_subprefix": "book1/GPORFP",
+          "orig_sort": 0,
+          "title": "book1/GPORFP.pdf",
+          "file_source": "/book1/GPORFP_jp2.zip"
+        },
+        "/details/SubBookTest/subdir/book2/brewster_kahle_internet_archive": {
+          "url_path": "/details/SubBookTest/subdir/book2/brewster_kahle_internet_archive",
+          "file_subprefix": "subdir/book2/brewster_kahle_internet_archive",
+          "orig_sort": 1,
+          "title": "subdir/book2/brewster_kahle_internet_archive.pdf",
+          "file_source": "/subdir/book2/brewster_kahle_internet_archive_jp2.zip"
+        },
+        "/details/SubBookTest/subdir/subsubdir/book3/Rfp008011ResponseInternetArchive-without-resume": {
+          "url_path": "/details/SubBookTest/subdir/subsubdir/book3/Rfp008011ResponseInternetArchive-without-resume",
+          "file_subprefix": "subdir/subsubdir/book3/Rfp008011ResponseInternetArchive-without-resume",
+          "orig_sort": 2,
+          "title": "subdir/subsubdir/book3/Rfp008011ResponseInternetArchive-without-resume.pdf",
+          "file_source": "/subdir/subsubdir/book3/Rfp008011ResponseInternetArchive-without-resume_jp2.zip"
+        }
+      }
+    }
+  }
+};
+
+const container = (brOptions, prefix) => (
+  html`
+    <viewable-files .viewableFiles=${brOptions} .hostUrl="https://archive.org" .subPrefix=${prefix}></viewable-files>
+  `
+);
+
+beforeEach(() => {
+  const body = document.querySelector('body');
+  const brHook = document.createElement('div');
+  brHook.setAttribute('id', 'BookReader');
+  body.appendChild(brHook);
+});
+
+afterEach(() => {
+  sinon.restore();
+  fixtureCleanup();
+});
+
+describe('<viewable-files>', () => {
+  it('sets default properties', async () => {
+    const files = brOptions.options.multipleBooksList?.by_subprefix;
+    const viewableFiles = Object.keys(files).map(item => files[item]);
+    const el = await fixture(container(viewableFiles));
+    await el.updateComplete;
+
+    expect(el.viewableFiles).to.equal(viewableFiles);
+    expect(el.viewableFiles.length).to.equal(3);
+    expect(el.shadowRoot.querySelectorAll("ul li").length).to.equal(3);
+
+    expect(el.shadowRoot.querySelector(".item-title").innerText).to.include(`${viewableFiles[0].title}`);
+  });
+
+  it('render empty volumes', async () => {
+    const viewableFiles = [];
+    const el = await fixture(container(viewableFiles));
+    await el.updateComplete;
+
+    expect(el.viewableFiles).to.equal(viewableFiles);
+    expect(el.viewableFiles.length).to.equal(0);
+    expect(el.shadowRoot.childElementCount).to.equal(0);
+  });
+
+  it('render active volume item set as first viewable item ', async () => {
+    const files = brOptions.options.multipleBooksList?.by_subprefix;
+    const viewableFiles = Object.keys(files).map(item => files[item]);
+    const prefix = viewableFiles[0].file_subprefix;
+
+    const el = await fixture(container(viewableFiles, prefix));
+    await el.updateComplete;
+
+    expect(el.viewableFiles).to.equal(viewableFiles);
+    expect(el.viewableFiles.length).to.equal(3);
+
+    expect(el.shadowRoot.querySelectorAll("ul li div")[1].className).to.equal("content active");
+  });
+
+});

package/webpack.config.js

@@ -14,7 +14,11 @@ const shared = {
 
   module: {
     rules: [
-      { test: /\.js$/, exclude: /node_modules/, loader: "babel-loader" }
+      {
+        test: /\.js$/,
+        exclude: /node_modules[/\\](?!(lit-element|lit-html|lit|@lit)[/\\]).*/,
+        loader: "babel-loader",
+      }
     ]
   },
 
@@ -31,6 +35,9 @@ module.exports = [
 
     // Output file -> srcfile
     entry: {
+      // Polyfill bundles
+      'webcomponents-bundle.js': { import: '@webcomponents/webcomponentsjs/webcomponents-bundle.js' },
+
       // BookReader
       'BookReader.js': './src/BookReader.js',
 
@@ -39,15 +46,14 @@ module.exports = [
       'plugins/plugin.autoplay.js': { import: './src/plugins/plugin.autoplay.js', dependOn: 'BookReader.js' },
       'plugins/plugin.chapters.js': { import: './src/plugins/plugin.chapters.js', dependOn: 'BookReader.js' },
       'plugins/plugin.iframe.js': { import: './src/plugins/plugin.iframe.js', dependOn: 'BookReader.js' },
-      'plugins/plugin.menu_toggle.js': { import: './src/plugins/menu_toggle/plugin.menu_toggle.js', dependOn: 'BookReader.js' },
       'plugins/plugin.mobile_nav.js': { import: './src/plugins/plugin.mobile_nav.js', dependOn: 'BookReader.js' },
       'plugins/plugin.resume.js': { import: './src/plugins/plugin.resume.js', dependOn: 'BookReader.js' },
       'plugins/plugin.search.js': { import: './src/plugins/search/plugin.search.js', dependOn: 'BookReader.js' },
       'plugins/plugin.text_selection.js': { import: './src/plugins/plugin.text_selection.js', dependOn: 'BookReader.js' },
       'plugins/plugin.tts.js': { import: './src/plugins/tts/plugin.tts.js', dependOn: 'BookReader.js' },
-      'plugins/plugin.url.js': { import: './src/plugins/plugin.url.js', dependOn: 'BookReader.js' },
+      'plugins/plugin.url.js': { import: './src/plugins/url/plugin.url.js', dependOn: 'BookReader.js' },
       'plugins/plugin.vendor-fullscreen.js': { import: './src/plugins/plugin.vendor-fullscreen.js', dependOn: 'BookReader.js' },
-      'bookreader-component-bundle.js': { import: './src/BookReaderComponent/BookReaderComponent.js', dependOn: 'BookReader.js' }
+      'ia-bookreader-bundle.js': { import: './src/ia-bookreader/ia-bookreader.js', dependOn: 'BookReader.js' }
     },
 
     externals: {

package/.babelrc

@@ -1,12 +0,0 @@
-{
-    "presets": [
-        [
-            "@babel/preset-env",
-            {
-                "targets": "> 2%, ie 11, edge 14, samsung > 9, OperaMini all, UCAndroid > 12",
-                "useBuiltIns": "usage",
-                "corejs": 3
-            }
-        ]
-    ]
-}

package/.dependabot/config.yml

@@ -1,6 +0,0 @@
-version: 1
-
-update_configs:
-  - package_manager: "javascript"
-    directory: "/"
-    update_schedule: "monthly"

package/.testcaferc.json

@@ -1,5 +0,0 @@
-{
-  "appCommand": "npm run serve",
-  "browsers": ["chrome:headless", "firefox:headless"],
-  "src": ["tests/e2e/**/*test.js"]
-}