@prose-reader/core 1.56.0 → 1.58.0

package/dist/manifest/areAllItemsPrePaginated.d.ts

@@ -0,0 +1,3 @@
+import { Manifest } from '@prose-reader/shared';
+
+export declare const areAllItemsPrePaginated: (manifest: Manifest | undefined) => boolean;

package/dist/manifest/isFullyPrePaginated.d.ts

@@ -0,0 +1,3 @@
+import { Manifest } from '@prose-reader/shared';
+
+export declare const isFullyPrePaginated: (manifest?: Manifest) => boolean | undefined;

package/dist/pagination/pagination.d.ts

@@ -0,0 +1,88 @@
+import { Context } from '../context/Context';
+import { SpineItem } from '../spineItem/createSpineItem';
+import { SpineItemManager } from '../spineItemManager';
+import { PaginationInfo } from './types';
+
+export declare const createPagination: ({ context }: {
+    context: Context;
+    spineItemManager: SpineItemManager;
+}) => {
+    destroy: () => void;
+    updateBeginAndEnd: ((begin: Parameters<(info: {
+        spineItem: SpineItem;
+        pageIndex: number;
+        cfi: string | undefined;
+        options: {
+            isAtEndOfChapter?: boolean;
+        };
+    }) => {
+        numberOfPages: number;
+        pageIndex: number;
+        cfi: string | undefined;
+    }>[0] & {
+        spineItemIndex: number;
+    }, end: Parameters<(info: {
+        spineItem: SpineItem;
+        pageIndex: number;
+        cfi: string | undefined;
+        options: {
+            isAtEndOfChapter?: boolean;
+        };
+    }) => {
+        numberOfPages: number;
+        pageIndex: number;
+        cfi: string | undefined;
+    }>[0] & {
+        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;
+    }) => ReturnType<(begin: Parameters<(info: {
+        spineItem: SpineItem;
+        pageIndex: number;
+        cfi: string | undefined;
+        options: {
+            isAtEndOfChapter?: boolean;
+        };
+    }) => {
+        numberOfPages: number;
+        pageIndex: number;
+        cfi: string | undefined;
+    }>[0] & {
+        spineItemIndex: number;
+    }, end: Parameters<(info: {
+        spineItem: SpineItem;
+        pageIndex: number;
+        cfi: string | undefined;
+        options: {
+            isAtEndOfChapter?: boolean;
+        };
+    }) => {
+        numberOfPages: number;
+        pageIndex: number;
+        cfi: string | undefined;
+    }>[0] & {
+        spineItemIndex: number;
+    }) => void>);
+    getPaginationInfo: () => PaginationInfo;
+    paginationInfo$: import('rxjs').Observable<PaginationInfo>;
+};
+export type Pagination = ReturnType<typeof createPagination>;
+export declare const getItemOffsetFromPageIndex: (pageWidth: number, pageIndex: number, itemWidth: number) => number;
+export declare const calculateNumberOfPagesForItem: (itemWidth: number, pageWidth: number) => number;
+export declare const getClosestValidOffsetFromApproximateOffsetInPages: (offset: number, pageWidth: number, itemWidth: number) => number;

package/dist/pagination/types.d.ts

@@ -0,0 +1,10 @@
+export type PaginationInfo = {
+    beginPageIndexInSpineItem: number | undefined;
+    beginNumberOfPagesInSpineItem: number;
+    beginCfi: string | undefined;
+    beginSpineItemIndex: number | undefined;
+    endPageIndexInSpineItem: number | undefined;
+    endNumberOfPagesInSpineItem: number;
+    endCfi: string | undefined;
+    endSpineItemIndex: number | undefined;
+};

package/dist/reader.d.ts

@@ -0,0 +1,8 @@
+import { ReaderInternal } from './types/reader';
+import { Settings } from './settings/types';
+
+export type CreateReaderOptions = Partial<Settings>;
+export type CreateReaderParameters = CreateReaderOptions;
+export declare const createReader: (inputSettings: CreateReaderOptions) => ReaderInternal;
+type Reader = ReturnType<typeof createReader>;
+export type { Reader };

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;
+        }) => 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;
+    }) => F | ((...args: Parameters<F>) => ReturnType<F>);
+};

package/dist/selection.d.ts

@@ -0,0 +1,7 @@
+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/SettingsManager.d.ts

