@prose-reader/core 0.0.36

package/dist/spine/eventsHelper.d.ts

@@ -0,0 +1,11 @@
+import { Context } from "../context";
+import { SpineItemManager } from "../spineItemManager";
+import { createLocationResolver } from "./locationResolver";
+export declare const createEventsHelper: ({ iframeEventBridgeElement, locator }: {
+    iframeEventBridgeElement: HTMLElement;
+    spineItemManager: SpineItemManager;
+    context: Context;
+    locator: ReturnType<typeof createLocationResolver>;
+}) => {
+    normalizeEventForViewport: <E extends MouseEvent | TouchEvent | PointerEvent>(event: E) => E;
+};

package/dist/spine/locationResolver.d.ts

@@ -0,0 +1,479 @@
+import { Context } from "../context";
+import { SpineItem } from "../spineItem/createSpineItem";
+import { createLocationResolver as createSpineItemLocator } from "../spineItem/locationResolver";
+import { SpineItemManager } from "../spineItemManager";
+declare type SpinePosition = {
+    x: number;
+    y: number;
+};
+declare type SpineItemPosition = {
+    x: number;
+    y: number;
+    outsideOfBoundaries?: boolean;
+};
+export declare const createLocationResolver: ({ spineItemManager, context, spineItemLocator }: {
+    spineItemManager: SpineItemManager;
+    context: Context;
+    spineItemLocator: ReturnType<typeof createSpineItemLocator>;
+}) => {
+    getSpinePositionFromSpineItemPosition: (spineItemPosition: SpineItemPosition, spineItem: SpineItem) => SpinePosition;
+    getSpinePositionFromSpineItem: (spineItem: SpineItem) => SpinePosition;
+    getSpinePositionFromSpineItemAnchor: (anchor: string, spineItem: SpineItem) => SpinePosition;
+    getSpineItemPositionFromSpinePosition: ((position: SpinePosition, spineItem: SpineItem) => SpineItemPosition) | ((position: SpinePosition, spineItem: SpineItem) => SpineItemPosition);
+    getSpineItemFromPosition: ((position: SpinePosition) => ({
+        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: import("@prose-reader/shared").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: () => import("@prose-reader/shared").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<import("@prose-reader/shared").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) | ((position: SpinePosition) => ({
+        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: import("@prose-reader/shared").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: () => import("@prose-reader/shared").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<import("@prose-reader/shared").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);
+    getSpineItemFromIframe: (iframe: Element) => SpineItem | undefined;
+    getSpineItemPageIndexFromNode: (node: Node, offset: number | undefined, spineItemOrIndex: SpineItem | number) => number | undefined;
+    getSpineItemsFromReadingOrderPosition: (position: SpinePosition) => {
+        left: number;
+        right: number;
+        begin: number;
+        beginPosition: SpinePosition;
+        end: number;
+        endPosition: SpinePosition;
+    } | undefined;
+};
+export {};

package/dist/spine/navigationResolver.d.ts

@@ -0,0 +1,48 @@
+import { Context } from "../context";
+import { SpineItemManager } from "../spineItemManager";
+import { SpineItem } from "../spineItem/createSpineItem";
+import { createLocationResolver } from "./locationResolver";
+import { createCfiLocator } from "./cfiLocator";
+export declare type ViewportNavigationEntry = {
+    x: number;
+    y: number;
+    spineItem?: SpineItem;
+};
+declare type ViewportPosition = {
+    x: number;
+    y: number;
+};
+declare type SpineItemPosition = {
+    x: number;
+    y: number;
+};
+export declare const createNavigationResolver: ({ context, spineItemManager, cfiLocator, locator }: {
+    context: Context;
+    spineItemManager: SpineItemManager;
+    cfiLocator: ReturnType<typeof createCfiLocator>;
+    locator: ReturnType<typeof createLocationResolver>;
+}) => {
+    getNavigationForCfi: (cfi: string) => ViewportNavigationEntry;
+    getNavigationForPage: (pageIndex: number, spineItem?: SpineItem | undefined) => ViewportNavigationEntry;
+    getNavigationForLastPage: (spineItem: SpineItem) => ViewportNavigationEntry;
+    getNavigationForSpineIndexOrId: (indexOrId: number | string) => ViewportNavigationEntry;
+    getNavigationForRightPage: (position: SpineItemPosition) => ViewportNavigationEntry;
+    getNavigationForLeftPage: (position: SpineItemPosition) => ViewportNavigationEntry;
+    getNavigationForUrl: (url: string | URL) => (ViewportNavigationEntry & {
+        url: URL;
+    }) | undefined;
+    getNavigationForAnchor: (anchor: string, spineItem: SpineItem) => ViewportNavigationEntry;
+    getNavigationForPosition: (viewportPosition: ViewportPosition) => ViewportNavigationEntry;
+    getMostPredominantNavigationForPosition: (viewportPosition: ViewportPosition) => ViewportNavigationEntry;
+    wrapPositionWithSafeEdge: ((position: SpineItemPosition) => {
+        x: number;
+        y: number;
+    }) | ((position: SpineItemPosition) => {
+        x: number;
+        y: number;
+    });
+    isNavigationGoingForwardFrom: (to: ViewportPosition, from: ViewportPosition) => boolean;
+    areNavigationDifferent: (a: ViewportNavigationEntry, b: ViewportNavigationEntry) => boolean;
+    arePositionsDifferent: (a: ViewportNavigationEntry, b: ViewportNavigationEntry) => boolean;
+};
+export {};

package/dist/spine/viewportNavigator/manualViewportNavigator.d.ts

@@ -0,0 +1,99 @@
+import { BehaviorSubject } from "rxjs";
+import { Context } from "../../context";
+import { SpineItemManager } from "../../spineItemManager";
+import { createNavigationResolver, ViewportNavigationEntry } from "../navigationResolver";
+import { createLocationResolver } from "../locationResolver";
+export declare const createManualViewportNavigator: ({ navigator, spineItemManager, currentNavigationSubject$, locator, context }: {
+    context: Context;
+    element: HTMLElement;
+    navigator: ReturnType<typeof createNavigationResolver>;
+    currentNavigationSubject$: BehaviorSubject<ViewportNavigationEntry>;
+    spineItemManager: SpineItemManager;
+    locator: ReturnType<typeof createLocationResolver>;
+}) => {
+    destroy: () => void;
+    adjustReadingOffset: (_: {
+        x: number;
+        y: number;
+    }) => boolean;
+    turnLeft: ({ allowSpineItemChange }?: {
+        allowSpineItemChange?: boolean | undefined;
+    }) => void;
+    turnRight: ({ allowSpineItemChange }?: {
+        allowSpineItemChange?: boolean | undefined;
+    }) => void;
+    goToCfi: (cfi: string, options?: {
+        animate: boolean;
+    }) => void;
+    goToPageOfCurrentChapter: (pageIndex: number) => void;
+    goToSpineItem: (indexOrId: number | string, options?: {
+        animate: boolean;
+    }) => void;
+    goToUrl: (url: string | URL) => void;
+    goToPage: (pageIndex: number) => void;
+    $: {
+        state$: import("rxjs").Observable<"start" | "end">;
+        navigation$: import("rxjs").Observable<{
+            animate: boolean;
+            lastUserExpectedNavigation: {
+                type: "navigate-from-anchor";
+                data: string;
+            };
+            x: number;
+            y: number;
+            spineItem?: import("../../spineItem/createSpineItem").SpineItem | undefined;
+            url: URL;
+        } | {
+            animate: boolean;
+            lastUserExpectedNavigation: {
+                type: "navigate-from-previous-item";
+            };
+            x: number;
+            y: number;
+            spineItem?: import("../../spineItem/createSpineItem").SpineItem | undefined;
+        } | {
+            lastUserExpectedNavigation: undefined;
+            animate: boolean;
+            x: number;
+            y: number;
+            spineItem?: import("../../spineItem/createSpineItem").SpineItem | undefined;
+        } | {
+            lastUserExpectedNavigation: {
+                type: "navigate-from-next-item";
+            };
+            animate: boolean;
+            x: number;
+            y: number;
+            spineItem?: import("../../spineItem/createSpineItem").SpineItem | undefined;
+        } | {
+            lastUserExpectedNavigation: {
+                type: "navigate-from-previous-item";
+            };
+            animate: boolean;
+            x: number;
+            y: number;
+            spineItem?: import("../../spineItem/createSpineItem").SpineItem | undefined;
+        } | {
+            lastUserExpectedNavigation: undefined;
+            animate: boolean;
+            x: number;
+            y: number;
+            spineItem?: import("../../spineItem/createSpineItem").SpineItem | undefined;
+        } | {
+            animate: boolean;
+            lastUserExpectedNavigation: {
+                type: "navigate-from-cfi";
+                data: string;
+            };
+            x: number;
+            y: number;
+            spineItem?: import("../../spineItem/createSpineItem").SpineItem | undefined;
+        } | {
+            lastUserExpectedNavigation: undefined;
+            animate: boolean;
+            x: number;
+            y: number;
+            spineItem?: import("../../spineItem/createSpineItem").SpineItem | undefined;
+        }>;
+    };
+};

package/dist/spine/viewportNavigator/panViewportNavigator.d.ts

@@ -0,0 +1,50 @@
+import { BehaviorSubject, Subject } from "rxjs";
+import { Context } from "../../context";
+import { SpineItemManager } from "../../spineItemManager";
+import { createNavigationResolver, ViewportNavigationEntry } from "../navigationResolver";
+import { createLocationResolver } from "../locationResolver";
+import { ViewportPosition } from "../../types";
+export declare const createPanViewportNavigator: ({ getCurrentViewportPosition, navigator, spineItemManager, locator, context, currentNavigationSubject$ }: {
+    context: Context;
+    element: HTMLElement;
+    navigator: ReturnType<typeof createNavigationResolver>;
+    currentNavigationSubject$: BehaviorSubject<ViewportNavigationEntry>;
+    spineItemManager: SpineItemManager;
+    locator: ReturnType<typeof createLocationResolver>;
+    getCurrentViewportPosition: () => ViewportPosition;
+}) => {
+    moveTo: ((delta: {
+        x: number;
+        y: number;
+    } | undefined, { final, start }?: {
+        start?: boolean | undefined;
+        final?: boolean | undefined;
+    }) => void) | ((args_0: {
+        x: number;
+        y: number;
+    } | undefined, args_1?: {
+        start?: boolean | undefined;
+        final?: boolean | undefined;
+    } | undefined) => void);
+    destroy: () => void;
+    adjustReadingOffset: (_: {
+        x: number;
+        y: number;
+    }) => boolean;
+    $: {
+        moveToSubject$: Subject<{
+            position: ViewportNavigationEntry;
+        }>;
+        state$: import("rxjs").Observable<"start" | "end">;
+        navigation$: import("rxjs").Observable<{
+            lastUserExpectedNavigation: {
+                type: "navigate-from-next-item";
+            } | {
+                type: "navigate-from-previous-item";
+            } | undefined;
+            x: number;
+            y: number;
+            spineItem?: import("../../spineItem/createSpineItem").SpineItem | undefined;
+        }>;
+    };
+};