@treinetic/treinetic-epub-reader 2.0.0 → 2.0.2

package/dist/ExternalControls.d.ts

@@ -0,0 +1,40 @@
+export declare class ExternalControls {
+    private static instance;
+    metadata: any;
+    reader: any;
+    channel: any;
+    auto_bookmark: boolean;
+    TocJsonObject: any;
+    currentPackageDocument: any;
+    readerSettings: any;
+    callbackFunctions: {
+        [key: string]: Function;
+    };
+    private constructor();
+    static getInstance(): ExternalControls;
+    static createInstance(): void;
+    epubLoaded(metadata: any, currentPackageDocument: any, reader: any): void;
+    registerEvent(eventName: string, func: Function): void;
+    epubFailed(error: any): void;
+    registerChannel(func: Function): void;
+    onTOCLoad(tocJson: any): void;
+    getReaderHeight(): number | null;
+    nextPage(): void;
+    prevPage(): void;
+    hasNextPage(): boolean;
+    hasPrevPage(): boolean;
+    makeBookMark(): void;
+    setAutoBookmark(val: boolean): void;
+    isAutoBookmark(): boolean;
+    getTOCJson(): string;
+    hasTOC(): boolean;
+    goToPage(href: string): void;
+    changeFontSize(size: number): void;
+    getRecommendedFontSizeRange(): {
+        min: number;
+        max: number;
+    };
+    setTheme(theme_id: string): void;
+    setScrollOption(type: 'auto' | 'scroll-continuous'): void;
+    private cloneUpdate;
+}

package/dist/Keyboard.d.ts

@@ -0,0 +1,14 @@
+export declare const Keyboard: {
+    scope: string;
+    handlers: {
+        [key: string]: Function[];
+    };
+    init: () => void;
+    on: (keyName: string, scope: string, callback: Function) => void;
+    handleKey: (e: KeyboardEvent) => void;
+    dispatch: (action: string) => void;
+    PagePrevious: string;
+    PageNext: string;
+    NightTheme: string;
+    applySettings: (_json: any) => void;
+};

package/dist/ModuleConfig.d.ts

@@ -0,0 +1,14 @@
+export declare const ModuleConfig: {
+    imagePathPrefix: string;
+    epubLibraryPath: string;
+    canHandleUrl: boolean;
+    canHandleDirectory: boolean;
+    epubReadingSystemUrl: string;
+    workerUrl: string;
+    annotationCSSUrl: string;
+    mathJaxUrl: string;
+    jsLibRoot: string;
+    fonts: never[];
+    useSimpleLoader: boolean;
+    loader: null;
+};

package/dist/Settings.d.ts

@@ -0,0 +1,6 @@
+export declare const Settings: {
+    put: (key: string, val: any, callback?: () => void) => void;
+    clear: (key: string, callback?: () => void) => void;
+    get: (key: string, callback?: (val: any) => void) => any;
+    getMultiple: (keys: string[], callback?: (val: any) => void) => any;
+};

package/dist/TOCJsonCreator.d.ts

@@ -0,0 +1,11 @@
+export declare const TOCJsonCreator: {
+    createTOCJson: (tocDom: HTMLElement) => any[];
+    getRootOL: (dom: HTMLElement) => HTMLElement;
+    findRecursively: (ol: HTMLElement) => any[];
+    createTOCItem: (a: HTMLAnchorElement) => {
+        Id_link: string | null;
+        name: string;
+        sub: any[];
+    };
+    getFixedTocElement: (dom: Document | HTMLElement) => HTMLElement;
+};

package/dist/ThemeManager.d.ts

@@ -0,0 +1,20 @@
+export interface ReaderTheme {
+    name: string;
+    properties: {
+        "background-color": string;
+        "color": string;
+        "font-family"?: string;
+        [key: string]: string | undefined;
+    };
+    css?: string;
+}
+export declare class ThemeManager {
+    private static instance;
+    private themes;
+    private constructor();
+    static getInstance(): ThemeManager;
+    registerTheme(theme: ReaderTheme): void;
+    getTheme(name: string): ReaderTheme | undefined;
+    private resolveThemeAlias;
+    private registerDefaultThemes;
+}

package/dist/TreineticEpubReader.d.ts

@@ -0,0 +1,38 @@
+import { ExternalControls } from './ExternalControls';
+import { ReaderView } from './view/ReaderView';
+import { ReaderTheme } from './ThemeManager';
+declare global {
+    interface Window {
+        READIUM: any;
+    }
+}
+declare const TreineticEpubReader: {
+    readium: any;
+    readerView: ReaderView | null;
+    currentPackageDocument: any;
+    ebookURL_filepath: string | null;
+    embeded: boolean;
+    init: (selectorOrElement: string | HTMLElement) => ExternalControls | null;
+    /**
+     * Alias for init() to align with standard library patterns.
+     */
+    create: (selectorOrElement: string | HTMLElement) => ExternalControls | null;
+    open: (epubUrlOrFolder: string) => void;
+    initReader: (element: HTMLElement) => void;
+    handleReaderEvents: () => void;
+    loadEpub: (_readerSettings: any, ebookURL: string, _openPageRequest: any) => Promise<void>;
+    setReaderPreferences: () => {
+        reader: any;
+    };
+    getOpenPageRequest: (_settings: any, _ebookURL: string) => null;
+    savePlace: () => void;
+    nextPage: () => void;
+    prevPage: () => void;
+    goToPage: (href: string) => void;
+    setTheme: (theme: string) => void;
+    registerTheme: (theme: ReaderTheme) => void;
+    setFontSize: (size: number) => void;
+    setScrollOption: (type: "auto" | "scroll-continuous") => void;
+    clearSettings: () => void;
+};
+export default TreineticEpubReader;

