@internetarchive/bookreader 5.0.0-6-14 → 5.0.0-60

package/tests/jest/BookReader/BookReaderPublicFunctions.test.js

@@ -0,0 +1,193 @@
+import BookReader from '@/src/BookReader';
+import { sleep } from '@/src/BookReader/utils.js';
+import sinon from 'sinon';
+
+beforeAll(() => {
+  global.alert = sinon.fake();
+});
+afterEach(() => {
+  sinon.restore();
+});
+
+describe('BookReader.prototype.toggleFullscreen', ()  => {
+  test('uses `isFullscreen` to check fullscreen state', () => {
+    const isFSmock = sinon.fake();
+    // isFSmock.mockReturnValueOnce(false);
+    const br = new BookReader();
+    br.mode = br.constMode1up;
+    br.enterFullscreen = sinon.fake();
+    br.isFullscreen = isFSmock;
+
+    br.toggleFullscreen();
+    expect(br.isFullscreen.callCount).toEqual(1);
+  });
+
+  test('will always emit an event', async () => {
+    const br = new BookReader();
+    br.mode = br.constMode2up;
+    br.trigger = sinon.fake();
+    br.switchMode = sinon.fake();
+    br.updateBrClasses = sinon.fake();
+    br.jumpToIndex = sinon.fake();
+    br.refs.$brContainer = {
+      css: sinon.fake(),
+      animate: (options, speed, style, callback) => callback()
+    };
+    br.refs.$br = {
+      updateBrClasses: sinon.fake(),
+      removeClass: sinon.fake(),
+      addClass: sinon.fake(),
+      css: sinon.fake(),
+      animate: (options, speed, style, callback) => callback()
+    };
+
+    await br.toggleFullscreen();
+    expect(br.trigger.callCount).toBeGreaterThan(0);
+  });
+
+  test('will start with opening fullscreen', () => {
+    const br = new BookReader();
+    br.mode = br.constMode2up;
+    br.enterFullscreen = sinon.fake();
+
+    br.toggleFullscreen();
+    expect(br.enterFullscreen.callCount).toEqual(1);
+  });
+
+  test('will close fullscreen if BookReader is in fullscreen', () => {
+    const br = new BookReader();
+    br.mode = br.constMode1up;
+    br.exitFullScreen = sinon.fake();
+    br.isFullscreenActive = true;
+
+    br.toggleFullscreen();
+    expect(br.exitFullScreen.callCount).toEqual(1);
+  });
+});
+
+describe('BookReader.prototype.enterFullscreen', ()  => {
+  test('will bind `_fullscreenCloseHandler` by default', () => {
+    const br = new BookReader();
+    br.mode = br.constMode1up;
+    br.switchMode = sinon.fake();
+    br.updateBrClasses = sinon.fake();
+    br.refs.$br = {
+      css: sinon.fake(),
+      animate: sinon.fake(),
+      addClass: sinon.fake(),
+    };
+    expect(br._fullscreenCloseHandler).toBeUndefined();
+
+    br.enterFullscreen();
+    expect(br._fullscreenCloseHandler).toBeDefined();
+  });
+
+  test('fires certain events when called', async () => {
+    const br = new BookReader();
+    br.mode = br.constMode2up;
+    br.switchMode = sinon.fake();
+    br.updateBrClasses = sinon.fake();
+    br.trigger = sinon.fake();
+    br.resize = sinon.fake();
+    br.jumpToIndex = sinon.fake();
+    br.refs.$br = {
+      addClass: sinon.fake(),
+      removeClass: sinon.fake(),
+    };
+    br.refs.$brContainer = {
+      css: sinon.fake(),
+      animate: (options, speed, style, callback) => callback(),
+    };
+
+    await br.enterFullscreen();
+    expect(br.switchMode.callCount).toEqual(1);
+    expect(br.updateBrClasses.callCount).toEqual(1);
+    expect(br.trigger.callCount).toEqual(2); // fragmentChange, fullscreenToggled
+    expect(br.jumpToIndex.callCount).toEqual(1);
+
+    await sleep(0);
+    expect(br.resize.callCount).toEqual(1);
+  });
+});
+
+describe('BookReader.prototype.exitFullScreen', () => {
+  test('fires certain events when called', async () => {
+    const br = new BookReader();
+    br.mode = br.constMode2up;
+    br.switchMode = sinon.fake();
+    br.updateBrClasses = sinon.fake();
+    br.trigger = sinon.fake();
+    br.resize = sinon.fake();
+    br.refs.$br = {
+      addClass: sinon.fake(),
+      removeClass: sinon.fake(),
+    };
+    br.refs.$brContainer = {
+      css: sinon.fake(),
+      animate: (options, speed, style, callback) => callback()
+    };
+    await br.exitFullScreen();
+    expect(br.switchMode.callCount).toEqual(1);
+    expect(br.updateBrClasses.callCount).toEqual(1);
+    expect(br.trigger.callCount).toEqual(2); // fragmentChange, fullscreenToggled
+    expect(br.resize.callCount).toEqual(1);
+  });
+});
+
+describe('BookReader.prototype.trigger', () => {
+  test('fires custom event', () => {
+    const br = new BookReader();
+    global.br = br;
+    global.dispatchEvent = sinon.fake();
+
+    const props = {bar: 1};
+    br.trigger('foo', props);
+    expect(global.dispatchEvent.callCount).toBe(1);
+  });
+});
+
+describe('`BookReader.prototype.prev`', () => {
+  let br;
+  let flipAnimationStub;
+  beforeEach(() => {
+    br = new BookReader();
+    global.br = br;
+    br.trigger = sinon.fake();
+    br.jumpToIndex = sinon.fake();
+    flipAnimationStub = sinon.stub(br._modes.mode2Up.mode2UpLit, 'flipAnimation');
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  test('does not take action if user is on front page', () => {
+    br.firstIndex = 0;
+    br.prev();
+    expect(br.trigger.callCount).toBe(0);
+    expect(flipAnimationStub.callCount).toBe(0);
+    expect(br.jumpToIndex.callCount).toBe(0);
+  });
+
+  describe('2up mode', () => {
+    test('fires event and turns the page', () => {
+      br.firstIndex = 10;
+      br.mode = br.constMode2up;
+      br.prev();
+      expect(br.jumpToIndex.callCount).toBe(0); // <--  does not get called
+      expect(br.trigger.callCount).toBe(1);
+      expect(flipAnimationStub.callCount).toBe(1);
+    });
+  });
+
+  describe('non 2up mode', () => {
+    test('jumps to provided index', () => {
+      br.firstIndex = 100;
+      br.mode = br.constMode1up;
+      br.prev();
+      expect(br.jumpToIndex.callCount).toBe(1);  // <--  gets called
+      expect(flipAnimationStub.callCount).toBe(0); // <-- gets called by `jumpToIndex` internally
+    });
+  });
+});
+

package/tests/{BookReader → jest/BookReader}/DebugConsole.test.js

@@ -1,5 +1,5 @@
 import sinon from 'sinon';
-import { DebugConsole } from '../../src/BookReader/DebugConsole.js';
+import { DebugConsole } from '@/src/BookReader/DebugConsole.js';
 
 beforeEach(() => {
   sinon.stub(console, 'log');

package/tests/{BookReader → jest/BookReader}/ImageCache.test.js

@@ -1,8 +1,8 @@
 import sinon from 'sinon';
-import { BookModel } from '../../src/BookReader/BookModel.js';
-import { ImageCache } from '../../src/BookReader/ImageCache.js';
-import { Pow2ReduceSet } from '../../src/BookReader/ReduceSet.js';
-/** @typedef {import('../../src/BookReader/options.js').BookReaderOptions} BookReaderOptions */
+import { BookModel } from '@/src/BookReader/BookModel.js';
+import { ImageCache } from '@/src/BookReader/ImageCache.js';
+import { Pow2ReduceSet } from '@/src/BookReader/ReduceSet.js';
+/** @typedef {import('@/src/BookReader/options.js').BookReaderOptions} BookReaderOptions */
 
 afterEach(() => {
   jest.restoreAllMocks();

package/tests/jest/BookReader/Mode1UpLit.test.js

@@ -0,0 +1,73 @@
+import { BookModel } from '@/src/BookReader/BookModel.js';
+import { Mode1UpLit } from '@/src/BookReader/Mode1UpLit.js';
+
+/** @type {import('@/src/BookReader/options.js').BookReaderOptions['data']} */
+const SAMPLE_DATA = [
+  [
+    { width: 123, height: 123, uri: 'https://archive.org/image0.jpg', pageNum: '1' },
+  ],
+  [
+    { width: 123, height: 123, uri: 'https://archive.org/image1.jpg', pageNum: '2' },
+    { width: 123, height: 123, uri: 'https://archive.org/image2.jpg', pageNum: '3' },
+  ],
+  [
+    { width: 123, height: 123, uri: 'https://archive.org/image3.jpg', pageNum: '4' },
+    { width: 123, height: 123, uri: 'https://archive.org/image4.jpg', pageNum: '5' },
+  ],
+  [
+    { width: 123, height: 123, uri: 'https://archive.org/image5.jpg', pageNum: '6' },
+  ],
+];
+
+function make_dummy_br(overrides = {}) {
+  return Object.assign({
+    updateFirstIndex() {},
+    _components: {
+      navbar: {
+        updateNavIndexThrottled() {},
+      }
+    },
+    data: []
+  }, overrides);
+}
+
+describe('pageTops', () => {
+  afterEach(() => document.body.innerHTML = '');
+
+  test('Works with empty book', async () => {
+    const br = make_dummy_br({ data: [] });
+    const book = new BookModel(br);
+    const mode = new Mode1UpLit(book, br);
+    document.body.appendChild(mode);
+    mode.requestUpdate();
+    await mode.updateComplete;
+    expect(mode.pageTops).toEqual({});
+  });
+
+  test('Iterates all pages', async () => {
+    const br = make_dummy_br({ data: SAMPLE_DATA });
+    const book = new BookModel(br);
+    const mode = new Mode1UpLit(book, br);
+    document.body.appendChild(mode);
+    await mode.requestUpdate();
+    expect(Object.values(mode.pageTops)).toHaveLength(6);
+  });
+
+  test('Computes tops', async () => {
+    const br = make_dummy_br({ data: SAMPLE_DATA });
+    const book = new BookModel(br);
+    const mode = new Mode1UpLit(book, br);
+    document.body.appendChild(mode);
+    await mode.requestUpdate();
+    const tops = Object.entries(mode.pageTops);
+    expect(tops.map(([index, top]) => [index, top.toFixed(1)])).toEqual([
+      // Recall these are in inches
+      ['0', '0.2'],
+      ['1', '0.6'],
+      ['2', '1.1'],
+      ['3', '1.5'],
+      ['4', '2.0'],
+      ['5', '2.4'],
+    ]);
+  });
+});

package/tests/jest/BookReader/Mode2Up.test.js

@@ -0,0 +1,98 @@
+
+import sinon from 'sinon';
+import { Mode2Up } from '@/src/BookReader/Mode2Up.js';
+import BookReader from '@/src/BookReader.js';
+import { BookModel } from '@/src/BookReader/BookModel.js';
+import { afterEventLoop } from '../utils';
+/** @typedef {import('@/src/BookReader/options.js').BookReaderOptions} BookReaderOptions */
+
+beforeAll(() => {
+  global.alert = jest.fn();
+});
+afterEach(() => {
+  jest.restoreAllMocks();
+  sinon.restore();
+});
+
+/** @type {BookReaderOptions['data']} */
+const SAMPLE_DATA = [
+  [
+    { width: 123, height: 123, uri: 'https://archive.org/image0.jpg', pageNum: '1' },
+  ],
+  [
+    { width: 123, height: 123, uri: 'https://archive.org/image1.jpg', pageNum: '2' },
+    { width: 123, height: 123, uri: 'https://archive.org/image2.jpg', pageNum: '3' },
+  ],
+  [
+    { width: 123, height: 123, uri: 'https://archive.org/image3.jpg', pageNum: '4' },
+    { width: 123, height: 123, uri: 'https://archive.org/image4.jpg', pageNum: '5' },
+  ],
+  [
+    { width: 123, height: 123, uri: 'https://archive.org/image5.jpg', pageNum: '6' },
+  ],
+];
+
+
+describe('Mode2Up', () => {
+  /** @type {BookReader} */
+  let br;
+  /** @type {BookModel} */
+  let bookModel;
+  /** @type {Mode2Up} */
+  let mode2Up;
+
+  beforeEach(() => {
+    br = new BookReader({
+      data: SAMPLE_DATA,
+      el: document.createElement('div'),
+    });
+    br.init();
+    bookModel = new BookModel(br);
+    mode2Up = new Mode2Up(br, bookModel);
+  });
+
+  describe('prepare', () => {
+    it('initializes DOM properly', async () => {
+      const spyAppend = sinon.spy(br.refs.$brContainer, 'append');
+      const spyRequestUpdate = sinon.spy(mode2Up.mode2UpLit, 'requestUpdate');
+      const initFirstRenderSpy = sinon.spy(mode2Up.mode2UpLit, 'initFirstRender');
+      const jumpToIndexSpy = sinon.spy(mode2Up.mode2UpLit, 'jumpToIndex');
+      sinon.stub(mode2Up.mode2UpLit, 'updateComplete').get(() => Promise.resolve());
+      mode2Up.prepare();
+
+      expect(br.refs.$brContainer[0].style.overflow).toEqual('hidden');
+      expect(spyAppend.calledWith(mode2Up.$el)).toBe(true);
+      expect(mode2Up.mode2UpLit.style.opacity).toEqual('0');
+
+      await afterEventLoop();
+
+      expect(initFirstRenderSpy.called).toBe(true);
+      expect(jumpToIndexSpy.called).toBe(false);
+      expect(mode2Up.everShown).toBe(true);
+      expect(spyRequestUpdate.called).toBe(true);
+      expect(mode2Up.mode2UpLit.style.opacity).toEqual('1');
+    });
+  });
+
+  describe('resizePageView', () => {
+    it('updates autoFit when possible', async () => {
+      const updateClientSizesSpy = sinon.stub(mode2Up.mode2UpLit.htmlDimensionsCacher, 'updateClientSizes');
+      const resizeViaAutofitSpy = sinon.spy(mode2Up.mode2UpLit, 'resizeViaAutofit');
+      const recenterStub = sinon.stub(mode2Up.mode2UpLit, 'recenter');
+
+      mode2Up.resizePageView();
+      expect(updateClientSizesSpy.called).toBe(true);
+      expect(resizeViaAutofitSpy.called).toBe(true);
+      expect(recenterStub.called).toBe(true);
+
+      // Test with scale and autoFit as 'none'
+      mode2Up.mode2UpLit.scale = 0.1;
+      mode2Up.mode2UpLit.autoFit = 'none';
+      mode2Up.resizePageView();
+
+      expect(mode2Up.mode2UpLit.autoFit).toEqual('auto');
+      expect(resizeViaAutofitSpy.callCount).toEqual(2);
+      expect(recenterStub.callCount).toEqual(2);
+    });
+  });
+});

package/tests/jest/BookReader/Mode2UpLit.test.js

@@ -0,0 +1,190 @@
+import sinon from "sinon";
+import { BookModel } from "@/src/BookReader/BookModel.js";
+import { Mode2UpLit } from "@/src/BookReader/Mode2UpLit.js";
+
+/** @type {import('@/src/BookReader/options.js').BookReaderOptions['data']} */
+const SAMPLE_DATA = [
+  [
+    {
+      width: 123,
+      height: 123,
+      uri: "https://archive.org/image0.jpg",
+      pageNum: "1",
+    },
+  ],
+  [
+    {
+      width: 123,
+      height: 123,
+      uri: "https://archive.org/image1.jpg",
+      pageNum: "2",
+    },
+    {
+      width: 123,
+      height: 123,
+      uri: "https://archive.org/image2.jpg",
+      pageNum: "3",
+    },
+  ],
+  [
+    {
+      width: 123,
+      height: 123,
+      uri: "https://archive.org/image3.jpg",
+      pageNum: "4",
+    },
+    {
+      width: 123,
+      height: 123,
+      uri: "https://archive.org/image4.jpg",
+      pageNum: "5",
+    },
+  ],
+  [
+    {
+      width: 123,
+      height: 123,
+      uri: "https://archive.org/image5.jpg",
+      pageNum: "6",
+    },
+  ],
+];
+
+function make_dummy_br(overrides = {}) {
+  return Object.assign({
+    updateFirstIndex() {},
+    _components: {
+      navbar: {
+        updateNavIndexThrottled() {},
+      },
+    },
+    data: [],
+  }, overrides);
+}
+
+afterEach(() => {
+  sinon.restore();
+});
+
+describe("computePageHeight", () => {
+  test("Always returns the median", () => {
+    const mode = new Mode2UpLit({
+      getMedianPageSizeInches: () => ({ width: 100, height: 200 }),
+    }, null);
+    expect(mode.computePageHeight(null)).toEqual(200);
+    expect(mode.computePageHeight({ widthInches: 300, heightInches: 400 }))
+      .toEqual(200);
+  });
+});
+
+describe("computePageWidth", () => {
+  test("returns relative to pageHeight", () => {
+    const mode = new Mode2UpLit(null, null);
+    sinon.stub(mode, "computePageHeight").returns(6);
+
+    expect(mode.computePageWidth({ widthInches: 2, heightInches: 6 })).toEqual(
+      2,
+    );
+    expect(mode.computePageWidth({ widthInches: 3, heightInches: 6 })).toEqual(
+      3,
+    );
+    expect(mode.computePageWidth({ widthInches: 2, heightInches: 4 })).toEqual(
+      2 * 6 / 4,
+    );
+  });
+});
+
+describe("computePositions", () => {
+  const LEFT_COVER_EXPECTED = {
+    leafEdgesLeftStart: -0.246,
+    leafEdgesLeftMainWidth: 0,
+    leafEdgesLeftMovingStart: -0.246,
+    leafEdgesLeftMovingWidth: 0,
+    leafEdgesLeftEnd: -0.246,
+    leafEdgesLeftFullWidth: 0,
+    pageLeftStart: -0.246,
+    pageLeftWidth: 0.246,
+    pageLeftEnd: 0,
+    gutter: 0,
+    pageRightStart: 0,
+    pageRightWidth: 0.246,
+    pageRightEnd: 0.246,
+    leafEdgesRightStart: 0.246,
+    leafEdgesRightMovingWidth: 0,
+    leafEdgesRightMainStart: 0.246,
+    leafEdgesRightMainWidth: 0.006,
+    leafEdgesRightEnd: 0.252,
+    leafEdgesRightFullWidth: 0.006,
+    spreadWidth: 0.492,
+    bookWidth: 0.498
+  };
+  const SPREAD_EXPECTED = {
+    leafEdgesLeftStart: -0.246,
+    leafEdgesLeftMainWidth: 0.002,
+    leafEdgesLeftMovingStart: -0.244,
+    leafEdgesLeftMovingWidth: 0,
+    leafEdgesLeftEnd: -0.244,
+    leafEdgesLeftFullWidth: 0.002,
+    pageLeftStart: -0.244,
+    pageLeftWidth: 0.246,
+    pageLeftEnd: 0.002,
+    gutter: 0.002,
+    pageRightStart: 0.002,
+    pageRightWidth: 0.246,
+    pageRightEnd: 0.248,
+    leafEdgesRightStart: 0.248,
+    leafEdgesRightMovingWidth: 0,
+    leafEdgesRightMainStart: 0.248,
+    leafEdgesRightMainWidth: 0.004,
+    leafEdgesRightEnd: 0.252,
+    leafEdgesRightFullWidth: 0.004,
+    spreadWidth: 0.492,
+    bookWidth: 0.498
+  };
+  const RIGHT_COVER_EXPECTED = {
+    leafEdgesLeftStart: -0.242,
+    leafEdgesLeftMainWidth: 0.006,
+    leafEdgesLeftMovingStart: -0.236,
+    leafEdgesLeftMovingWidth: 0,
+    leafEdgesLeftEnd: -0.236,
+    leafEdgesLeftFullWidth: 0.006,
+    pageLeftStart: -0.236,
+    pageLeftWidth: 0.246,
+    pageLeftEnd: 0.01,
+    gutter: 0.01,
+    pageRightStart: 0.01,
+    pageRightWidth: 0,
+    pageRightEnd: 0.01,
+    leafEdgesRightStart: 0.01,
+    leafEdgesRightMovingWidth: 0,
+    leafEdgesRightMainStart: 0.01,
+    leafEdgesRightMainWidth: 0,
+    leafEdgesRightEnd: 0.01,
+    leafEdgesRightFullWidth: 0,
+    spreadWidth: 0.246,
+    bookWidth: 0.252
+  };
+
+  test("left cover page", () => {
+    const br = make_dummy_br({ data: SAMPLE_DATA });
+    const book = new BookModel(br);
+    const mode = new Mode2UpLit(book, br);
+    expect(mode.computePositions(null, book.getPage(0))).toEqual(LEFT_COVER_EXPECTED);
+  });
+
+  test("spread", () => {
+    const br = make_dummy_br({ data: SAMPLE_DATA });
+    const book = new BookModel(br);
+    const mode = new Mode2UpLit(book, br);
+
+    expect(mode.computePositions(book.getPage(1), book.getPage(2))).toEqual(SPREAD_EXPECTED);
+  });
+
+  test("right cover page", () => {
+    const br = make_dummy_br({ data: SAMPLE_DATA });
+    const book = new BookModel(br);
+    const mode = new Mode2UpLit(book, br);
+
+    expect(mode.computePositions(book.getPage(-1), null)).toEqual(RIGHT_COVER_EXPECTED);
+  });
+});

package/tests/jest/BookReader/ModeCoordinateSpace.test.js

@@ -0,0 +1,16 @@
+import { ModeCoordinateSpace } from "@/src/BookReader/ModeCoordinateSpace";
+
+describe("worldUnitsToRenderedPixels", () => {
+  test("0 case", () => {
+    const mcs = new ModeCoordinateSpace({ scale: 1 });
+    expect(mcs.worldUnitsToRenderedPixels(0)).toBe(0);
+  });
+
+  test("Misc cases", () => {
+    const mcs = new ModeCoordinateSpace({ scale: 1 });
+    mcs.screenDPI = 100;
+    expect(mcs.worldUnitsToRenderedPixels(1)).toBe(100);
+    mcs.screenDPI = 78;
+    expect(mcs.worldUnitsToRenderedPixels(1)).toBe(78);
+  });
+});