@prose-reader/core 0.0.36

package/dist/pagination.d.ts

@@ -0,0 +1,65 @@
+import { Context } from "./context";
+import { SpineItem } from "./spineItem/createSpineItem";
+import { SpineItemManager } from "./spineItemManager";
+declare type PaginationInfo = {
+    beginPageIndex: number | undefined;
+    beginNumberOfPages: number;
+    beginCfi: string | undefined;
+    beginSpineItemIndex: number | undefined;
+    endPageIndex: number | undefined;
+    endNumberOfPages: number;
+    endCfi: string | undefined;
+    endSpineItemIndex: number | undefined;
+};
+export declare const createPagination: ({ context }: {
+    context: Context;
+    spineItemManager: SpineItemManager;
+}) => {
+    destroy: () => void;
+    updateBeginAndEnd: ((begin: {
+        spineItem: SpineItem;
+        pageIndex: number;
+        cfi: string | undefined;
+        options: {
+            isAtEndOfChapter?: boolean;
+        };
+    } & {
+        spineItemIndex: number;
+    }, end: {
+        spineItem: SpineItem;
+        pageIndex: number;
+        cfi: string | undefined;
+        options: {
+            isAtEndOfChapter?: boolean;
+        };
+    } & {
+        spineItemIndex: number;
+    }) => void) | ((begin: {
+        spineItem: SpineItem;
+        pageIndex: number;
+        cfi: string | undefined;
+        options: {
+            isAtEndOfChapter?: boolean;
+        };
+    } & {
+        spineItemIndex: number;
+    }, end: {
+        spineItem: SpineItem;
+        pageIndex: number;
+        cfi: string | undefined;
+        options: {
+            isAtEndOfChapter?: boolean;
+        };
+    } & {
+        spineItemIndex: number;
+    }) => void);
+    getInfo: () => PaginationInfo;
+    $: {
+        info$: import("rxjs").Observable<PaginationInfo>;
+    };
+};
+export declare type Pagination = ReturnType<typeof createPagination>;
+export declare const getItemOffsetFromPageIndex: (pageWidth: number, pageIndex: number, itemWidth: number) => number;
+export declare const getNumberOfPages: (itemWidth: number, pageWidth: number) => number;
+export declare const getClosestValidOffsetFromApproximateOffsetInPages: (offset: number, pageWidth: number, itemWidth: number) => number;
+export {};

package/dist/reader.d.ts

@@ -0,0 +1,63 @@
+import { Observable } from "rxjs";
+import { createContext as createBookContext } from "./context";
+import { Pagination } from "./pagination";
+import { Spine } from "./spine/createSpine";
+import { LoadOptions, Manifest } from "./types";
+import { createSelection } from "./selection";
+import { SpineItemManager } from "./spineItemManager";
+import { Hook, RegisterHook } from "./types/Hook";
+declare type Context = ReturnType<typeof createBookContext>;
+declare type ContextSettings = Parameters<Context[`setSettings`]>[0];
+declare type CreateReaderOptions = {
+    hooks?: Hook[];
+    containerElement: HTMLElement;
+} & Pick<ContextSettings, `forceSinglePageMode` | `pageTurnAnimation` | `pageTurnDirection` | `pageTurnMode`>;
+export declare type Reader = {
+    context: Context;
+    registerHook: RegisterHook;
+    spine: Spine;
+    manipulateSpineItems: Spine[`manipulateSpineItems`];
+    manipulateContainer: (cb: (container: HTMLElement) => boolean) => void;
+    moveTo: Spine[`viewportNavigator`][`moveTo`];
+    turnLeft: Spine[`viewportNavigator`][`turnLeft`];
+    turnRight: Spine[`viewportNavigator`][`turnRight`];
+    goToPageOfCurrentChapter: Spine[`viewportNavigator`][`goToPageOfCurrentChapter`];
+    goToPage: Spine[`viewportNavigator`][`goToPage`];
+    goToUrl: Spine[`viewportNavigator`][`goToUrl`];
+    goToCfi: Spine[`viewportNavigator`][`goToCfi`];
+    goToSpineItem: Spine[`viewportNavigator`][`goToSpineItem`];
+    getFocusedSpineItemIndex: SpineItemManager[`getFocusedSpineItemIndex`];
+    getSpineItem: SpineItemManager[`get`];
+    getSpineItems: SpineItemManager[`getAll`];
+    getAbsolutePositionOf: SpineItemManager[`getAbsolutePositionOf`];
+    getSelection: Spine[`getSelection`];
+    isSelecting: Spine[`isSelecting`];
+    normalizeEventForViewport: Spine[`normalizeEventForViewport`];
+    getCfiMetaInformation: Spine[`cfiLocator`][`getCfiMetaInformation`];
+    resolveCfi: Spine[`cfiLocator`][`resolveCfi`];
+    generateCfi: Spine[`cfiLocator`][`generateFromRange`];
+    locator: Spine[`locator`];
+    getCurrentNavigationPosition: Spine[`viewportNavigator`][`getCurrentNavigationPosition`];
+    getCurrentViewportPosition: Spine[`viewportNavigator`][`getCurrentViewportPosition`];
+    layout: () => void;
+    load: (manifest: Manifest, loadOptions?: LoadOptions) => void;
+    destroy: () => void;
+    setSettings: Context[`setSettings`];
+    $: {
+        pagination$: Pagination[`$`][`info$`];
+        settings$: Context[`$`][`settings$`];
+        state$: Observable<{
+            supportedPageTurnAnimation: NonNullable<ContextSettings[`pageTurnAnimation`]>[];
+            supportedPageTurnMode: NonNullable<ContextSettings[`pageTurnMode`]>[];
+            supportedPageTurnDirection: NonNullable<ContextSettings[`pageTurnDirection`]>[];
+            supportedComputedPageTurnDirection: NonNullable<ContextSettings[`pageTurnDirection`]>[];
+        }>;
+        ready$: Observable<void>;
+        selection$: Observable<ReturnType<typeof createSelection> | null>;
+        viewportState$: Spine[`$`][`viewportState$`];
+        layout$: Spine[`$`][`layout$`];
+        destroy$: Observable<void>;
+    };
+};
+export declare const createReader: ({ containerElement, hooks: initialHooks, ...settings }: CreateReaderOptions) => Reader;
+export {};

