@internetarchive/ia-item-navigator 0.0.0 → 0.0.2

package/src/no-theater-available.ts

@@ -0,0 +1,85 @@
+import {
+  LitElement,
+  customElement,
+  property,
+  html,
+  TemplateResult,
+  PropertyValues,
+  CSSResult,
+  css,
+} from 'lit-element';
+
+@customElement('ia-no-theater-available')
+export class IANoTheaterAvailable extends LitElement {
+  @property({ type: String }) identifier?: string = '';
+
+  emitLoaded(): void {
+    this.dispatchEvent(
+      new CustomEvent<{ loaded: boolean }>('loadingStateUpdated', {
+        detail: { loaded: true },
+      })
+    );
+  }
+
+  updated(changed: PropertyValues): void {
+    if (changed.has('identifier')) {
+      this.emitLoaded();
+    }
+  }
+
+  get downloadUrl(): string {
+    return `/download/${this.identifier}`;
+  }
+
+  render(): TemplateResult {
+    return html`
+      <section>
+        <h2>THERE IS NO PREVIEW AVAILABLE FOR THIS ITEM</h2>
+        <p>
+          This item does not appear to have any files that can be experienced on
+          Archive.org. <br />
+          Please download files in this item to interact with them on your
+          computer.
+        </p>
+        <a href=${this.downloadUrl}>Show all files</a>
+      </section>
+    `;
+  }
+
+  static get styles(): CSSResult {
+    return css`
+      :host {
+        color: var(--primaryTextColor, #fff);
+        text-align: center;
+      }
+      section {
+        margin: 10% auto 0;
+        padding: 0 5%;
+      }
+      p {
+        font-size: 1.4rem;
+      }
+      a {
+        color: var(--primaryTextColor, #fff);
+        background-color: rgb(25, 72, 128);
+        min-height: 35px;
+        outline: none;
+        cursor: pointer;
+        line-height: normal;
+        border-radius: 0.4rem;
+        text-align: center;
+        vertical-align: middle;
+        font-size: 1.4rem;
+        font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
+        display: inline-block;
+        padding: 0.85rem 1.2rem;
+        border: 1px solid rgb(197, 209, 223);
+        white-space: nowrap;
+        appearance: auto;
+        box-sizing: border-box;
+        user-select: none;
+        text-decoration: none;
+      }
+    `;
+  }
+}

package/test/book-nav-stub.ts

@@ -0,0 +1,47 @@
+import { ModalManager } from '@internetarchive/modal-manager';
+import { SharedResizeObserver } from '@internetarchive/shared-resize-observer';
+import { html, customElement, LitElement, property } from 'lit-element';
+import { MetadataResponse } from '@internetarchive/search-service';
+import {
+  MenuProviderInterface,
+  MenuShortcutInterface,
+} from '../src/interfaces/menu-interfaces';
+import { CustomTheaterInterface } from '../src/interfaces/custom-theater-interface';
+@customElement('book-navigator')
+export class BookNavigator
+  extends LitElement
+  implements CustomTheaterInterface {
+  @property({ attribute: false }) modal?: ModalManager;
+
+  @property({ type: Object }) itemMD?: MetadataResponse;
+
+  @property({ type: String }) baseHost?: string;
+
+  @property({ type: Boolean, reflect: true }) signedIn?: boolean | null = null;
+
+  @property({ type: Boolean }) sideMenuOpen!: boolean;
+
+  @property({ attribute: false }) sharedObserver?: SharedResizeObserver;
+
+  @property({ type: Array }) menuProviders?: MenuProviderInterface[];
+
+  @property({ type: Array }) menuShortcuts?: MenuShortcutInterface[];
+
+  emitLoadingStatusUpdate() {}
+
+  addMenuShortcut(menuId: string) {
+    return menuId;
+  }
+
+  removeMenuShortcut(menuId: string) {
+    return menuId;
+  }
+
+  sortMenuShortcuts() {}
+
+  emitMenuShortcutsUpdated() {}
+
+  render() {
+    return html` <p>foo</p> `;
+  }
+}

package/test/ia-item-navigator.test.ts

