@readium/navigator 1.2.0

package/types/src/epub/fxl/FXLCoordinator.d.ts

@@ -0,0 +1,37 @@
+export interface Point {
+    X: number;
+    Y: number;
+}
+export declare enum HorizontalThird {
+    Left = 0,
+    Center = 1,
+    Right = 2
+}
+export declare enum VerticalThird {
+    Top = 0,
+    Middle = 1,
+    Bottom = 2
+}
+export interface NinthPoint {
+    X: HorizontalThird | null;
+    Y: VerticalThird | null;
+}
+export interface BibiEvent {
+    Target: EventTarget | null;
+    Coord: Point | null;
+    Ratio: Point | null;
+    Division: NinthPoint | null;
+}
+export declare class FXLCoordinator {
+    HTML: HTMLElement;
+    Head: HTMLHeadElement;
+    Body: HTMLElement;
+    constructor();
+    private outerWidth;
+    private outerHeight;
+    refreshOuterPixels(_: DOMRect): void;
+    getBibiEventCoord(Eve: TouchEvent | MouseEvent, touch?: number): Point;
+    getTouchDistance(Eve: TouchEvent): number;
+    getTouchCenter(Eve: TouchEvent): Point | null;
+    getBibiEvent(Eve: Event): BibiEvent;
+}

package/types/src/epub/fxl/FXLFrameManager.d.ts

@@ -0,0 +1,41 @@
+import { Loader, ModuleName } from "@readium/navigator-html-injectables";
+import { Page, ReadingProgression } from "@readium/shared";
+import { FrameComms } from "../frame/FrameComms";
+import { FXLPeripherals } from "./FXLPeripherals";
+export declare class FXLFrameManager {
+    private frame;
+    private loader;
+    source: string;
+    private comms;
+    private readonly peripherals;
+    private currModules;
+    wrapper: HTMLDivElement;
+    debugHref: string;
+    private loadPromise;
+    private showPromise;
+    constructor(peripherals: FXLPeripherals, direction: ReadingProgression, debugHref: string);
+    load(modules: ModuleName[], source: string): Promise<Window>;
+    loadPageSize(): {
+        width: number;
+        height: number;
+    };
+    update(page?: Page): void;
+    destroy(): Promise<void>;
+    unload(): Promise<void>;
+    deselect(): void;
+    unfocus(): Promise<void>;
+    private cachedPage;
+    show(page: Page): Promise<void>;
+    activate(): Promise<void>;
+    get element(): HTMLDivElement;
+    get iframe(): HTMLIFrameElement;
+    get realSize(): DOMRect;
+    get loaded(): boolean | null;
+    set width(width: number);
+    set height(height: number);
+    get window(): Window;
+    get atLeft(): boolean;
+    get atRight(): boolean;
+    get msg(): FrameComms | undefined;
+    get ldr(): Loader<ModuleName> | undefined;
+}

package/types/src/epub/fxl/FXLFramePoolManager.d.ts

@@ -0,0 +1,93 @@
+import { ModuleName } from "@readium/navigator-html-injectables";
+import { Locator, Publication, Page, Link } from "@readium/shared";
+import { FrameCommsListener } from "../frame";
+import { FXLFrameManager } from "./FXLFrameManager";
+import { FXLPeripherals } from "./FXLPeripherals";
+export declare class FXLFramePoolManager {
+    private readonly container;
+    private readonly positions;
+    private readonly pool;
+    private readonly blobs;
+    private readonly inprogress;
+    private readonly delayedShow;
+    private readonly delayedTimeout;
+    private currentBaseURL;
+    private previousFrames;
+    private readonly bookElement;
+    readonly spineElement: HTMLDivElement;
+    private readonly pub;
+    width: number;
+    height: number;
+    private transform;
+    currentSlide: number;
+    private spreader;
+    private spread;
+    private readonly spreadPresentation;
+    private orientationInternal;
+    private containerHeightCached;
+    private readonly resizeBoundHandler;
+    private resizeTimeout;
+    readonly peripherals: FXLPeripherals;
+    constructor(container: HTMLElement, positions: Locator[], pub: Publication);
+    private _listener;
+    set listener(listener: FrameCommsListener);
+    get listener(): FrameCommsListener;
+    get doNotDisturb(): boolean;
+    private nativeResizeHandler;
+    /**
+     * When window resizes, resize slider components as well
+     */
+    resizeHandler(slide?: boolean, fast?: boolean): void;
+    /**
+     * It is important that these values be cached to avoid spamming them on redraws, they are expensive.
+     */
+    private updateDimensions;
+    get rtl(): boolean;
+    private get single();
+    get perPage(): 1 | 2;
+    get threshold(): number;
+    get portrait(): boolean;
+    updateSpineStyle(animate: boolean, fast?: boolean): void;
+    updateBookStyle(initial?: boolean): void;
+    /**
+     * Go to slide with particular index
+     * @param {number} index - Item index to slide to.
+     */
+    goTo(index: number): void;
+    onChange(): void;
+    private get offset();
+    get length(): number;
+    get slength(): number;
+    get shift(): boolean;
+    private get nLandscape();
+    setPerPage(perPage: number): void;
+    /**
+     * Moves sliders frame to position of currently active slide
+     */
+    slideToCurrent(enableTransition?: boolean, fast?: boolean): void;
+    bounce(rtl?: boolean): void;
+    /**
+     * Go to next slide.
+     * @param {number} [howManySlides=1] - How many items to slide forward.
+     * @returns {boolean} Whether or not going to next was possible
+     */
+    next(howManySlides?: number): boolean;
+    /**
+     * Go to previous slide.
+     * @param {number} [howManySlides=1] - How many items to slide backward.
+     * @returns {boolean} Whether or not going to prev was possible
+     */
+    prev(howManySlides?: number): boolean;
+    get ownerWindow(): Window & typeof globalThis;
+    destroy(): Promise<void>;
+    makeSpread(itemIndex: number): Link[];
+    reAlign(index?: number): number;
+    spreadPosition(spread: Link[], target: Link): Page;
+    waitForItem(href: string): Promise<void>;
+    cancelShowing(href: string): Promise<void>;
+    update(pub: Publication, locator: Locator, modules: ModuleName[], _force?: boolean): Promise<void>;
+    get currentFrames(): (FXLFrameManager | undefined)[];
+    get currentBounds(): DOMRect;
+    get currentNumbers(): number[];
+    deselect(): void;
+}

