@d-i-t-a/reader 2.1.0-alpha.2 → 2.1.0-beta.2

package/dist/{modules → types/modules}/mediaoverlays/MediaOverlayModule.d.ts

@@ -1,6 +1,6 @@
 import { Publication } from "../../model/Publication";
-import IFrameNavigator from "../../navigator/IFrameNavigator";
-import ReaderModule from "../ReaderModule";
+import { IFrameNavigator } from "../../navigator/IFrameNavigator";
+import { ReaderModule } from "../ReaderModule";
 import { Link } from "../../model/Link";
 import { MediaOverlayNode } from "r2-shared-js/dist/es6-es2015/src/models/media-overlay";
 import { MediaOverlaySettings } from "./MediaOverlaySettings";
@@ -17,46 +17,49 @@ export interface MediaOverlayModuleProperties {
     autoScroll?: boolean;
     autoTurn?: boolean;
     volume?: number;
+    rate?: number;
     wait?: number;
+    hideLayer?: boolean;
 }
 export interface MediaOverlayModuleConfig extends MediaOverlayModuleProperties {
     publication: Publication;
     delegate: IFrameNavigator;
-    api: MediaOverlayModuleAPI;
     settings: MediaOverlaySettings;
+    api?: MediaOverlayModuleAPI;
 }
-export default class MediaOverlayModule implements ReaderModule {
+export declare class MediaOverlayModule implements ReaderModule {
     private publication;
     private delegate;
     private audioElement;
-    private settings;
+    settings: MediaOverlaySettings;
+    private properties;
     private play;
     private pause;
     private currentAudioBegin;
     private currentAudioEnd;
     private currentLinks;
     private currentLinkIndex;
-    private mediaOverlaysPlaybackRate;
     private currentAudioUrl;
     private previousAudioUrl;
     private previousAudioEnd;
     private mediaOverlayRoot;
     private mediaOverlayTextAudioPair;
     private pid;
-    static create(config: MediaOverlayModuleConfig): Promise<MediaOverlayModule>;
+    private __ontimeupdate;
+    static create(config: MediaOverlayModuleConfig): MediaOverlayModule;
     private constructor();
-    stop(): Promise<void>;
-    protected start(): Promise<void>;
+    stop(): void;
+    protected start(): void;
     initialize(): Promise<void>;
-    initializeResource(links: Array<Link>): Promise<void>;
+    initializeResource(links: Array<Link | undefined>): Promise<void>;
     private playLink;
     startReadAloud(): Promise<void>;
-    stopReadAloud(): void;
+    stopReadAloud(): Promise<void>;
     pauseReadAloud(): void;
     resumeReadAloud(): Promise<void>;
     findDepthFirstTextAudioPair(textHref: string, mo: MediaOverlayNode, textFragmentIDChain: Array<string | null> | undefined): MediaOverlayNode | undefined | null;
-    ontimeupdate: (ev: Event) => Promise<void>;
-    ensureOnTimeUpdate: (remove: boolean) => void;
+    myReq: any;
+    trackCurrentTime(): void;
     mediaOverlaysNext(escape?: boolean): void;
     mediaOverlaysStop(): void;
     mediaOverlaysPause(): void;
@@ -65,5 +68,7 @@ export default class MediaOverlayModule implements ReaderModule {
     }, escape: boolean): MediaOverlayNode | undefined | null;
     playMediaOverlaysAudio(moTextAudioPair: MediaOverlayNode, begin: number | undefined, end: number | undefined): Promise<void>;
     playMediaOverlays(textHref: string, rootMo: MediaOverlayNode, textFragmentIDChain: Array<string | null> | undefined): Promise<void>;
-    mediaOverlayHighlight(href: string | undefined, id: string | undefined): void;
+    ontimeupdate: (_v: Event) => Promise<void>;
+    ensureOnTimeUpdate: (remove: boolean, replace: boolean) => void;
+    mediaOverlayHighlight(id: string | undefined): void;
 }