@@ -0,0 +1,438 @@
+/* eslint-disable camelcase */
+import { html, fixture, expect } from '@open-wc/testing';
+import Sinon from 'sinon';
+
+import { SharedResizeObserver } from '@internetarchive/shared-resize-observer';
+import { ModalManager } from '@internetarchive/modal-manager';
+import { CustomTheaterInterface } from '../src/interfaces/custom-theater-interface';
+import { ItemNavigator, ItemType } from '../src/item-navigator';
+import '../src/item-navigator';
+
+import '../test/book-nav-stub';
+import { ItemStub, menuProvider, shortcut } from '../test/ia-stub';
+import {
+  ManageFullscreenEvent,
+  ToggleSideMenuOpenEvent,
+  SetSideMenuContentsEvent,
+  SetSideMenuShortcutsEvent,
+  ToggleSidePanelOpenEvent,
+} from '../src/interfaces/event-interfaces';
+
+afterEach(() => {
+  Sinon.restore();
+});
+
+describe('ItemNavigator', () => {
+  describe('Theaters', () => {
+    it('shows <ia-no-theater-available> by default', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator .item=${new ItemStub()}></ia-item-navigator>`
+      );
+      expect(el.shadowRoot?.querySelector('ia-no-theater-available')).to.exist;
+    });
+
+    it('shows <book-navigator> if `this.itemType = "bookreader"`', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator
+          .itemType=${ItemType.BOOK}
+          .item=${new ItemStub()}
+          .modal=${new ModalManager()}
+          .sharedObserver=${new SharedResizeObserver()}
+        ></ia-item-navigator>`
+      );
+
+      await el.updateComplete;
+
+      el.toggleMenu();
+      await el.updateComplete;
+
+      const bookNavigator = el.shadowRoot?.querySelector(
+        'book-navigator'
+      ) as CustomTheaterInterface;
+      await bookNavigator.updateComplete;
+
+      console.log('132234234324324324');
+      // TODO: add BookNavigator type & import via @internetarchive/bookreader
+      // For now, let's check that the BookNavigator element and its properties exist w/ stub
+      expect(bookNavigator).to.exist;
+      expect(bookNavigator?.modal).to.exist;
+      expect(bookNavigator?.baseHost).to.exist;
+      expect(bookNavigator?.signedIn).to.be.null;
+      expect(bookNavigator?.sharedObserver).to.exist;
+      expect(bookNavigator?.sideMenuOpen).to.exist;
+    });
+  });
+  describe('`el.loaded`', () => {
+    it('toggles the spinning loader', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator></ia-item-navigator>`
+      );
+      expect(el.loaded).to.be.null; // initial load
+      expect(el.shadowRoot?.querySelector('ia-itemnav-loader')).to.exist;
+    });
+    it('hides reader section if `!loaded`', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator></ia-item-navigator>`
+      );
+
+      expect(
+        el.shadowRoot?.querySelector('#reader')?.getAttribute('class')
+      ).to.contain('hide');
+    });
+    it('shows reader when `loaded` ', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator .item=${new ItemStub()}></ia-item-navigator>`
+      );
+
+      const mainTheaterSection = el.shadowRoot?.querySelector('#reader');
+      expect(mainTheaterSection?.classList.contains('hide')).to.be.false;
+      expect(el.loaded).to.be.true;
+      // `loaded` property is reflected as DOM attribute
+      expect(el.hasAttribute('loaded')).to.equal(true);
+      expect(el.shadowRoot?.querySelector('ia-no-theater-available')).to.exist;
+    });
+    it('listens to `@loadingStateUpdated` to update `loaded`', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator></ia-item-navigator>`
+      );
+
+      await el.updateComplete;
+      const spy = Sinon.spy();
+      el.loadingStateUpdated = spy;
+      el.loaded = null;
+      await el.updateComplete;
+      // check base properties
+      expect(el.loaded).to.equal(null);
+      expect(el.item).to.be.undefined;
+
+      // hydrate item
+      el.item = new ItemStub();
+      await el.updateComplete;
+
+      // spy fires
+      expect(spy.called).to.equal(true);
+      expect(spy.callCount).to.equal(1);
+    });
+  });
+
+  describe('`el.sharedObserver`', () => {
+    it('uses one', async () => {
+      const sharedObserver = new SharedResizeObserver();
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator
+          .sharedObserver=${sharedObserver}
+        ></ia-item-navigator>`
+      );
+
+      expect(el.sharedObserver).to.equal(sharedObserver);
+      expect(typeof el.handleResize).to.equal('function');
+    });
+    it('freshly registers handler', async () => {
+      const sharedObserver = new SharedResizeObserver();
+      const addObserverSpy = Sinon.spy(sharedObserver, 'addObserver');
+
+      await fixture<ItemNavigator>(
+        html`<ia-item-navigator
+          .sharedObserver=${sharedObserver}
+        ></ia-item-navigator>`
+      );
+
+      expect(addObserverSpy.callCount).to.equal(1);
+    });
+    it('removes handler when component disconnects', async () => {
+      const sharedObserver = new SharedResizeObserver();
+      const removeObserverSpy = Sinon.spy(sharedObserver, 'removeObserver');
+
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator
+          .sharedObserver=${sharedObserver}
+        ></ia-item-navigator>`
+      );
+
+      el.disconnectedCallback();
+      await el.updateComplete;
+
+      expect(removeObserverSpy.callCount).to.equal(1);
+    });
+    it('sets menu to overlay if container width is <= 600px', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator></ia-item-navigator>`
+      );
+
+      expect(el.openMenuState).to.equal('shift'); // as starting point
+
+      const overlaySize = {
+        contentRect: { width: 600 },
+      } as ResizeObserverEntry;
+      el.handleResize(overlaySize);
+      await el.updateComplete;
+
+      expect(el.openMenuState).to.equal('overlay'); // changes open menu display to an overlay
+
+      const shiftSize = {
+        contentRect: { width: 601 },
+      } as ResizeObserverEntry;
+      el.handleResize(shiftSize);
+      await el.updateComplete;
+
+      expect(el.openMenuState).to.equal('shift');
+    });
+  });
+
+  describe('`el.modal`', () => {
+    it('uses one', async () => {
+      const modal = new ModalManager();
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator .modal=${modal}></ia-item-navigator>`
+      );
+      expect(el.modal).to.equal(modal);
+    });
+  });
+
+  describe('full browser window immersion "fullscreen"', () => {
+    it('creates reflected attribute `viewportinfullscreen`', async () => {
+      /** to help with external styling adjustmnents */
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator></ia-item-navigator>`
+      );
+      expect(el.getAttribute('viewportinfullscreen')).to.be.null;
+
+      el.viewportInFullscreen = true;
+      await el.updateComplete;
+
+      expect(el.getAttribute('viewportinfullscreen')).to.exist;
+    });
+    it('@ViewportInFullScreen', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator></ia-item-navigator>`
+      );
+      expect(el.viewportInFullscreen).to.be.null;
+
+      const yesFullscreenEvent = {
+        detail: {
+          isFullScreen: true,
+        },
+      } as ManageFullscreenEvent;
+      el.manageViewportFullscreen(yesFullscreenEvent);
+      await el.updateComplete;
+      expect(el.viewportInFullscreen).to.be.true;
+
+      const noFullscreenEvent = {
+        detail: {
+          isFullScreen: false,
+        },
+      } as ManageFullscreenEvent;
+      el.manageViewportFullscreen(noFullscreenEvent);
+      await el.updateComplete;
+      expect(el.viewportInFullscreen).to.be.null;
+    });
+  });
+
+  /* Side menu & shortcuts tests */
+  describe('el.menuOpened', () => {
+    it('toggles side menu open', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator .item=${new ItemStub()}></ia-item-navigator>`
+      );
+
+      el.menuContents = [menuProvider];
+      await el.updateComplete;
+
+      const nav = el.shadowRoot?.querySelector('nav');
+
+      expect(nav?.querySelector('#menu')).to.exist;
+      // side menu starts closed
+      expect(el.menuOpened).to.be.false;
+      expect(nav?.querySelector('#menu')?.getAttribute('class')).to.contain(
+        'hidden'
+      );
+
+      // let's open menu
+      el.toggleMenu();
+      await el.updateComplete;
+
+      expect(el.menuOpened).to.be.true;
+      expect(nav?.querySelector('#menu')?.getAttribute('class')).to.not.contain(
+        'hidden'
+      );
+    });
+
+    it('opens menu shortcut with `@manageSideMenuEvents`', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator .item=${new ItemStub()}></ia-item-navigator>`
+      );
+      const detail = {
+        menuId: 'fullscreen',
+        action: 'open',
+      };
+
+      el.menuContents = [menuProvider];
+      await el.updateComplete;
+      const frame = el.shadowRoot?.querySelector('#frame');
+      // default menu open behavior is to side menu open, not overlay
+      expect(frame?.getAttribute('class')).to.contain('shift');
+
+      expect(el.menuOpened).to.be.false;
+      expect(el.openMenu).to.be.undefined;
+      expect(frame?.getAttribute('class')).to.not.contain('open');
+
+      const event = new CustomEvent('updateSideMenu', {
+        detail,
+      }) as ToggleSideMenuOpenEvent;
+      el.manageSideMenuEvents(event);
+      await el.updateComplete;
+
+      expect(el.shouldRenderMenu).to.be.true;
+      expect(el.menuOpened).to.be.true;
+      expect(el.openMenu).to.equal(detail.menuId);
+
+      expect(frame?.getAttribute('class')).to.contain('open');
+
+      // no menu provided
+      const openShortcutSpy = Sinon.spy(el, 'openShortcut');
+      const toggleMenuSpy = Sinon.spy(el, 'toggleMenu');
+
+      const noMenuProvidedEvent = new CustomEvent('updateSideMenu', {
+        detail: {},
+      }) as any;
+      el.manageSideMenuEvents(noMenuProvidedEvent);
+      await el.updateComplete;
+
+      expect(openShortcutSpy.called).to.be.false;
+      expect(toggleMenuSpy.called).to.be.false;
+
+      // toggle menu
+      const toggleMenuEvent = new CustomEvent('updateSideMenu', {
+        detail: { action: 'toggle', menuId: 'fullscreen' },
+      }) as any;
+      el.manageSideMenuEvents(toggleMenuEvent);
+      await el.updateComplete;
+
+      expect(toggleMenuSpy.callCount).to.equal(1);
+
+      // open menu
+      const openMenuEvent = new CustomEvent('updateSideMenu', {
+        detail: { action: 'open', menuId: 'fullscreen' },
+      }) as any;
+      el.manageSideMenuEvents(openMenuEvent);
+      await el.updateComplete;
+
+      expect(openShortcutSpy.callCount).to.equal(1);
+    });
+  });
+
+  describe('el.menuContents', () => {
+    it('draws side menu when populated', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator .item=${new ItemStub()}></ia-item-navigator>`
+      );
+
+      el.menuContents = [menuProvider];
+      await el.updateComplete;
+      expect(el.menuContents.length).to.exist;
+      expect(el.shouldRenderMenu).to.be.true;
+
+      const nav = el.shadowRoot?.querySelector('nav');
+      expect(nav).to.exist;
+
+      const menuSlider = nav?.querySelector('ia-menu-slider');
+      expect(menuSlider).to.exist;
+      expect(menuSlider?.getAttribute('manuallyhandleclose')).to.exist;
+      expect(menuSlider?.getAttribute('open')).to.exist;
+    });
+  });
+
+  describe('`el.menuShortcuts`', () => {
+    it('displays shortcut & toggle side menu button', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator .item=${new ItemStub()}></ia-item-navigator>`
+      );
+
+      const anotherShortcut = {
+        id: 'foo',
+        icon: html`<i class="foo-shortcut"></i>`,
+      };
+      el.menuContents = [menuProvider];
+      el.menuShortcuts = [shortcut, anotherShortcut];
+      await el.updateComplete;
+
+      const nav = el.shadowRoot?.querySelector('nav');
+
+      const shortcutsContainer = nav?.querySelector('.shortcuts');
+      expect(el.menuShortcuts.length).to.exist;
+      expect(nav).to.exist;
+      expect(shortcutsContainer).to.exist;
+      expect(shortcutsContainer?.querySelector('i.fullscreen-test')).to.exist;
+      expect(shortcutsContainer?.querySelector('button.shortcut.foo')).to.exist;
+      expect(nav?.querySelector('.toggle-menu')).to.exist;
+    });
+  });
+
+  describe('Menu events', () => {
+    it('`el.setMenuShortcuts`', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator .item=${new ItemStub()}></ia-item-navigator>`
+      );
+      expect(el.menuShortcuts.length).to.equal(0);
+
+      const menuShortcuts = [shortcut];
+
+      el.setMenuShortcuts({
+        detail: menuShortcuts,
+      } as SetSideMenuShortcutsEvent);
+      await el.updateComplete;
+
+      expect(el.menuShortcuts.length).to.equal(1);
+    });
+    it('`el.setMenuContents`', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator .item=${new ItemStub()}></ia-item-navigator>`
+      );
+      expect(el.menuContents.length).to.equal(0);
+
+      el.setMenuShortcuts({
+        detail: [menuProvider],
+      } as SetSideMenuContentsEvent);
+      await el.updateComplete;
+
+      expect(el.menuShortcuts.length).to.equal(1);
+    });
+    it('`el.setOpenMenu`', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator .item=${new ItemStub()}></ia-item-navigator>`
+      );
+
+      el.setOpenMenu({
+        detail: { id: 'foo' },
+      } as ToggleSidePanelOpenEvent);
+      await el.updateComplete;
+
+      expect(el.openMenu).to.equal('foo');
+      expect(el.selectedMenuId).to.equal('foo');
+
+      // toggles it off
+      el.setOpenMenu({
+        detail: { id: 'foo' },
+      } as ToggleSidePanelOpenEvent);
+      await el.updateComplete;
+
+      expect(el.openMenu).to.be.undefined;
+      expect(el.selectedMenuId).to.equal('');
+    });
+    it('`el.closeMenu`', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator .item=${new ItemStub()}></ia-item-navigator>`
+      );
+
+      el.menuOpened = true;
+      await el.updateComplete;
+
+      expect(el.menuOpened).to.be.true;
+
+      el.closeMenu();
+      await el.updateComplete;
+
+      expect(el.menuOpened).to.be.false;
+    });
+  });
+});

