@prose-reader/core 1.56.0 → 1.58.0

package/dist/spine/locationResolver.d.ts

@@ -0,0 +1,636 @@
+import { Context } from '../context/Context';
+import { SpineItem } from '../spineItem/createSpineItem';
+import { createLocationResolver as createSpineItemLocator } from '../spineItem/locationResolver';
+import { SpineItemManager } from '../spineItemManager';
+import { SpineItemNavigationPosition, SpineItemPosition, UnsafeSpineItemPosition } from '../spineItem/types';
+import { SpinePosition, UnsafeSpinePosition } from './types';
+import { SettingsManager } from '../settings/SettingsManager';
+
+export declare const createLocationResolver: ({ spineItemManager, context, spineItemLocator, settings, }: {
+    spineItemManager: SpineItemManager;
+    context: Context;
+    spineItemLocator: ReturnType<typeof createSpineItemLocator>;
+    settings: SettingsManager;
+}) => {
+    getSpinePositionFromSpineItemPosition: (spineItemPosition: SpineItemNavigationPosition | SpineItemPosition, spineItem: SpineItem) => SpinePosition;
+    getSpinePositionFromSpineItem: (spineItem: SpineItem) => SpinePosition;
+    getSpinePositionFromSpineItemAnchor: (anchor: string, spineItem: SpineItem) => SpinePosition;
+    getSpineItemPositionFromSpinePosition: ((position: UnsafeSpinePosition, spineItem: SpineItem) => UnsafeSpineItemPosition) | ((position: UnsafeSpinePosition, 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: import('@prose-reader/shared').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<(position: UnsafeSpinePosition, spineItem: SpineItem) => UnsafeSpineItemPosition>);
+    getSpineItemFromPosition: ((position: UnsafeSpinePosition) => {
+        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: import('@prose-reader/shared').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) | ((position: UnsafeSpinePosition) => ReturnType<(position: UnsafeSpinePosition) => {
+        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: import('@prose-reader/shared').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>);
+    getSpineItemFromIframe: (iframe: Element) => {
+        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: import('@prose-reader/shared').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;
+    getSpineItemPageIndexFromNode: (node: Node, offset: number | undefined, spineItemOrIndex: SpineItem | number) => number | undefined;
+    getSpineItemsFromReadingOrderPosition: (position: SpinePosition) => {
+        begin: number;
+        beginPosition: SpinePosition;
+        end: number;
+        endPosition: SpinePosition;
+    } | undefined;
+};

package/dist/spine/navigationResolver.d.ts

@@ -0,0 +1,48 @@
+import { Context } from '../context/Context';
+import { SpineItemManager } from '../spineItemManager';
+import { SpineItem } from '../spineItem/createSpineItem';
+import { createLocationResolver } from './locationResolver';
+import { createCfiLocator } from './cfiLocator';
+import { SpinePosition, UnsafeSpinePosition } from './types';
+import { SettingsManager } from '../settings/SettingsManager';
+
+export type ViewportNavigationEntry = {
+    x: number;
+    y: number;
+    spineItem?: SpineItem;
+};
+type ViewportPosition = {
+    x: number;
+    y: number;
+};
+export declare const createNavigationResolver: ({ context, spineItemManager, cfiLocator, locator, settings, }: {
+    context: Context;
+    spineItemManager: SpineItemManager;
+    cfiLocator: ReturnType<typeof createCfiLocator>;
+    locator: ReturnType<typeof createLocationResolver>;
+    settings: SettingsManager;
+}) => {
+    getNavigationForCfi: (cfi: string) => ViewportNavigationEntry;
+    getNavigationForPage: (pageIndex: number, spineItem?: SpineItem) => ViewportNavigationEntry;
+    getNavigationForLastPage: (spineItem: SpineItem) => ViewportNavigationEntry;
+    getNavigationForSpineIndexOrId: (indexOrId: number | string) => ViewportNavigationEntry;
+    getNavigationForRightPage: (position: SpinePosition) => ViewportNavigationEntry;
+    getNavigationForLeftPage: (position: UnsafeSpinePosition) => SpinePosition;
+    getNavigationForUrl: (url: string | URL) => (ViewportNavigationEntry & {
+        url: URL;
+    }) | undefined;
+    getNavigationForAnchor: (anchor: string, spineItem: SpineItem) => ViewportNavigationEntry;
+    getNavigationForPosition: (viewportPosition: ViewportPosition) => ViewportNavigationEntry;
+    getMostPredominantNavigationForPosition: (viewportPosition: ViewportPosition) => ViewportNavigationEntry;
+    wrapPositionWithSafeEdge: ((position: SpinePosition) => {
+        x: number;
+        y: number;
+    }) | ((position: SpinePosition) => ReturnType<(position: SpinePosition) => {
+        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/types.d.ts

@@ -0,0 +1,10 @@
+export type SpinePosition = {
+    x: number;
+    y: number;
+    __symbol?: `SpinePosition`;
+};
+export type UnsafeSpinePosition = {
+    x: number;
+    y: number;
+    __symbol?: `UnsafeSpinePosition` | `SpinePosition`;
+};