package/dist/{modules → types/modules}/mediaoverlays/MediaOverlaySettings.d.ts

@@ -7,25 +7,29 @@ export declare class MEDIAOVERLAYREFS {
     static readonly AUTO_SCROLL_REF = "autoscroll";
     static readonly AUTO_TURN_REF = "autoturn";
     static readonly VOLUME_REF = "volume";
+    static readonly RATE_REF = "rate";
     static readonly COLOR_KEY: string;
     static readonly AUTO_SCROLL_KEY: string;
     static readonly AUTO_TURN_KEY: string;
     static readonly VOLUME_KEY: string;
+    static readonly RATE_KEY: string;
 }
 export interface MediaOverlayConfig {
     store: Store;
-    initialMediaOverlaySettings: MediaOverlayModuleProperties;
-    headerMenu: HTMLElement;
-    api: MediaOverlayModuleAPI;
+    initialMediaOverlaySettings?: MediaOverlayModuleProperties;
+    headerMenu?: HTMLElement | null;
+    api?: MediaOverlayModuleAPI;
 }
 export interface IMediaOverlayUserSettings {
     color?: string;
     autoScroll?: boolean;
     autoTurn?: boolean;
     volume?: number;
+    rate?: number;
     playing?: boolean;
     wait?: number;
 }