package/test/ia-stub.ts

@@ -0,0 +1,79 @@
+/* eslint-disable camelcase */
+import {
+  MetadataResponse,
+  Metadata,
+  File,
+  Review,
+  SpeechMusicASREntry,
+} from '@internetarchive/search-service';
+import { html } from 'lit-html';
+import {
+  MenuShortcutInterface,
+  MenuProviderInterface,
+} from '../src/interfaces/menu-interfaces';
+
+export class ItemStub implements MetadataResponse {
+  constructor() {
+    this.rawResponse = '';
+    this.created = 1;
+    this.d1 = 'hello';
+    this.d2 = 'boop';
+    this.dir = 'whee';
+    this.files = [];
+    this.files_count = 0;
+    this.item_last_updated = 2020;
+    this.item_size = 111;
+    this.metadata = { identifier: 'foo' } as Metadata;
+    this.server = 'foo-server';
+    this.uniq = 2;
+    this.workable_servers = ['abc'];
+  }
+
+  rawResponse: any;
+
+  created: number;
+
+  d1: string;
+
+  d2: string;
+
+  dir: string;
+
+  files: File[];
+
+  files_count: number;
+
+  item_last_updated: number;
+
+  item_size: number;
+
+  metadata: Metadata;
+
+  server: string;
+
+  uniq: number;
+
+  workable_servers: string[];
+
+  speech_vs_music_asr?: SpeechMusicASREntry[] | undefined;
+
+  reviews?: Review[] | undefined;
+}
+
+export const shortcut = {
+  id: 'fullscreen',
+  icon: html`<i class="fas fullscreen-test"></i>`,
+} as MenuShortcutInterface;
+
+export const menuProvider = {
+  ...shortcut,
+  label: 'foo',
+  menuDetails: html`<div>foo</div>`,
+  selected: true,
+  followable: false,
+  href: 'https://archive.foo',
+  item: new ItemStub(),
+  baseHost: 'https://archive.foo',
+  subPrefix: 'bar',
+  updated: () => {},
+} as MenuProviderInterface;

package/test/no-theater-available.test.ts

@@ -0,0 +1,32 @@
+import { html, fixture, expect } from '@open-wc/testing';
+import { IANoTheaterAvailable } from '../src/no-theater-available';
+import '../src/no-theater-available';
+
+describe('IANoTheaterAvailable', () => {
+  it('Fires `loadingStateUpdated` on identifier change', async () => {
+    const el = await fixture<IANoTheaterAvailable>(
+      html`<ia-no-theater-available
+        .identifier=${`foo`}
+      ></ia-no-theater-available>`
+    );
+    let eventFired = false;
+    el.addEventListener('loadingStateUpdated', () => {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      eventFired = true;
+    });
+    expect(eventFired).to.be.false;
+
+    el.identifier = 'bar';
+    await el.updateComplete;
+    expect(eventFired).to.be.true;
+  });
+  it('Has link to item download page', async () => {
+    const el = await fixture<IANoTheaterAvailable>(
+      html`<ia-no-theater-available
+        .identifier=${`foo`}
+      ></ia-no-theater-available>`
+    );
+    expect(el.downloadUrl).to.equal('/download/foo');
+    expect(el?.shadowRoot?.querySelector('a')?.href).to.contain(el.downloadUrl);
+  });
+});