@@ -0,0 +1,14 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { Settings, ComputedSettings } from './types';
+import { Context } from '../context/Context';
+
+export declare class SettingsManager {
+    _settingsSubject$: BehaviorSubject<ComputedSettings>;
+    _context: Context;
+    settings$: Observable<ComputedSettings>;
+    constructor(initialSettings: Partial<Settings>, context: Context);
+    _updateSettings(settings: Settings): void;
+    setSettings(settings: Partial<Settings>): void;
+    get settings(): ComputedSettings;
+    destroy(): void;
+}

package/dist/settings/defaultSettings.d.ts

@@ -0,0 +1,3 @@
+import { Settings } from './types';
+
+export declare const defaultSettings: Settings;

package/dist/settings/getComputedSettings.d.ts

@@ -0,0 +1,4 @@
+import { ComputedSettings, Settings } from './types';
+import { Context } from '../context/Context';
+
+export declare const getComputedSettings: (settings: Settings, context: Context) => Omit<ComputedSettings, keyof Settings>;

package/dist/settings/types.d.ts

@@ -0,0 +1,19 @@
+import { Manifest } from '@prose-reader/shared';
+
+export type Settings = {
+    forceSinglePageMode: boolean;
+    pageTurnAnimation: `none` | `fade` | `slide`;
+    pageTurnAnimationDuration: undefined | number;
+    pageTurnDirection: `vertical` | `horizontal`;
+    pageTurnMode: `controlled` | `scrollable`;
+    navigationSnapThreshold: number;
+    numberOfAdjacentSpineItemToPreLoad: number;
+    fetchResource?: (item: Manifest[`spineItems`][number]) => Promise<Response>;
+};
+export type ComputedSettings = Settings & {
+    computedPageTurnMode: Settings[`pageTurnMode`];
+    computedPageTurnDirection: Settings[`pageTurnDirection`];
+    computedPageTurnAnimation: Settings[`pageTurnAnimation`];
+    computedPageTurnAnimationDuration: number;
+    computedSnapAnimationDuration: number;
+};

package/dist/spine/cfiLocator.d.ts