package/dist/report.d.ts

@@ -0,0 +1,26 @@
+export declare const Report: {
+    namespace: (namespace: string) => {
+        log: (...data: any[]) => void;
+        warn: (...data: any[]) => void;
+        error: (...data: any[]) => void;
+        time: (name: string, targetDuration?: number) => () => void;
+        logMetric: (performanceEntry: PerformanceEntry | {
+            name: string;
+            duration: number;
+        }, targetDuration?: number) => void;
+        measurePerformance: <F extends (...args: any[]) => any>(name: string, targetDuration: number | undefined, functionToMeasure: F, { disable }?: {
+            disable?: boolean | undefined;
+        }) => F | ((...args: Parameters<F>) => ReturnType<F>);
+    };
+    log: (...data: any[]) => void;
+    warn: (...data: any[]) => void;
+    error: (...data: any[]) => void;
+    time: (name: string, targetDuration?: number) => () => void;
+    logMetric: (performanceEntry: PerformanceEntry | {
+        name: string;
+        duration: number;
+    }, targetDuration?: number) => void;
+    measurePerformance: <F extends (...args: any[]) => any>(name: string, targetDuration: number | undefined, functionToMeasure: F, { disable }?: {
+        disable?: boolean | undefined;
+    }) => F | ((...args: Parameters<F>) => ReturnType<F>);
+};

package/dist/selection.d.ts

@@ -0,0 +1,6 @@
+import { Manifest } from "./types";
+export declare const createSelection: (selection: Selection, item: Manifest[`spineItems`][number]) => {
+    toString: () => string;
+    getAnchorCfi: () => string | undefined;
+    getFocusCfi: () => string | undefined;
+};

package/dist/settings.d.ts

@@ -0,0 +1,37 @@
+import { Manifest } from "./types";
+export declare type PublicSettings = {
+    forceSinglePageMode: boolean;
+    pageTurnAnimation: `none` | `fade` | `slide`;
+    pageTurnAnimationDuration: undefined | number;
+    pageTurnDirection: `vertical` | `horizontal`;
+    pageTurnMode: `controlled` | `scrollable`;
+};
+declare type InnerSettings = PublicSettings & {
+    computedPageTurnMode: PublicSettings[`pageTurnMode`];
+    computedPageTurnDirection: PublicSettings[`pageTurnDirection`];
+    computedPageTurnAnimation: PublicSettings[`pageTurnAnimation`];
+    computedPageTurnAnimationDuration: number;
+    computedSnapAnimationDuration: number;
+};
+export declare const createSettings: (initialSettings: Partial<PublicSettings>) => {
+    getSettings: () => InnerSettings;
+    setSettings: (newSettings: Partial<PublicSettings>, options: {
+        hasVerticalWritingSubject: boolean;
+        manifest: Manifest | undefined;
+    }) => void;
+    recompute: (options: {
+        hasVerticalWritingSubject: boolean;
+        manifest: Manifest | undefined;
+    }) => void;
+    destroy: () => void;
+    $: {
+        settings$: import("rxjs").Observable<PublicSettings & {
+            computedPageTurnMode: PublicSettings[`pageTurnMode`];
+            computedPageTurnDirection: PublicSettings[`pageTurnDirection`];
+            computedPageTurnAnimation: PublicSettings[`pageTurnAnimation`];
+            computedPageTurnAnimationDuration: number;
+            computedSnapAnimationDuration: number;
+        }>;
+    };
+};
+export {};

