@readium/navigator 1.2.0

package/src/epub/fxl/FXLSpreader.ts

@@ -0,0 +1,95 @@
+import { Link, Links, Orientation, Page, Publication, ReadingProgression, Spread } from "@readium/shared";
+
+export class FXLSpreader {
+    shift = true; // TODO getter
+    private spreads: Link[][] = [];
+    nLandscape: number = 0; // TODO getter
+
+    constructor(publication: Publication) {
+        this.index(publication);
+        this.testShift(publication);
+        console.log(`Indexed ${this.spreads.length} spreads for ${publication.readingOrder.items.length} items`);
+    }
+
+    private index(publication: Publication, redo = false) {
+        this.nLandscape = 0;
+        publication.readingOrder.items.forEach((item, index) => {
+            // item.Properties.Spread = item.Properties.Spread ? item.Properties.Spread : "landscape"; // TODO Maybe default to auto instead
+            if(!redo) {
+                publication.readingOrder.items[index] = item.addProperties({
+                    "number": index + 1,
+                    "isImage": item.type?.indexOf("image/") === 0,
+                });
+                // if(!orientation) item.Properties.Orientation = item.Width > item.Height ? "landscape" : "portrait";
+            }
+            const isLandscape = item.properties?.getOrientation() === Orientation.landscape ? true : false;
+            if((!item.properties?.getPage() || redo)) item.properties = item.properties?.add({
+                "page": isLandscape ? // If a landscape image
+                    "center" : // Center it
+                    ((((this.shift ? 0 : 1) + index - this.nLandscape) % 2) ? 
+                        (publication.metadata.readingProgression === ReadingProgression.rtl ? "right" : "left") :
+                        (publication.metadata.readingProgression === ReadingProgression.rtl ? "left" : "right"))
+            })
+            if(isLandscape || item.properties?.otherProperties["addBlank"])
+                this.nLandscape++;
+        });
+        if(redo)
+            this.spreads = [];
+        this.buildSpreads(publication.readingOrder);
+    }
+
+    private testShift(publication: Publication) {
+        let wasLastSingle = false;
+        this.spreads.forEach((item, index) => {
+            if(item.length > 1)
+                return; // Only left with single-page "spreads"
+            const single = item[0];
+            const orientation = single.properties?.getOrientation();
+
+            // First page is landscape/spread means no shift
+            if(index === 0 && (orientation === Orientation.landscape || (orientation !== Orientation.portrait && ((single.width || 0) > (single.height || 0) || single.properties?.getSpread() === Spread.both))))
+                this.shift = false;
+
+            // If last was a true single, and this spread is a center page (that's not special), something's wrong
+            if(wasLastSingle && single.properties?.getPage() === Page.center) {
+                this.spreads[index - 1][0].addProperties({"addBlank": true});
+                /*if(single.findFlag("final"))
+                    this.nLandscape++;*/
+            }
+
+            // If this single page spread is an orphaned component of a double page spread (and it's not the first page)
+            if(orientation === Orientation.portrait && single.properties?.getPage() !== "center" && single.properties?.otherProperties["number"] > 1)
+                wasLastSingle = true;
+            else
+                wasLastSingle = false;
+        });
+        if(!this.shift)
+            this.index(publication, true); // Re-index spreads
+    }
+
+    private buildSpreads(spine: Links) {
+        let currentSet: Link[] = [];
+        spine.items.forEach((item, index) => {
+            if(!index && this.shift) {
+                this.spreads.push([item]);
+            } else if(item.properties?.getPage() === Page.center) { // If a center (single) page spread, push immediately and reset current set
+                if(currentSet.length > 0) this.spreads.push(currentSet);
+                this.spreads.push([item]);
+                currentSet = [];
+            } else if (currentSet.length >= 2) { // Spread has max 2 pages
+                this.spreads.push(currentSet);
+                currentSet = [item];
+            } else // Add this item to current set
+                currentSet.push(item);
+        });
+        if(currentSet.length > 0) this.spreads.push(currentSet);
+    }
+
+    currentSpread(currentSlide: number, perPage: number): Link[] {
+        return this.spreads[Math.min(Math.floor(currentSlide / perPage), this.spreads.length - 1)];
+    }
+
+    findByLink(link: Link): Link[] | undefined {
+        return this.spreads.find((spread) => spread.includes(link)) || undefined;
+    }
+}