package/types/src/epub/fxl/FXLPeripherals.d.ts

@@ -0,0 +1,97 @@
+import { Point } from "./FXLCoordinator";
+import { FXLFramePoolManager } from "./FXLFramePoolManager";
+export interface PanTracker {
+    startX: number;
+    endX: number;
+    overscrollX: number;
+    overscrollY: number;
+    startY: number;
+    letItGo: boolean;
+    preventClick: boolean;
+    translateX: number;
+    translateY: number;
+    touchID: number;
+}
+export interface PinchTracker {
+    startDistance: number;
+    startScale: number;
+    target: Point;
+    startTranslate: Point;
+    touchN: number;
+}
+export interface Zoomer {
+    scale: number;
+    translate: {
+        X: number;
+        Y: number;
+    };
+}
+export declare class FXLPeripherals {
+    private readonly manager;
+    private readonly coordinator;
+    dragState: number;
+    private minimumMoved;
+    pan: PanTracker;
+    private pinch;
+    private _scale;
+    get scale(): number;
+    private scaleDebouncer;
+    set scale(value: number);
+    private frameBounds;
+    private debugger;
+    constructor(manager: FXLFramePoolManager, debug?: boolean);
+    private readonly btouchstartHandler;
+    private readonly btouchendHandler;
+    private readonly btouchmoveHandler;
+    private readonly bdblclickHandler;
+    private readonly bmousedownHandler;
+    private readonly bmouseupHandler;
+    private readonly bmousemoveHandler;
+    /**
+     * Attaches listeners to required events.
+     */
+    attachEvents(): void;
+    /**
+     * Clear drag after touchend and mouseup event
+     */
+    private clearPan;
+    clearPinch(): void;
+    observe(item: EventTarget): void;
+    clickHandler(_: MouseEvent): void;
+    /**
+     * touchstart event handler
+     */
+    touchstartHandler(e: TouchEvent): void;
+    private startTouch;
+    /**
+     * touchend event handler
+     */
+    touchendHandler(e: TouchEvent): void;
+    private moveFrame;
+    /**
+     * touchmove event handler
+     */
+    touchmoveHandler(e: TouchEvent): void;
+    private dtimer;
+    private pdblclick;
+    private disableDblClick;
+    dblclickHandler(_: MouseEvent): void;
+    get isScaled(): boolean;
+    private addTouch;
+    /**
+     * mousedown event handler
+     */
+    mousedownHandler(e: MouseEvent): void;
+    /**
+     * mouseup event handler
+     */
+    mouseupHandler(e: MouseEvent): void;
+    /**
+     * mousemove event handler
+     */
+    mousemoveHandler(e: MouseEvent): void;
+    /**
+     * Recalculate drag/swipe event and reposition the frame of a slider
+     */
+    private updateAfterDrag;
+}

package/types/src/epub/fxl/FXLPeripheralsDebug.d.ts

@@ -0,0 +1,13 @@
+export declare class FXLPeripheralsDebug {
+    private readonly _DOM;
+    get show(): boolean;
+    get DOM(): {
+        show: boolean;
+        pinchTarget: HTMLDivElement;
+        touch1: HTMLDivElement;
+        touch2: HTMLDivElement;
+        center: HTMLDivElement;
+        stats: HTMLDivElement;
+    };
+    constructor();
+}

package/types/src/epub/fxl/FXLSpreader.d.ts

@@ -0,0 +1,12 @@
+import { Link, Publication } from "@readium/shared";
+export declare class FXLSpreader {
+    shift: boolean;
+    private spreads;
+    nLandscape: number;
+    constructor(publication: Publication);
+    private index;
+    private testShift;
+    private buildSpreads;
+    currentSpread(currentSlide: number, perPage: number): Link[];
+    findByLink(link: Link): Link[] | undefined;
+}

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

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

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

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

package/types/src/helpers/sML.d.ts

@@ -0,0 +1,51 @@
+/*!
+ *                                                                                                                         (℠)
+ *  # 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[];
+}
+declare class sML {
+    OS: OSFlags;
+    UA: UAFlags;
+    Env: string[];
+    constructor();
+}
+declare const _default: sML;
+export default _default;

package/types/src/index.d.ts

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