+export declare type MediaOverlayIncrementable = "mo_volume" | "mo_rate";
 export declare class MediaOverlaySettings implements IMediaOverlayUserSettings {
     private readonly store;
     private readonly MEDIAOVERLAYSETTINGS;
@@ -33,35 +37,36 @@ export declare class MediaOverlaySettings implements IMediaOverlayUserSettings {
     autoScroll: boolean;
     autoTurn: boolean;
     volume: number;
+    rate: number;
     playing: boolean;
+    resourceReady: boolean;
     wait: number;
     userProperties: UserProperties;
     private settingsChangeCallback;
     private settingsView;
-    private readonly headerMenu;
-    private volumeButtons;
+    private readonly headerMenu?;
     private speechAutoScroll;
     private speechAutoTurn;
     private speechVolume;
-    private readonly api;
-    static create(config: MediaOverlayConfig): Promise<any>;
-    protected constructor(store: Store, headerMenu: HTMLElement, api: MediaOverlayModuleAPI);
-    stop(): Promise<void>;
+    private speechRate;
+    private readonly api?;
+    static create(config: MediaOverlayConfig): any;
+    protected constructor(store: Store, api?: MediaOverlayModuleAPI, headerMenu?: HTMLElement | null);
+    stop(): void;
     private initialise;
     private reset;
     private initializeSelections;
     setControls(): void;
     private renderControls;
     onSettingsChange(callback: () => void): void;
-    private setupEvents;
     private storeProperty;
     private updateUserSettings;
     private getMediaOverlaySettings;
     private saveProperty;
-    getProperty(name: string): Promise<UserProperty>;
-    resetMediaOverlaySettings(): Promise<void>;
-    applyMediaOverlaySettings(mediaOverlaySettings: IMediaOverlayUserSettings): Promise<void>;
-    applyMediaOverlaySetting(key: any, value: any): Promise<void>;
-    increase(incremental: string): Promise<void>;
-    decrease(incremental: string): Promise<void>;
+    getProperty(name: string): UserProperty | null;
+    resetMediaOverlaySettings(): void;
+    applyMediaOverlaySettings(mediaOverlaySettings: IMediaOverlayUserSettings): void;
+    applyMediaOverlaySetting(key: any, value: any): void;
+    increase(incremental: MediaOverlayIncrementable): void;
+    decrease(incremental: MediaOverlayIncrementable): void;
 }

package/dist/types/modules/pagebreak/PageBreakModule.d.ts

@@ -0,0 +1,30 @@
+import { IFrameNavigator } from "../../navigator/IFrameNavigator";
+import { ReaderModule } from "../ReaderModule";
+import { IHighlight } from "../highlight/common/highlight";
+import { ISelectionInfo } from "../highlight/common/selection";
+import { Publication } from "../../model/Publication";
+export interface PageBreakModuleProperties {
+    hideLayer?: boolean;
+}
+export interface PageBreakModuleConfig extends PageBreakModuleProperties {
+    delegate: IFrameNavigator;
+    headerMenu?: HTMLElement | null;
+    publication: Publication;
+}
+export declare class PageBreakModule implements ReaderModule {
+    private delegate;
+    private readonly headerMenu?;
+    private publication;
+    private properties;
+    private goToPageView;
+    private goToPageNumberInput;
+    private goToPageNumberButton;
+    static create(config: PageBreakModuleConfig): Promise<PageBreakModule>;
+    private constructor();
+    stop(): Promise<void>;
+    protected start(): Promise<void>;
+    private goToPageNumber;
+    handleResize(): Promise<void>;
+    drawPageBreaks(): Promise<void>;
+    createPageBreakHighlight(selectionInfo: ISelectionInfo, title: string): IHighlight;
+}

package/dist/{modules → types/modules}/positions/TimelineModule.d.ts

@@ -1,11 +1,11 @@
 import { Publication } from "../../model/Publication";
-import IFrameNavigator from "../../navigator/IFrameNavigator";
-import ReaderModule from "../ReaderModule";
+import { IFrameNavigator } from "../../navigator/IFrameNavigator";
+import { ReaderModule } from "../ReaderModule";
 export interface TimelineModuleConfig {
     publication: Publication;
     delegate: IFrameNavigator;
 }
-export default class TimelineModule implements ReaderModule {
+export declare class TimelineModule implements ReaderModule {
     private publication;
     private delegate;
     private timelineContainer;

package/dist/{modules → types/modules}/protection/ContentProtectionModule.d.ts

@@ -1,5 +1,5 @@
-import ReaderModule from "../ReaderModule";
-import IFrameNavigator from "../../navigator/IFrameNavigator";
+import { ReaderModule } from "../ReaderModule";
+import { IFrameNavigator } from "../../navigator/IFrameNavigator";
 export interface ContentProtectionModuleProperties {
     enforceSupportedBrowsers: boolean;
     enableEncryption: boolean;
@@ -8,18 +8,19 @@ export interface ContentProtectionModuleProperties {
     disableCopy: boolean;
     detectInspect: boolean;
     clearOnInspect: boolean;
+    detectInspectInitDelay: number;
     disableKeys: boolean;
     disableContextMenu: boolean;
     hideTargetUrl: boolean;
     disableDrag: boolean;
     supportedBrowsers: [];
 }
-export interface ContentProtectionModuleConfig extends ContentProtectionModuleProperties {
+export interface ContentProtectionModuleConfig extends Partial<ContentProtectionModuleProperties> {
     delegate: IFrameNavigator;
-    api: ContentProtectionModuleAPI;
+    api?: ContentProtectionModuleAPI;
 }
 export interface ContentProtectionModuleAPI {
-    inspectDetected: any;
+    inspectDetected: () => void;
 }
 interface ContentProtectionRect {
     node: Element;
@@ -31,17 +32,20 @@ interface ContentProtectionRect {
     scrambledTextContent: string;
     isObfuscated: boolean;
 }
-export default class ContentProtectionModule implements ReaderModule {
+export declare class ContentProtectionModule implements ReaderModule {
     private rects;
     private delegate;
-    private properties;
-    private api;
+    private properties?;
     private hasEventListener;
     private isHacked;
     private securityContainer;
     private mutationObserver;
+    private wrapper;
+    static setupPreloadProtection(config: ContentProtectionModuleConfig): Promise<void>;
     static create(config: ContentProtectionModuleConfig): Promise<ContentProtectionModule>;
-    constructor(delegate: IFrameNavigator, properties?: ContentProtectionModuleProperties | null, api?: ContentProtectionModuleAPI | null);
+    constructor(delegate: IFrameNavigator, properties?: ContentProtectionModuleProperties);
+    private static startInspectorProtection;
+    private static isCurrentBrowserSupported;
     protected start(): Promise<void>;
     stop(): Promise<void>;
     observe(): any;
@@ -81,7 +85,7 @@ export default class ContentProtectionModule implements ReaderModule {
     }): boolean;
     hideTargetUrls(activate: any): void;
     preventDrag(activate: any): void;
-    recalculate(delay?: number): void;
+    recalculate(delay?: number): Promise<boolean>;
     calcRects(rects: Array<ContentProtectionRect>): void;
     deactivateRect(rect: ContentProtectionRect, securityContainer: HTMLElement, isHacked: boolean): void;
     toggleRect(rect: ContentProtectionRect, securityContainer: HTMLElement, isHacked: boolean): void;

package/dist/types/modules/sampleread/SampleReadEventHandler.d.ts

@@ -0,0 +1,8 @@
+import { IFrameNavigator } from "../../navigator/IFrameNavigator";
+export default class SampleReadEventHandler {
+    delegate: IFrameNavigator;
+    constructor(delegate: IFrameNavigator);
+    enforceSampleRead: ((position: any) => void) & {
+        clear(): void;
+    };
+}

package/dist/types/modules/search/DefinitionsModule.d.ts

@@ -0,0 +1,52 @@
+import { IFrameNavigator } from "../../navigator/IFrameNavigator";
+import { ReaderModule } from "../ReaderModule";
+import { TextHighlighter } from "../highlight/TextHighlighter";
+import { IHighlight } from "../highlight/common/highlight";
+import { ISelectionInfo } from "../highlight/common/selection";
+import { Publication } from "../../model/Publication";
+export interface DefinitionsModuleAPI {
+    success: any;
+    click: any;
+    visible: any;
+}
+export interface Definition {
+    order: number;
+    terms: [string];
+    result?: number;
+    definition?: string;
+}
+export interface DefinitionsModuleProperties {
+    definitions?: Definition[];
+    color?: string;
+    fullWordSearch?: boolean;
+    hideLayer?: boolean;
+}
+export interface DefinitionsModuleConfig extends DefinitionsModuleProperties {
+    api?: DefinitionsModuleAPI;
+    publication: Publication;
+    delegate: IFrameNavigator;
+    highlighter: TextHighlighter;
+}
+export declare class DefinitionsModule implements ReaderModule {
+    properties: DefinitionsModuleProperties;
+    api?: DefinitionsModuleAPI;
+    private publication;
+    private delegate;
+    private currentChapterPopupResult;
+    private currentPopupHighlights;
+    private highlighter;
+    static create(config: DefinitionsModuleConfig): Promise<DefinitionsModule>;
+    private constructor();
+    stop(): Promise<void>;
+    protected start(): Promise<void>;
+    searchAndPaint(item: Definition, callback: (result: any) => any): Promise<void>;
+    definitions: (() => Promise<void>) & {
+        clear(): void;
+    };
+    define(item: Definition): Promise<void>;
+    drawDefinitions(): Promise<void>;
+    handleResize(): Promise<void>;
+    createDefinitionHighlight(selectionInfo: ISelectionInfo, item: Definition): IHighlight;
+    addDefinition(definition: any): Promise<void>;
+    clearDefinitions(): Promise<void>;
+}

package/dist/types/modules/search/Popup.d.ts

@@ -0,0 +1,10 @@
+import { IFrameNavigator } from "../../navigator/IFrameNavigator";
+export declare class Popup {
+    navigator: IFrameNavigator;
+    constructor(navigator: IFrameNavigator);
+    handleFootnote(link: HTMLLIElement, event: MouseEvent | TouchEvent): Promise<void>;
+    hidePopover(): Promise<void>;
+    showPopover(link: HTMLElement, event: MouseEvent | TouchEvent): Promise<void>;
+    showPopup(element: any, event: MouseEvent | TouchEvent): void;
+    private getScrollingElement;
+}

package/dist/{modules → types/modules}/search/SearchModule.d.ts

@@ -1,43 +1,47 @@
 import { Publication } from "../../model/Publication";
-import IFrameNavigator from "../../navigator/IFrameNavigator";
-import ReaderModule from "../ReaderModule";
-import TextHighlighter from "../highlight/TextHighlighter";
+import { IFrameNavigator } from "../../navigator/IFrameNavigator";
+import { ReaderModule } from "../ReaderModule";
+import { IHighlight } from "../highlight/common/highlight";
+import { ISelectionInfo } from "../highlight/common/selection";
+import { TextHighlighter } from "../highlight/TextHighlighter";
 export interface SearchModuleAPI {
 }
 export interface SearchModuleProperties {
-    color: string;
-    current: string;
+    color?: string;
+    current?: string;
+    hideLayer?: boolean;
 }
 export interface SearchModuleConfig extends SearchModuleProperties {
-    api: SearchModuleAPI;
+    api?: SearchModuleAPI;
     publication: Publication;
-    headerMenu: HTMLElement;
+    headerMenu?: HTMLElement | null;
     delegate: IFrameNavigator;
     highlighter: TextHighlighter;
 }
-export default class SearchModule implements ReaderModule {
+export declare class SearchModule implements ReaderModule {
     private properties;
-    private api;
+    private api?;
     private publication;
-    private readonly headerMenu;
+    private readonly headerMenu?;
     private delegate;
     private searchInput;
     private searchGo;
     private currentChapterSearchResult;
     private bookSearchResult;
-    private currentHighlights;
-    private highlighter;
+    private currentSearchHighlights;
+    private highlighter?;
     static create(config: SearchModuleConfig): Promise<SearchModule>;
     private constructor();
     stop(): Promise<void>;
     protected start(): Promise<void>;
     private handleSearch;
     handleSearchChapter(index?: number): Promise<void>;
-    searchAndPaintChapter(term: string, index: number, callback: (result: any) => any): Promise<void>;
+    searchAndPaintChapter(term: string, index: number | undefined, callback: (result: any) => any): Promise<void>;
+    createSearchHighlight(selectionInfo: ISelectionInfo, color: string): IHighlight;
     clearSearch(): void;
-    search(term: any, current: boolean): Promise<any>;
-    goToSearchID(href: any, index: number, current: boolean): Promise<void>;
-    goToSearchIndex(href: any, index: number, current: boolean): Promise<void>;
+    search(term: string, current: boolean): Promise<any>;
+    goToSearchID(href: string, index: number, current: boolean): Promise<void>;
+    goToSearchIndex(href: string, index: number, current: boolean): Promise<void>;
     private handleSearchBook;
     searchBook(term: string): Promise<any>;
     searchChapter(term: string): Promise<any>;
@@ -47,8 +51,8 @@ export default class SearchModule implements ReaderModule {
     paginate(items: Array<any>, page: number, per_page: number): {
         page: number;
         per_page: number;
-        pre_page: number;
-        next_page: number;
+        pre_page: number | undefined;
+        next_page: number | undefined;
         total: number;
         total_pages: number;
         data: any[];

package/dist/{modules → types/modules}/search/searchWithDomSeek.d.ts

@@ -11,4 +11,4 @@ export interface ISearchResult {
 }
 export declare function escapeRegExp(str: string): string;
 export declare const reset: () => void;
-export declare function searchDocDomSeek(searchInput: string, doc: Document, href: string, title: string): Promise<ISearchResult[]>;
+export declare function searchDocDomSeek(searchInput: string, doc: Document | null, href: string, title: string, fullWordSearch?: boolean): Promise<ISearchResult[]>;