package/dist/TreineticHelpers.d.ts

@@ -0,0 +1,19 @@
+export declare const TreineticHelpers: {
+    updateReader: (reader: any, readerSettings: any) => void;
+    getBookStyles: (theme: string) => ({
+        selector: string;
+        declarations: {
+            backgroundColor: string | null | undefined;
+            color: string | null | undefined;
+            fontFamily: string;
+        };
+    } | {
+        selector: string;
+        declarations: {
+            backgroundColor: string | null | undefined;
+            color: string | null | undefined;
+            fontFamily?: undefined;
+        };
+    })[];
+    getPropertyFromThemeClass: (classOrId: string, property: string) => string | null | undefined;
+};

package/dist/model/Metadata.d.ts

@@ -0,0 +1,13 @@
+export declare class Metadata {
+    identifier?: string;
+    title?: string;
+    author?: string;
+    description?: string;
+    publisher?: string;
+    language?: string;
+    rights?: string;
+    modifiedDate?: string;
+    publishedDate?: string;
+    epubVersion?: string;
+    constructor(packageMetadata?: any);
+}

package/dist/model/Package.d.ts

@@ -0,0 +1,21 @@
+import { default as JSZip } from 'jszip';
+import { Spine } from './Spine';
+import { Metadata } from './Metadata';
+export declare class Package {
+    rootUrl: string;
+    rootUrlMO?: string;
+    spine: Spine;
+    metadata: Metadata;
+    zip: JSZip | null;
+    rendition_viewport?: string;
+    rendition_layout?: string;
+    rendition_flow?: string;
+    rendition_orientation?: string;
+    rendition_spread?: string;
+    toc?: any;
+    constructor(packageData: any);
+    resolveRelativeUrl(relativeUrl: string): string;
+    isFixedLayout(): boolean;
+    loadFile(relativePath: string): Promise<string | null>;
+    loadBlob(relativePath: string): Promise<Blob | null>;
+}

package/dist/model/Spine.d.ts

@@ -0,0 +1,19 @@
+import { Package } from './Package';
+import { SpineItem } from './SpineItem';
+export declare class Spine {
+    package: Package;
+    items: SpineItem[];
+    direction: string;
+    private handleLinear;
+    constructor(epubPackage: Package, spineDTO?: any);
+    isValidLinearItem(index: number): boolean;
+    item(index: number): SpineItem | undefined;
+    getItemByHref(href: string): SpineItem | undefined;
+    first(): SpineItem | undefined;
+    firstLinear(): SpineItem | undefined;
+    nextItem(item: SpineItem): SpineItem | undefined;
+    prevItem(item: SpineItem): SpineItem | undefined;
+    nextLinear(item: SpineItem): SpineItem | undefined;
+    prevLinear(item: SpineItem): SpineItem | undefined;
+    last(): SpineItem | undefined;
+}

package/dist/model/SpineItem.d.ts

@@ -0,0 +1,34 @@
+import { Spine } from './Spine';
+export declare class SpineItem {
+    idref: string;
+    href: string;
+    cfi: string;
+    linear: string;
+    page_spread: string;
+    rendition_viewport?: string;
+    rendition_spread?: string;
+    rendition_orientation?: string;
+    rendition_layout?: string;
+    rendition_flow?: string;
+    media_overlay_id?: string;
+    media_type?: string;
+    index: number;
+    spine: Spine;
+    static readonlyRENDITION_LAYOUT_REFLOWABLE: string;
+    static readonly RENDITION_LAYOUT_PREPAGINATED = "pre-paginated";
+    static readonly SPREAD_LEFT = "page-spread-left";
+    static readonly SPREAD_RIGHT = "page-spread-right";
+    static readonly SPREAD_CENTER = "page-spread-center";
+    static readonly SPREAD_NONE = "none";
+    static readonly SPREAD_AUTO = "auto";
+    static readonly FLOW_PAGINATED = "paginated";
+    static readonly FLOW_SCROLLED_CONTINUOUS = "scrolled-continuous";
+    static readonly FLOW_SCROLLED_DOC = "scrolled-doc";
+    static readonly FLOW_AUTO = "auto";
+    constructor(itemData: any, index: number, spine: Spine);
+    private validateSpread;
+    isReflowable(): boolean;
+    isFixedLayout(): boolean;
+    getRenditionLayout(): string | undefined;
+    static alternateSpread(spread: string): string;
+}

package/dist/parser/EpubParser.d.ts

@@ -0,0 +1,6 @@
+import { Package } from '../model/Package';
+export declare class EpubParser {
+    static load(rootUrl: string): Promise<Package>;
+    private static parseOpf;
+    private static parseNcx;
+}