@@ -0,0 +1,340 @@
+import { Context } from '../context/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) => {
+        layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
+            blankPagePosition: `before` | `after` | `none`;
+            minimumWidth: number;
+            spreadPosition: `none` | `left` | `right`;
+        }) => {
+            width: number;
+            height: number;
+        };
+        item: {
+            id: string;
+            href: string;
+            renditionLayout: `reflowable` | `pre-paginated`;
+            progressionWeight: number;
+            pageSpreadLeft: true | undefined;
+            pageSpreadRight: true | undefined;
+            mediaType?: string;
+        };
+        load: () => void;
+        adjustPositionOfElement: ({ right, left, top }: {
+            right?: number;
+            left?: number;
+            top?: number;
+        }) => void;
+        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: () => ReturnType<typeof import('../spineItem/frameItem/createFrameManipulator').createFrameManipulator> | 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;
+        getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+        getViewPortInformation: () => {
+            computedScale: number;
+            computedWidthScale: number;
+            viewportDimensions: {
+                width: number;
+                height: number;
+            };
+        } | undefined;
+        isImageType: () => boolean;
+        isReady: () => boolean;
+        destroy: () => void;
+        isUsingVerticalWriting: () => boolean | undefined;
+        getReadingDirection: () => "ltr" | "rtl" | undefined;
+        manipulateSpineItem: (cb: (options: {
+            container: HTMLElement;
+            item: Manifest[`spineItems`][number];
+            overlayElement: HTMLDivElement;
+        } & (ReturnType<typeof import('../spineItem/frameItem/createFrameManipulator').createFrameManipulator> | {
+            frame: undefined;
+            removeStyle: (id: string) => void;
+            addStyle: (id: string, style: string) => void;
+        })) => boolean) => boolean;
+        executeOnLayoutBeforeMeasurementHook: (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;
+            }>;
+        };
+        getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
+            columnHeight: number;
+            columnWidth: number;
+            width: number;
+        };
+        getDimensionsForPaginatedContent: () => {
+            columnHeight: number;
+            columnWidth: number;
+        };
+        $: {
+            contentLayout$: import('rxjs').Observable<{
+                isFirstLayout: boolean;
+                isReady: boolean;
+            }>;
+            loaded$: import('rxjs').Observable<HTMLIFrameElement>;
+            isReady$: import('rxjs').Observable<boolean>;
+        };
+    } | undefined;
+    getCfiMetaInformation: (cfi: string) => {
+        spineItemIndex: number | undefined;
+    } | undefined;
+    getCfi: ((pageIndex: number, spineItem: SpineItem) => string) | ((pageIndex: number, spineItem: {
+        layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
+            blankPagePosition: `before` | `after` | `none`;
+            minimumWidth: number;
+            spreadPosition: `none` | `left` | `right`;
+        }) => {
+            width: number;
+            height: number;
+        };
+        item: {
+            id: string;
+            href: string;
+            renditionLayout: `reflowable` | `pre-paginated`;
+            progressionWeight: number;
+            pageSpreadLeft: true | undefined;
+            pageSpreadRight: true | undefined;
+            mediaType?: string;
+        };
+        load: () => void;
+        adjustPositionOfElement: ({ right, left, top }: {
+            right?: number;
+            left?: number;
+            top?: number;
+        }) => void;
+        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: () => ReturnType<typeof import('../spineItem/frameItem/createFrameManipulator').createFrameManipulator> | 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;
+        getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+        getViewPortInformation: () => {
+            computedScale: number;
+            computedWidthScale: number;
+            viewportDimensions: {
+                width: number;
+                height: number;
+            };
+        } | undefined;
+        isImageType: () => boolean;
+        isReady: () => boolean;
+        destroy: () => void;
+        isUsingVerticalWriting: () => boolean | undefined;
+        getReadingDirection: () => "ltr" | "rtl" | undefined;
+        manipulateSpineItem: (cb: (options: {
+            container: HTMLElement;
+            item: Manifest[`spineItems`][number];
+            overlayElement: HTMLDivElement;
+        } & (ReturnType<typeof import('../spineItem/frameItem/createFrameManipulator').createFrameManipulator> | {
+            frame: undefined;
+            removeStyle: (id: string) => void;
+            addStyle: (id: string, style: string) => void;
+        })) => boolean) => boolean;
+        executeOnLayoutBeforeMeasurementHook: (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;
+            }>;
+        };
+        getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
+            columnHeight: number;
+            columnWidth: number;
+            width: number;
+        };
+        getDimensionsForPaginatedContent: () => {
+            columnHeight: number;
+            columnWidth: number;
+        };
+        $: {
+            contentLayout$: import('rxjs').Observable<{
+                isFirstLayout: boolean;
+                isReady: boolean;
+            }>;
+            loaded$: import('rxjs').Observable<HTMLIFrameElement>;
+            isReady$: import('rxjs').Observable<boolean>;
+        };
+    }) => ReturnType<(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;
+    };
+};

package/dist/spine/createSpine.d.ts

@@ -0,0 +1,31 @@
+import { Observable } from 'rxjs';
+import { Context } from '../context/Context';
+import { Pagination } from '../pagination/pagination';
+import { SpineItemManager } from '../spineItemManager';
+import { createLocationResolver as createSpineLocationResolver } from './locationResolver';
+import { createLocationResolver as createSpineItemLocationResolver } from '../spineItem/locationResolver';
+import { createCfiLocator } from './cfiLocator';
+import { Spine } from '../types/Spine';
+import { AdjustedNavigation, Navigation } from '../viewportNavigator/types';
+import { SettingsManager } from '../settings/SettingsManager';
+import { HookManager } from '../hooks/HookManager';
+
+export declare const createSpine: ({ element$, context, pagination, spineItemManager, spineItemLocator, spineLocator, cfiLocator, navigation$, navigationAdjusted$, currentNavigationPosition$, viewportState$, settings, hookManager, }: {
+    element$: Observable<HTMLElement>;
+    context: Context;
+    pagination: Pagination;
+    spineItemManager: SpineItemManager;
+    spineItemLocator: ReturnType<typeof createSpineItemLocationResolver>;
+    spineLocator: ReturnType<typeof createSpineLocationResolver>;
+    cfiLocator: ReturnType<typeof createCfiLocator>;
+    navigation$: Observable<Navigation>;
+    navigationAdjusted$: Observable<AdjustedNavigation>;
+    currentNavigationPosition$: Observable<{
+        x: number;
+        y: number;
+    }>;
+    viewportState$: Observable<`free` | `busy`>;
+    settings: SettingsManager;
+    hookManager: HookManager;
+}) => Spine;
+export { Spine };