package/dist/spine/cfiLocator.d.ts

@@ -0,0 +1,257 @@
+import { Context } from "../context";
+import { SpineItem } from "../spineItem/createSpineItem";
+import { createLocationResolver } from "../spineItem/locationResolver";
+import { SpineItemManager } from "../spineItemManager";
+import { Manifest } from "../types";
+export declare const createCfiLocator: ({ spineItemManager, spineItemLocator }: {
+    spineItemManager: SpineItemManager;
+    context: Context;
+    spineItemLocator: ReturnType<typeof createLocationResolver>;
+}) => {
+    getSpineItemFromCfi: (cfi: string) => ({
+        item: {
+            id: string;
+            href: string;
+            path: string;
+            renditionLayout: "reflowable" | "pre-paginated";
+            progressionWeight: number;
+            pageSpreadLeft: true | undefined;
+            pageSpreadRight: true | undefined;
+            mediaType?: string | undefined;
+        };
+    } & {
+        layout: (layoutInformation: {
+            blankPagePosition: "after" | "before" | "none";
+            minimumWidth: number;
+            spreadPosition: "right" | "left" | "none";
+        }) => {
+            width: number;
+            height: number;
+        };
+        load: () => void;
+        adjustPositionOfElement: ({ right, left, top }: {
+            right?: number | undefined;
+            left?: number | undefined;
+            top?: number | undefined;
+        }) => void;
+        createLoadingElement: (containerElement: HTMLElement, item: {
+            id: string;
+            href: string;
+            path: string;
+            renditionLayout: "reflowable" | "pre-paginated";
+            progressionWeight: number;
+            pageSpreadLeft: true | undefined;
+            pageSpreadRight: true | undefined;
+            mediaType?: string | undefined;
+        }, context: {
+            load: (newManifest: Manifest, newLoadOptions: import("../types").LoadOptions) => void;
+            isRTL: () => boolean;
+            areAllItemsPrePaginated: () => boolean;
+            destroy: () => void;
+            getLoadOptions: () => import("../types").LoadOptions | undefined;
+            getCalculatedInnerMargin: () => number;
+            getVisibleAreaRect: () => {
+                width: number;
+                height: number;
+                x: number;
+                y: number;
+            };
+            shouldDisplaySpread: () => boolean;
+            setHasVerticalWriting: () => void;
+            setVisibleAreaRect: (x: number, y: number, width: number, height: number) => void;
+            getManifest: () => Manifest | undefined;
+            getReadingDirection: () => "ltr" | "rtl" | undefined;
+            getPageSize: () => {
+                width: number;
+                height: number;
+            };
+            getSettings: () => import("../settings").PublicSettings & {
+                computedPageTurnMode: "controlled" | "scrollable";
+                computedPageTurnDirection: "vertical" | "horizontal";
+                computedPageTurnAnimation: "none" | "fade" | "slide";
+                computedPageTurnAnimationDuration: number;
+                computedSnapAnimationDuration: number;
+            };
+            setSettings: (data: Partial<import("../settings").PublicSettings>) => void;
+            $: {
+                hasVerticalWriting$: import("rxjs").Observable<boolean>;
+                destroy$: import("rxjs").Observable<void>;
+                settings$: import("rxjs").Observable<import("../settings").PublicSettings & {
+                    computedPageTurnMode: "controlled" | "scrollable";
+                    computedPageTurnDirection: "vertical" | "horizontal";
+                    computedPageTurnAnimation: "none" | "fade" | "slide";
+                    computedPageTurnAnimationDuration: number;
+                    computedSnapAnimationDuration: number;
+                }>;
+                load$: import("rxjs").Observable<Manifest>;
+            };
+        }) => HTMLDivElement;
+        getElementDimensions: () => {
+            width: number;
+            height: number;
+        };
+        getHtmlFromResource: (response: Response) => Promise<string>;
+        getResource: () => Promise<Response>;
+        translateFramePositionIntoPage: (position: {
+            clientX: number;
+            clientY: number;
+        }) => {
+            clientX: number;
+            clientY: number;
+        };
+        setLayoutDirty: () => void;
+        injectStyle: (cssText: string) => void;
+        loadContent: () => void;
+        unloadContent: () => void;
+        spineItemFrame: {
+            getIsLoaded: () => boolean;
+            getIsReady: () => boolean;
+            getViewportDimensions: () => {
+                width: number;
+                height: number;
+            } | undefined;
+            getFrameElement: () => HTMLIFrameElement | undefined;
+            getHtmlFromResource: (response: Response) => Promise<string>;
+            load: () => void;
+            unload: () => void;
+            staticLayout: (size: {
+                width: number;
+                height: number;
+            }) => void;
+            getManipulableFrame: () => {
+                frame: HTMLIFrameElement;
+                removeStyle: (id: string) => void;
+                addStyle: (id: string, style: string, prepend?: boolean) => void;
+            } | undefined;
+            getReadingDirection: () => "ltr" | "rtl" | undefined;
+            isUsingVerticalWriting: () => boolean;
+            getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined;
+            destroy: () => void;
+            $: {
+                unload$: import("rxjs").Observable<void>;
+                unloaded$: import("rxjs").Observable<void>;
+                loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                ready$: import("rxjs").Observable<FontFaceSet | undefined>;
+                isReady$: import("rxjs").Observable<boolean>;
+                contentLayoutChange$: import("rxjs").Observable<{
+                    isFirstLayout: boolean;
+                } | {
+                    isFirstLayout: boolean;
+                }>;
+            };
+        };
+        element: HTMLElement;
+        loadingElement: HTMLDivElement;
+        isReflowable: boolean;
+        getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+        getViewPortInformation: () => {
+            computedScale: number;
+            computedWidthScale: number;
+            viewportDimensions: {
+                width: number;
+                height: number;
+            };
+        } | {
+            width?: number | undefined;
+            height?: number | undefined;
+            computedScale: number;
+            computedWidthScale: number;
+            viewportDimensions?: undefined;
+        };
+        isImageType: () => boolean | undefined;
+        isReady: () => boolean;
+        destroy: () => void;
+        isUsingVerticalWriting: () => boolean | undefined;
+        getReadingDirection: () => "ltr" | "rtl" | undefined;
+        manipulateSpineItem: (cb: (options: {
+            container: HTMLElement;
+            loadingElement: HTMLElement;
+            item: {
+                id: string;
+                href: string;
+                path: string;
+                renditionLayout: "reflowable" | "pre-paginated";
+                progressionWeight: number;
+                pageSpreadLeft: true | undefined;
+                pageSpreadRight: true | undefined;
+                mediaType?: string | undefined;
+            };
+            overlayElement: HTMLDivElement;
+        } & ({
+            frame: HTMLIFrameElement;
+            removeStyle: (id: string) => void;
+            addStyle: (id: string, style: string, prepend?: boolean) => void;
+        } | {
+            frame: undefined;
+            removeStyle: (id: string) => void;
+            addStyle: (id: string, style: string) => void;
+        })) => boolean) => boolean;
+        executeOnLayoutBeforeMeasurmentHook: (options: {
+            minimumWidth: number;
+        }) => void;
+        selectionTracker: {
+            track: (frameToTrack: HTMLIFrameElement) => void;
+            destroy: () => void;
+            isSelecting: () => boolean;
+            getSelection: () => Selection | undefined;
+            $: import("rxjs").Observable<{
+                event: "selectionchange";
+                data: Selection | null;
+            } | {
+                event: "selectstart";
+                data: Selection | null;
+            } | {
+                event: "selectend";
+                data: Selection | null;
+            }>;
+        };
+        fingerTracker: {
+            track: (frame: HTMLIFrameElement) => void;
+            getFingerPositionInIframe(): {
+                x: number | undefined;
+                y: number | undefined;
+            } | undefined;
+            destroy: () => void;
+            $: import("rxjs").Observable<{
+                event: "fingermove";
+                data: {
+                    x: number;
+                    y: number;
+                };
+            } | {
+                event: "fingerout";
+                data: undefined;
+            }>;
+        };
+        $: {
+            contentLayoutChangeSubject$: import("rxjs").Observable<{
+                isFirstLayout: boolean;
+                isReady: boolean;
+            }>;
+            loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+        };
+    }) | undefined;
+    getCfiMetaInformation: (cfi: string) => {
+        spineItemIndex: number | undefined;
+    } | undefined;
+    getCfi: ((pageIndex: number, spineItem: SpineItem) => string) | ((pageIndex: number, spineItem: SpineItem) => string);
+    getRootCfi: (spineItem: SpineItem) => string;
+    resolveCfi: (cfiString: string) => {
+        node: Node | undefined;
+        offset: number | undefined;
+        spineItemIndex: number;
+    } | {
+        spineItemIndex: number;
+        node?: undefined;
+        offset?: undefined;
+    } | undefined;
+    generateFromRange: ({ startNode, start, end, endNode }: {
+        startNode: Node;
+        start: number;
+        endNode: Node;
+        end: number;
+    }, item: Manifest[`spineItems`][number]) => {
+        start: string;
+        end: string;
+    };
+};