package/src/epub/fxl/index.ts

@@ -0,0 +1,5 @@
+export * from "./FXLCoordinator";
+export * from "./FXLFrameManager";
+export * from "./FXLFramePoolManager";
+export * from "./FXLPeripherals";
+export * from "./FXLSpreader";

package/src/epub/index.ts

@@ -0,0 +1,3 @@
+export * from "./EpubNavigator";
+export * from "./frame";
+export * from "./fxl";

package/src/helpers/sML.ts

@@ -0,0 +1,120 @@
+/*!
+ *                                                                                                                         (℠)
+ *  # sML.js | I'm a Simple and Middling Library.
+ *
+ *  * Copyright (c) Satoru MATSUSHIMA - https://github.com/satorumurmur/sML
+ *  * Licensed under the MIT license. - http://www.opensource.org/licenses/mit-license.php
+ *
+ * Portions of this code come from the sML library
+ * Current version: 1.0.36
+ */
+
+declare interface OSFlags {
+    iOS: number[];
+    macOS: number[];
+    iPadOS: number[];
+    WindowsPhone: number[];
+    ChromeOS: number[];
+    Windows: number[];
+    Android: number[];
+    Linux: number[];
+    Firefox: boolean;
+}
+
+declare interface UAFlags {
+    Gecko: number[];
+    Firefox: number[];
+    Waterfox: number[];
+    Opera: number[];
+    Silk: number[];
+    Blink: number[];
+    EdgeHTML: number[];
+    Chrome: number[];
+    Chromium: number[];
+    Phoebe: number[];
+    UCBrowser: number[];
+    Vivaldi: number[];
+    Safari: number[];
+    Edge: number[];
+    WebKit: number[];
+    Trident: number[];
+    InternetExplorer: number[];
+    Flash: number[];
+    Facebook: number[];
+    LINE: number[];
+}
+
+class sML {
+    OS: OSFlags;
+    UA: UAFlags;
+    Env!: string[];
+
+    constructor() {
+        const NUAD = (navigator as any).userAgentData, NUA = navigator.userAgent;
+
+        const _sV = (V?: string | number) => (typeof V === "string" || typeof V === "number") && V ? String(V).replace(/_/g, ".").split(".").map(I => parseInt(I) || 0) : [];
+        const _dV = (Pre="") => {
+            if(!Pre) return [];
+            const RE = new RegExp("^.*" + Pre + "[ :\\/]?(\\d+([\\._]\\d+)*).*$");
+            if(!RE.test(NUA)) return [];
+            return _sV(NUA.replace(RE, "$1"));
+        };
+
+        this.OS = ((OS: OSFlags) => {
+            if(                /(macOS|Mac OS X)/.test(NUA)) {
+                    if(/\(iP(hone|od touch);/.test(NUA)) OS.iOS = _dV("CPU (?:iPhone )?OS ");
+                    if(             /\(iPad;/.test(NUA)) OS.iOS = OS.iPadOS = _dV("CPU (?:iPhone )?OS ");
+                else if( /(macOS|Mac OS X) \d/.test(NUA)) document.ontouchend !== undefined ? OS.iOS = OS.iPadOS = _dV() : OS.macOS = _dV("(?:macOS|Mac OS X) ");
+            } else if(      /Windows( NT)? \d/.test(NUA)) OS.Windows = (V => V[0] !== 6 || !V[1] ? V : V[1] === 1 ? [7] : V[1] === 2 ? [8] : [8, 1])(_dV("Windows(?: NT)?"));
+            else if(            /Android \d/.test(NUA)) OS.Android = _dV("Android");
+            else if(                  /CrOS/.test(NUA)) OS.ChromeOS = _dV();
+            else if(                  /X11;/.test(NUA)) OS.Linux = _dV();
+            return OS;
+        })({} as OSFlags); if(NUAD) NUAD.getHighEntropyValues(["architecture", "model", "platform", "platformVersion", "uaFullVersion"]).then((HEUAD: any) => (OS => { const Pf = HEUAD.platform, PfV = HEUAD.platformVersion; if(!Pf || !PfV) return;
+                if(         /^i(OS|P(hone|od touch))$/.test(Pf)) OS.iOS = _sV(PfV);
+            else if(                      /^iPad(OS)?$/.test(Pf)) OS.iOS = OS.iPadOS = _sV(PfV);
+            else if(/^(macOS|(Mac )?OS X|Mac(Intel)?)$/.test(Pf)) document.ontouchend !== undefined ? OS.iOS = OS.iPadOS = _sV() : OS.macOS = _sV(PfV);
+            else if(           /^(Microsoft )?Windows$/.test(Pf)) OS.Windows = _sV(PfV);
+            else if(              /^(Google )?Android$/.test(Pf)) OS.Android = _sV(PfV);
+            else if(     /^((Google )?Chrome OS|CrOS)$/.test(Pf)) OS.ChromeOS = _sV(PfV);
+            else if(             /^(Linux|Ubuntu|X11)$/.test(Pf)) OS.Linux = _sV(PfV);
+            else return; /**/ Object.keys(this.OS).forEach(Key => delete (this.OS as any)[Key]), Object.assign(this.OS, OS);
+        })({} as OSFlags));
+
+        this.UA = ((UA: UAFlags) => { let _OK = false;
+            if(NUAD && Array.isArray(NUAD.brands)) { const BnV = NUAD.brands.reduce((BnV: string[], _: any) => { (BnV[_.brand] as any) = [_.version * 1]; return BnV; }, {});
+                    if(BnV["Google Chrome"])  _OK = true, UA.Blink = UA.Chromium = BnV["Chromium"] || [], UA.Chrome = BnV["Google Chrome"];
+                else if(BnV["Microsoft Edge"]) _OK = true, UA.Blink = UA.Chromium = BnV["Chromium"] || [], UA.Edge = BnV["Microsoft Edge"];
+                else if(BnV["Opera"])          _OK = true, UA.Blink = UA.Chromium = BnV["Chromium"] || [], UA.Opera = BnV["Opera"];
+            } if(!_OK) {
+                if(              / Gecko\/\d/.test(NUA)) { UA.Gecko = _dV("rv");
+                        if(  / Waterfox\/\d/.test(NUA))   UA.Waterfox = _dV("Waterfox");
+                    else if(   / Firefox\/\d/.test(NUA))   UA.Firefox = _dV("Firefox");
+                } else if(        / Edge\/\d/.test(NUA)) { UA.EdgeHTML = _dV("Edge");
+                                                        UA.Edge = UA.EdgeHTML;
+                } else if(/ Chrom(ium|e)\/\d/.test(NUA)) { UA.Blink = UA.Chromium = (V => V[0] ? V : _dV("Chrome"))(_dV("Chromium"));
+                        if(     / EdgA?\/\d/.test(NUA))   UA.Edge = (V => V[0] ? V : _dV("Edg"))(_dV("EdgA"));
+                    else if(       / OPR\/\d/.test(NUA))   UA.Opera = _dV("OPR");
+                    else if(   / Vivaldi\/\d/.test(NUA))   UA.Vivaldi = _dV("Vivaldi");
+                    else if(      / Silk\/\d/.test(NUA))   UA.Silk = _dV("Silk");
+                    else if( / UCBrowser\/\d/.test(NUA))   UA.UCBrowser = _dV("UCBrowser");
+                    else if(    / Phoebe\/\d/.test(NUA))   UA.Phoebe = _dV("Phoebe");
+                    else                                   UA.Chrome = (V => V[0] ? V : UA.Chromium)(_dV("Chrome"));
+                } else if( / AppleWebKit\/\d/.test(NUA)) { UA.WebKit = _dV("AppleWebKit");
+                        if(      / CriOS \d/.test(NUA))   UA.Chrome = _dV("CriOS");
+                    else if(      / FxiOS \d/.test(NUA))   UA.Firefox = _dV("FxiOS");
+                    else if(    / EdgiOS\/\d/.test(NUA))   UA.Edge = _dV("EdgiOS");
+                    else if(   / Version\/\d/.test(NUA))   UA.Safari = _dV("Version");
+                } else if(     / Trident\/\d/.test(NUA)) { UA.Trident = _dV("Trident");
+                                                        UA.InternetExplorer = (V => V[0] ? V : _dV("MSIE"))(_dV("rv"));
+                }
+            } /*+*/ if( /[\[; ]FB(AN|_IAB)\//.test(NUA))   UA.Facebook = _dV("FBAV");
+            /*+*/ if(           / Line\/\d/.test(NUA))   UA.LINE = _dV("Line");
+            return UA;
+        })({} as UAFlags);
+
+        (this.Env as any) = { get: () => [this.OS, this.UA].reduce((Env: string[], OS_UA) => { for(const Par in OS_UA) if((OS_UA as any)[Par]) Env.push(Par); return Env; }, []) };
+    }
+}
+
+export default (new sML);

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './Navigator';
+export * from './epub';
+export * from './audio';

package/types/src/Navigator.d.ts

@@ -0,0 +1,41 @@
+import { Link, Locator, Publication, ReadingProgression } from "@readium/shared";
+type cbb = (ok: boolean) => void;
+export declare abstract class Navigator {
+    abstract get publication(): Publication;
+    abstract get currentLocator(): Locator;
+    /**
+     * Moves to the position in the publication corresponding to the given {Locator}.
+     */
+    abstract go(locator: Locator, animated: boolean, cb: cbb): void;
+    /**
+     * Moves to the position in the publication targeted by the given link.
+     */
+    abstract goLink(link: Link, animated: boolean, cb: cbb): void;
+    /**
+     * Moves to the next content portion (eg. page) in the reading progression direction.
+     */
+    abstract goForward(animated: boolean, cb: cbb): void;
+    /**
+     * Moves to the previous content portion (eg. page) in the reading progression direction.
+     */
+    abstract goBackward(animated: boolean, cb: cbb): void;
+    /**
+     * Destroy all resources associated with this navigator. Synonymous with "unmount"
+     */
+    abstract destroy(): void;
+}
+export declare abstract class VisualNavigator extends Navigator {
+    /**
+     * Current reading progression direction.
+     */
+    abstract get readingProgression(): ReadingProgression;
+    /**
+     * Moves to the left content portion (eg. page) relative to the reading progression direction.
+     */
+    goLeft(animated: boolean | undefined, completion: cbb): void;
+    /**
+     * Moves to the right content portion (eg. page) relative to the reading progression direction.
+     */
+    goRight(animated: boolean | undefined, completion: cbb): void;
+}
+export {};

package/types/src/audio/engine/AudioEngine.d.ts

@@ -0,0 +1,114 @@
+import { Locator } from '@readium/shared';
+import { Publication } from '@readium/shared';
+/**
+ * Initial state of the audio engine playback.
+ */
+export interface PlaybackState {
+    /**
+     * The current time of the audio resource.
+     */
+    currentTime: number;
+    /**
+     * The duration of the audio resource.
+     */
+    duration: number;
+    /**
+     * The volume of the audio resource.
+     */
+    volume: number;
+}
+/**
+ * Playback interface for an audio engine state
+ * @state The initial [PlaybackState].
+ * @playWhenReady Indicates if the navigator should play as soon as the state is Ready.
+ * @index Index of the reading order item currently being played.
+ * @offset Position of the playback in the current item.
+ * @buffered Position in the current item until which the content is buffered.
+ *
+ */
+export interface Playback {
+    state: PlaybackState;
+    playWhenReady: boolean;
+    index: number;
+    offset?: number;
+    buffered?: number;
+}
+/**
+ * An audio engine that plays audio resources from a publication.
+ * @playback - The current [Playback] state.
+*/
+export interface AudioEngine {
+    /**
+     * The current playback state.
+     */
+    playback: Playback;
+    /**
+     * Plays the audio resource at the given locator.
+     */
+    playLocator(publication: Publication, locator: Locator): Promise<void>;
+    /**
+     * Adds an event listener to the audio engine.
+     * @param event The event name to listen.
+     * @param callback Callback function to be called when the event is triggered.
+     */
+    on(event: string, callback: (data: any) => void): void;
+    /**
+     * Removes an event listener from the audio engine.
+     * @param event The event name to remove the listener.
+     * @param callback Callback function to be removed.
+     */
+    off(event: string, callback: (data: any) => void): void;
+    /**
+     * Loads the audio resource at the given URL.
+     * @param url The URL of the audio resource.
+     */
+    loadAudio(url: string): void;
+    /**
+     * Plays the current audio resource.
+     */
+    play(): void;
+    /**
+     * Pauses the currently playing audio resource.
+     */
+    pause(): void;
+    /**
+     * Stops the currently playing audio resource.
+     */
+    stop(): void;
+    /**
+     * Skips [duration] either forward or backward if [duration] is negative.
+     */
+    skip(duration: number): void;
+    /**
+     * Returns the duration of the audio resource.
+     */
+    duration(): number;
+    /**
+     * Returns whether the audio resource is currently playing.
+     */
+    isPlaying(): boolean;
+    /**
+     * Returns whether the audio resource is currently paused.
+     */
+    isPaused(): boolean;
+    /**
+     * Returns whether the audio resource is currently stopped.
+     */
+    isStopped(): boolean;
+    /**
+     * Returns whether the audio resource is currently loading.
+     */
+    isLoading(): boolean;
+    /**
+     * Returns whether the audio resource is currently loaded.
+     */
+    isLoaded(): boolean;
+    /**
+     * Returns whether the audio resource is currently ended.
+     */
+    isEnded(): boolean;
+    /**
+     * Returns whether the audio resource is currently muted.
+     */
+    isMuted(): boolean;
+}

package/types/src/audio/engine/WebAudioEngine.d.ts

@@ -0,0 +1,107 @@
+import { AudioEngine, Playback } from "./AudioEngine";
+import { Publication } from "@readium/shared";
+import { Locator } from "@readium/shared";
+type EventCallback = (data: any) => void;
+export declare class WebAudioEngine implements AudioEngine {
+    readonly playback: Playback;
+    private audioContext;
+    private mediaElement;
+    private sourceNode;
+    private gainNode;
+    private listeners;
+    private isMutedValue;
+    private isPlayingValue;
+    private isPausedValue;
+    private isLoadingValue;
+    private isLoadedValue;
+    private isEndedValue;
+    constructor(values: {
+        playback: Playback;
+        audioContext: AudioContext;
+    });
+    /**
+     * Adds an event listener to the audio engine.
+     * @param event - event name to be listened.
+     * @param callback - callback function to be called when the event is triggered.
+     */
+    on(event: string, callback: EventCallback): void;
+    /**
+     * Removes an event listener from the audio engine.
+     * @param event - event name to be removed from the listeners.
+     * @param callback - callback function to be removed.
+     */
+    off(event: string, callback: EventCallback): void;
+    /**
+     * Load the audio resource at the given URL.
+     * @param url The URL of the audio resource.
+     * */
+    loadAudio(url: string): void;
+    private ensureAudioContextRunning;
+    private onTimeUpdate;
+    private onCanPlayThrough;
+    private onError;
+    private onEnded;
+    private emit;
+    /**
+     * Plays the audio resource at the given locator.
+     */
+    playLocator(_publication: Publication, _locator: Locator): Promise<void>;
+    /**
+     * Plays the current audio resource.
+     */
+    play(): Promise<void>;
+    /**
+     * Pauses the currently playing audio resource.
+     */
+    pause(): void;
+    /**
+     * Stops the currently playing audio resource.
+     */
+    stop(): void;
+    /**
+     * Adjusts the [volume] of the audio resource.
+     * @volume The volume to set, in the range [0, 1].
+     */
+    setVolume(volume: number): void;
+    /**
+     * Skips [seconds] either forward or backward if [seconds] is negative.
+     */
+    skip(seconds: number): void;
+    /**
+     * Returns de current time in the audio resource.
+     */
+    currentTime(): number;
+    /**
+     * Returns the duration in seconds of the current media element resource.
+     */
+    duration(): number;
+    /**
+     * Returns whether the audio resource is currently playing.
+     */
+    isPlaying(): boolean;
+    /**
+     * Returns whether the audio resource is currently paused.
+     */
+    isPaused(): boolean;
+    /**
+     * Returns whether the audio resource is currently stopped.
+     */
+    isStopped(): boolean;
+    /**
+     * Returns whether the audio resource is currently loading.
+     */
+    isLoading(): boolean;
+    /**
+     * Returns whether the audio resource is currently loaded.
+     */
+    isLoaded(): boolean;
+    /**
+     * Returns whether the audio resource is currently ended.
+     */
+    isEnded(): boolean;
+    /**
+     * Returns whether the audio resource is currently muted.
+     */
+    isMuted(): boolean;
+}
+export {};

package/types/src/audio/engine/index.d.ts

@@ -0,0 +1,2 @@
+export * from './AudioEngine';
+export * from './WebAudioEngine';

package/types/src/audio/index.d.ts

@@ -0,0 +1 @@
+export * from './engine';

package/types/src/epub/EpubNavigator.d.ts

@@ -0,0 +1,66 @@
+import { EPUBLayout, Link, Locator, Publication, ReadingProgression } from "@readium/shared";
+import { VisualNavigator } from "../";
+import { FramePoolManager } from "./frame/FramePoolManager";
+import { FXLFramePoolManager } from "./fxl/FXLFramePoolManager";
+import { CommsEventKey } from "@readium/navigator-html-injectables";
+import { BasicTextSelection, FrameClickEvent } from "@readium/navigator-html-injectables";
+import { FXLFrameManager } from "./fxl/FXLFrameManager";
+import { FrameManager } from "./frame/FrameManager";
+export type ManagerEventKey = "zoom";
+export interface EpubNavigatorListeners {
+    frameLoaded: (wnd: Window) => void;
+    positionChanged: (locator: Locator) => void;
+    tap: (e: FrameClickEvent) => boolean;
+    click: (e: FrameClickEvent) => boolean;
+    zoom: (scale: number) => void;
+    miscPointer: (amount: number) => void;
+    customEvent: (key: string, data: unknown) => void;
+    handleLocator: (locator: Locator) => boolean;
+    textSelected: (selection: BasicTextSelection) => void;
+}
+export declare class EpubNavigator extends VisualNavigator {
+    private readonly pub;
+    private readonly container;
+    private readonly listeners;
+    private framePool;
+    private positions;
+    private currentLocation;
+    private currentProgression;
+    readonly layout: EPUBLayout;
+    constructor(container: HTMLElement, pub: Publication, listeners: EpubNavigatorListeners, positions?: Locator[], initialPosition?: Locator | undefined);
+    static determineLayout(pub: Publication): EPUBLayout;
+    load(): Promise<void>;
+    /**
+     * Exposed to the public to compensate for lack of implemented readium conveniences
+     * TODO remove when settings management is incorporated
+     */
+    get _cframes(): (FXLFrameManager | FrameManager | undefined)[];
+    /**
+     * Exposed to the public to compensate for lack of implemented readium conveniences
+     * TODO remove when settings management is incorporated
+     */
+    get pool(): FramePoolManager | FXLFramePoolManager;
+    /**
+     * Left intentionally public so you can pass in your own events here
+     * to trigger the navigator when user's mouse/keyboard focus is
+     * outside the readium-controller navigator. Be careful!
+     */
+    eventListener(key: CommsEventKey | ManagerEventKey, data: unknown): void;
+    private determineModules;
+    private attachListener;
+    private apply;
+    destroy(): Promise<void>;
+    private changeResource;
+    private findNearestPosition;
+    private syncLocation;
+    goBackward(_: boolean, cb: (ok: boolean) => void): void;
+    goForward(_: boolean, cb: (ok: boolean) => void): void;
+    get currentLocator(): Locator;
+    get currentPositionNumbers(): number[];
+    get readingProgression(): ReadingProgression;
+    setReadingProgression(newProgression: ReadingProgression): Promise<void>;
+    get publication(): Publication;
+    private loadLocator;
+    go(locator: Locator, _: boolean, cb: (ok: boolean) => void): void;
+    goLink(link: Link, animated: boolean, cb: (ok: boolean) => void): void;
+}

package/types/src/epub/frame/FrameBlobBuilder.d.ts

@@ -0,0 +1,13 @@
+import { Link, Publication } from "@readium/shared";
+export default class FrameBlobBuider {
+    private readonly item;
+    private readonly burl;
+    private readonly pub;
+    constructor(pub: Publication, baseURL: string, item: Link);
+    build(fxl?: boolean): Promise<string>;
+    private buildHtmlFrame;
+    private buildImageFrame;
+    private hasExecutable;
+    private hasStyle;
+    private finalizeDOM;
+}

package/types/src/epub/frame/FrameComms.d.ts

@@ -0,0 +1,26 @@
+import { CommsCommandKey, CommsAck, CommsEventKey } from "@readium/navigator-html-injectables";
+import { ManagerEventKey } from "../EpubNavigator";
+export type FrameCommsListener = (key: CommsEventKey | ManagerEventKey, value: unknown) => void;
+export declare class FrameComms {
+    private readonly wnd;
+    private readonly registry;
+    private readonly gc;
+    private readonly origin;
+    readonly channelId: string;
+    private _ready;
+    private _listener;
+    private listenerBuffer;
+    set listener(listener: FrameCommsListener);
+    clearListener(): void;
+    constructor(wnd: Window, origin: string);
+    halt(): void;
+    resume(): void;
+    private handle;
+    private handler;
+    get ready(): boolean;
+    /**
+     * Send a message to the window using postMessage-based comms communication
+     * @returns Identifier associated with the message
+     */
+    send(key: CommsCommandKey, data: unknown, callback?: CommsAck, strict?: boolean, transfer?: Transferable[]): string;
+}

package/types/src/epub/frame/FrameManager.d.ts

@@ -0,0 +1,21 @@
+import { Loader, ModuleName } from "@readium/navigator-html-injectables";
+import { FrameComms } from "./FrameComms";
+export declare class FrameManager {
+    private frame;
+    private loader;
+    readonly source: string;
+    private comms;
+    private currModules;
+    constructor(source: string);
+    load(modules: ModuleName[]): Promise<Window>;
+    destroy(): Promise<void>;
+    hide(): Promise<void>;
+    show(atProgress?: number): Promise<void>;
+    get iframe(): HTMLIFrameElement;
+    get realSize(): DOMRect;
+    get window(): Window;
+    get atLeft(): boolean;
+    get atRight(): boolean;
+    get msg(): FrameComms | undefined;
+    get ldr(): Loader<ModuleName> | undefined;
+}

package/types/src/epub/frame/FramePoolManager.d.ts

@@ -0,0 +1,17 @@
+import { ModuleName } from "@readium/navigator-html-injectables";
+import { Locator, Publication } from "@readium/shared";
+import { FrameManager } from "./FrameManager";
+export declare class FramePoolManager {
+    private readonly container;
+    private readonly positions;
+    private _currentFrame;
+    private readonly pool;
+    private readonly blobs;
+    private readonly inprogress;
+    private currentBaseURL;
+    constructor(container: HTMLElement, positions: Locator[]);
+    destroy(): Promise<void>;
+    update(pub: Publication, locator: Locator, modules: ModuleName[], force?: boolean): Promise<void>;
+    get currentFrames(): (FrameManager | undefined)[];
+    get currentBounds(): DOMRect;
+}

package/types/src/epub/frame/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./FrameComms";
+export * from "./FrameManager";
+export * from "./FramePoolManager";