@prose-reader/core 1.67.0 → 1.68.0

package/dist/navigation/InternalNavigator.d.ts

@@ -0,0 +1,67 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
+import { UserNavigationEntry } from './UserNavigator';
+import { ViewportNavigator, ViewportPosition } from './viewport/ViewportNavigator';
+import { createNavigationResolver } from './resolvers/NavigationResolver';
+import { SpineItemsManager } from '../spine/SpineItemsManager';
+import { SpineLocator } from '../spine/locator/SpineLocator';
+import { DestroyableClass } from '../utils/DestroyableClass';
+import { Context } from '../context/Context';
+import { UnsafeSpineItemPosition } from '../spineItem/types';
+import { Locker } from './Locker';
+
+export type NavigationConsolidation = {
+    spineItemHeight?: number;
+    spineItemWidth?: number;
+    spineItemTop?: number;
+    spineItemLeft?: number;
+    spineItemIsUsingVerticalWriting?: boolean;
+    paginationBeginCfi?: string;
+    positionInSpineItem?: UnsafeSpineItemPosition;
+    directionFromLastNavigation?: "forward" | "backward" | "anchor";
+};
+export type InternalNavigationEntry = {
+    position: ViewportPosition;
+    id: symbol;
+    meta: {
+        triggeredBy: `user` | `restoration` | `pagination`;
+    };
+    type: `api` | `scroll`;
+    animation?: boolean | `turn` | `snap`;
+    url?: string | URL;
+    spineItem?: string | number;
+    cfi?: string;
+} & NavigationConsolidation;
+export type InternalNavigationInput = Omit<InternalNavigationEntry, "position"> & Partial<InternalNavigationEntry>;
+export type Navigation = Pick<InternalNavigationEntry, "position" | "id">;
+export declare class InternalNavigator extends DestroyableClass {
+    protected settings: ReaderSettingsManager;
+    protected context: Context;
+    protected userNavigation$: Observable<UserNavigationEntry>;
+    protected viewportController: ViewportNavigator;
+    protected navigationResolver: ReturnType<typeof createNavigationResolver>;
+    protected spineItemsManager: SpineItemsManager;
+    protected spineLocator: SpineLocator;
+    protected element$: Observable<HTMLElement>;
+    protected isUserLocked$: Observable<boolean>;
+    navigationSubject: BehaviorSubject<InternalNavigationEntry>;
+    navigated$: Observable<{
+        position: ViewportPosition;
+        id: symbol;
+        meta: {
+            triggeredBy: `user` | `restoration` | `pagination`;
+        };
+        type: `api` | `scroll`;
+        animation?: boolean | `turn` | `snap`;
+        url?: string | URL;
+        spineItem?: string | number;
+        cfi?: string;
+    } & NavigationConsolidation>;
+    navigation$: Observable<{
+        position: ViewportPosition;
+        id: symbol;
+    }>;
+    locker: Locker;
+    constructor(settings: ReaderSettingsManager, context: Context, userNavigation$: Observable<UserNavigationEntry>, viewportController: ViewportNavigator, navigationResolver: ReturnType<typeof createNavigationResolver>, spineItemsManager: SpineItemsManager, spineLocator: SpineLocator, element$: Observable<HTMLElement>, isUserLocked$: Observable<boolean>);
+    get navigation(): InternalNavigationEntry;
+}

package/dist/navigation/InternalNavigator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/navigation/Locker.d.ts

@@ -0,0 +1,7 @@
+import { BehaviorSubject } from 'rxjs';
+
+export declare class Locker {
+    protected isLockedSubject: BehaviorSubject<number>;
+    isLocked$: import('rxjs').Observable<boolean>;
+    lock(): () => void;
+}

package/dist/navigation/Navigator.d.ts

@@ -0,0 +1,70 @@
+import { Context } from '../context/Context';
+import { SpineItemsManager } from '../spine/SpineItemsManager';
+import { BehaviorSubject } from 'rxjs';
+import { Spine } from '../spine/Spine';
+import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
+import { HookManager } from '../hooks/HookManager';
+import { ViewportNavigator } from './viewport/ViewportNavigator';
+import { InternalNavigator } from './InternalNavigator';
+import { SpineItemsObserver } from '../spine/SpineItemsObserver';
+
+export declare const createNavigator: ({ spineItemsManager, spineItemsObserver, context, parentElement$, hookManager, spine, settings, }: {
+    spineItemsManager: SpineItemsManager;
+    spineItemsObserver: SpineItemsObserver;
+    context: Context;
+    parentElement$: BehaviorSubject<HTMLElement | undefined>;
+    hookManager: HookManager;
+    spine: Spine;
+    settings: ReaderSettingsManager;
+}) => {
+    destroy: () => void;
+    getNavigation: () => import('./InternalNavigator').InternalNavigationEntry;
+    internalNavigator: InternalNavigator;
+    viewportNavigator: ViewportNavigator;
+    element$: BehaviorSubject<HTMLElement>;
+    isLocked$: import('rxjs').Observable<boolean>;
+    viewportState$: import('rxjs').Observable<"free" | "busy">;
+    navigate: (to: import('./UserNavigator').UserNavigationEntry) => void;
+    lock(): () => void;
+    navigationResolver: {
+        getNavigationForUrl: (url: string | URL) => {
+            position: import('./viewport/ViewportNavigator').ViewportPosition;
+            spineItemId: string;
+        } | undefined;
+        getNavigationForSpineItemPage: (params: Omit<Parameters<typeof import('./resolvers/getNavigationForSpineItemPage').getNavigationForSpineItemPage>[0], "context" | "spineItemsManager" | "spineItemNavigationResolver" | "spineLocator">) => import('./viewport/ViewportNavigator').ViewportPosition;
+        getNavigationFromSpineItemPosition: (params: {
+            spineItemPosition: import('../spineItem/types').UnsafeSpineItemPosition;
+            spineItem: import('../spineItem/createSpineItem').SpineItem;
+        }) => import('./viewport/ViewportNavigator').ViewportPosition;
+        getNavigationForCfi: (cfi: string) => import('./viewport/ViewportNavigator').ViewportPosition | undefined;
+        getNavigationForLastPage: (spineItem: import('../spineItem/createSpineItem').SpineItem) => import('./viewport/ViewportNavigator').ViewportPosition;
+        getNavigationForSpineIndexOrId: (indexOrId: number | string | import('../spineItem/createSpineItem').SpineItem) => import('./viewport/ViewportNavigator').ViewportPosition;
+        getNavigationForPosition: (viewportPosition: import('./viewport/ViewportNavigator').ViewportPosition) => import('./viewport/ViewportNavigator').ViewportPosition;
+        getMostPredominantNavigationForPosition: (viewportPosition: import('./viewport/ViewportNavigator').ViewportPosition) => import('./viewport/ViewportNavigator').ViewportPosition;
+        wrapPositionWithSafeEdge: (position: import('./viewport/ViewportNavigator').ViewportPosition) => {
+            x: number;
+            y: number;
+        };
+        isNavigationGoingForwardFrom: (to: import('./viewport/ViewportNavigator').ViewportPosition, from: import('./viewport/ViewportNavigator').ViewportPosition) => boolean;
+        areNavigationDifferent: (a: import('./viewport/ViewportNavigator').ViewportPosition, b: import('./viewport/ViewportNavigator').ViewportPosition) => boolean;
+        arePositionsDifferent: (a: {
+            x: number;
+            y: number;
+        }, b: {
+            x: number;
+            y: number;
+        }) => boolean;
+        getAdjustedPositionForSpread: (position: import('./viewport/ViewportNavigator').ViewportPosition) => import('./viewport/ViewportNavigator').ViewportPosition;
+        spineItemNavigator: {
+            getNavigationForLastPage: (spineItem: import('../spineItem/createSpineItem').SpineItem) => import('../spineItem/types').SafeSpineItemPosition;
+            getNavigationForPosition: (spineItem: import('../spineItem/createSpineItem').SpineItem, position: import('../spineItem/types').UnsafeSpineItemPosition) => import('../spineItem/types').SafeSpineItemPosition;
+            getNavigationFromNode: (spineItem: import('../spineItem/createSpineItem').SpineItem, node: Node, offset: number) => import('../spineItem/types').SafeSpineItemPosition;
+        };
+    };
+    navigation$: import('rxjs').Observable<{
+        position: import('./viewport/ViewportNavigator').ViewportPosition;
+        id: symbol;
+    }>;
+    getElement: () => HTMLElement;
+};
+export type Navigator = ReturnType<typeof createNavigator>;

package/dist/navigation/UserNavigator.d.ts

@@ -0,0 +1,27 @@
+import { Observable, Subject } from 'rxjs';
+import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
+import { ViewportPosition } from './viewport/ViewportNavigator';
+import { Context } from '../context/Context';
+import { DestroyableClass } from '../utils/DestroyableClass';
+import { Locker } from './Locker';
+
+export type UserNavigationEntry = {
+    position?: ViewportPosition;
+    spineItem?: number | string;
+    url?: string | URL;
+    cfi?: string;
+    animation?: boolean | "turn" | "snap";
+    type?: "api" | "scroll";
+    direction?: "left" | "right" | "top" | "bottom";
+};
+export declare class UserNavigator extends DestroyableClass {
+    protected settings: ReaderSettingsManager;
+    protected element$: Observable<HTMLElement>;
+    protected context: Context;
+    protected scrollHappeningFromBrowser$: Observable<unknown>;
+    protected navigationSubject: Subject<UserNavigationEntry>;
+    locker: Locker;
+    navigation$: Observable<UserNavigationEntry>;
+    constructor(settings: ReaderSettingsManager, element$: Observable<HTMLElement>, context: Context, scrollHappeningFromBrowser$: Observable<unknown>);
+    navigate(to: UserNavigationEntry): void;
+}

package/dist/navigation/consolidation/mapUserNavigationToInternal.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from 'rxjs';
+import { UserNavigationEntry } from '../UserNavigator';
+import { InternalNavigationEntry, InternalNavigationInput } from '../InternalNavigator';
+
+export declare const mapUserNavigationToInternal: (stream: Observable<[UserNavigationEntry, InternalNavigationEntry]>) => Observable<{
+    navigation: InternalNavigationInput;
+    previousNavigation: InternalNavigationEntry;
+}>;

package/dist/navigation/consolidation/withCfiPosition.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+import { InternalNavigationInput } from '../InternalNavigator';
+import { NavigationResolver } from '../resolvers/NavigationResolver';
+
+type Navigation = {
+    navigation: InternalNavigationInput;
+};
+export declare const withCfiPosition: ({ navigationResolver }: {
+    navigationResolver: NavigationResolver;
+}) => <N extends Navigation>(stream: Observable<N>) => Observable<N>;
+export {};

package/dist/navigation/consolidation/withDirection.d.ts

@@ -0,0 +1,22 @@
+import { Observable } from 'rxjs';
+import { InternalNavigationEntry, InternalNavigationInput } from '../InternalNavigator';
+import { Context } from '../../context/Context';
+import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
+
+type Navigation = {
+    navigation: InternalNavigationInput;
+    previousNavigation: InternalNavigationEntry;
+};
+export declare const getOrGuessDirection: ({ navigation, previousNavigation, settings, }: {
+    previousNavigation: InternalNavigationEntry;
+    navigation: InternalNavigationInput;
+    context: Context;
+    settings: ReaderSettingsManager;
+}) => InternalNavigationEntry["directionFromLastNavigation"];
+export declare const withDirection: ({ context, settings, }: {
+    context: Context;
+    settings: ReaderSettingsManager;
+}) => (stream: Observable<Navigation>) => Observable<Navigation & {
+    direction: InternalNavigationEntry["directionFromLastNavigation"];
+}>;
+export {};

package/dist/navigation/consolidation/withFallbackPosition.d.ts

@@ -0,0 +1,13 @@
+import { Observable } from 'rxjs';
+import { InternalNavigationEntry, InternalNavigationInput } from '../InternalNavigator';
+import { SpineItemsManager } from '../../spine/SpineItemsManager';
+import { NavigationResolver } from '../resolvers/NavigationResolver';
+
+export declare const withFallbackPosition: ({ spineItemsManager, navigationResolver, }: {
+    spineItemsManager: SpineItemsManager;
+    navigationResolver: NavigationResolver;
+}) => <Navigation extends {
+    navigation: InternalNavigationInput;
+}>(stream: Observable<Navigation>) => Observable<Omit<Navigation, "navigation"> & {
+    navigation: InternalNavigationEntry;
+}>;

package/dist/navigation/consolidation/withPaginationInfo.d.ts

@@ -0,0 +1,10 @@
+import { Observable } from 'rxjs';
+import { InternalNavigationEntry } from '../InternalNavigator';
+import { PaginationInfo } from '../../pagination/Pagination';
+
+type Navigation = {
+    navigation: InternalNavigationEntry;
+    pagination: PaginationInfo;
+};
+export declare const withPaginationInfo: () => <N extends Navigation>(stream: Observable<N>) => Observable<N>;
+export {};

package/dist/navigation/consolidation/withSpineItem.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import { InternalNavigationInput } from '../InternalNavigator';
+import { Context } from '../../context/Context';
+import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
+import { SpineItemsManager } from '../../spine/SpineItemsManager';
+import { NavigationResolver } from '../resolvers/NavigationResolver';
+import { SpineLocator } from '../../spine/locator/SpineLocator';
+
+type Navigation = {
+    navigation: InternalNavigationInput;
+};
+export declare const withSpineItem: ({ settings, spineItemsManager, navigationResolver, spineLocator, }: {
+    context: Context;
+    settings: ReaderSettingsManager;
+    spineItemsManager: SpineItemsManager;
+    navigationResolver: NavigationResolver;
+    spineLocator: SpineLocator;
+}) => <N extends Navigation>(stream: Observable<N>) => Observable<N>;
+export {};

package/dist/navigation/consolidation/withSpineItemLayoutInfo.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+import { InternalNavigationEntry, InternalNavigationInput } from '../InternalNavigator';
+import { SpineItemsManager } from '../../spine/SpineItemsManager';
+
+type Navigation = {
+    navigation: InternalNavigationInput | InternalNavigationEntry;
+};
+export declare const withSpineItemLayoutInfo: ({ spineItemsManager }: {
+    spineItemsManager: SpineItemsManager;
+}) => <N extends Navigation>(stream: Observable<N>) => Observable<N>;
+export {};

package/dist/navigation/consolidation/withSpineItemPosition.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import { InternalNavigationEntry, InternalNavigationInput } from '../InternalNavigator';
+import { Context } from '../../context/Context';
+import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
+import { SpineItemsManager } from '../../spine/SpineItemsManager';
+import { NavigationResolver } from '../resolvers/NavigationResolver';
+import { SpineLocator } from '../../spine/locator/SpineLocator';
+
+type Navigation = {
+    navigation: InternalNavigationEntry | InternalNavigationInput;
+};
+export declare const withSpineItemPosition: ({ settings, spineItemsManager, spineLocator, navigationResolver, }: {
+    context: Context;
+    settings: ReaderSettingsManager;
+    spineItemsManager: SpineItemsManager;
+    navigationResolver: NavigationResolver;
+    spineLocator: SpineLocator;
+}) => <N extends Navigation>(stream: Observable<N>) => Observable<N>;
+export {};

package/dist/navigation/consolidation/withUrlInfo.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+import { InternalNavigationInput } from '../InternalNavigator';
+import { NavigationResolver } from '../resolvers/NavigationResolver';
+
+type Navigation = {
+    navigation: InternalNavigationInput;
+};
+export declare const withUrlInfo: ({ navigationResolver }: {
+    navigationResolver: NavigationResolver;
+}) => <N extends Navigation>(stream: Observable<N>) => Observable<N>;
+export {};

package/dist/navigation/resolvers/NavigationResolver.d.ts

@@ -0,0 +1,51 @@
+import { Context } from '../../context/Context';
+import { SpineItemsManager } from '../../spine/SpineItemsManager';
+import { SpineItem } from '../../spineItem/createSpineItem';
+import { SpineLocator } from '../../spine/locator/SpineLocator';
+import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
+import { ViewportPosition } from '../viewport/ViewportNavigator';
+import { SafeSpineItemPosition, UnsafeSpineItemPosition } from '../../spineItem/types';
+import { getNavigationForSpineItemPage } from './getNavigationForSpineItemPage';
+
+export declare const NAMESPACE = "spineNavigator";
+export type NavigationResolver = ReturnType<typeof createNavigationResolver>;
+export declare const createNavigationResolver: ({ context, spineItemsManager, locator, settings, }: {
+    context: Context;
+    spineItemsManager: SpineItemsManager;
+    locator: SpineLocator;
+    settings: ReaderSettingsManager;
+}) => {
+    getNavigationForUrl: (url: string | URL) => {
+        position: ViewportPosition;
+        spineItemId: string;
+    } | undefined;
+    getNavigationForSpineItemPage: (params: Omit<Parameters<typeof getNavigationForSpineItemPage>[0], "context" | "spineItemsManager" | "spineItemNavigationResolver" | "spineLocator">) => ViewportPosition;
+    getNavigationFromSpineItemPosition: (params: {
+        spineItemPosition: UnsafeSpineItemPosition;
+        spineItem: SpineItem;
+    }) => ViewportPosition;
+    getNavigationForCfi: (cfi: string) => ViewportPosition | undefined;
+    getNavigationForLastPage: (spineItem: SpineItem) => ViewportPosition;
+    getNavigationForSpineIndexOrId: (indexOrId: number | string | SpineItem) => ViewportPosition;
+    getNavigationForPosition: (viewportPosition: ViewportPosition) => ViewportPosition;
+    getMostPredominantNavigationForPosition: (viewportPosition: ViewportPosition) => ViewportPosition;
+    wrapPositionWithSafeEdge: (position: ViewportPosition) => {
+        x: number;
+        y: number;
+    };
+    isNavigationGoingForwardFrom: (to: ViewportPosition, from: ViewportPosition) => boolean;
+    areNavigationDifferent: (a: ViewportPosition, b: ViewportPosition) => boolean;
+    arePositionsDifferent: (a: {
+        x: number;
+        y: number;
+    }, b: {
+        x: number;
+        y: number;
+    }) => boolean;
+    getAdjustedPositionForSpread: (position: ViewportPosition) => ViewportPosition;
+    spineItemNavigator: {
+        getNavigationForLastPage: (spineItem: SpineItem) => SafeSpineItemPosition;
+        getNavigationForPosition: (spineItem: SpineItem, position: UnsafeSpineItemPosition) => SafeSpineItemPosition;
+        getNavigationFromNode: (spineItem: SpineItem, node: Node, offset: number) => SafeSpineItemPosition;
+    };
+};

package/dist/navigation/resolvers/getAdjustedPositionForSpread.d.ts

@@ -0,0 +1,7 @@
+import { ViewportPosition } from '../viewport/ViewportNavigator';
+
+export declare const getAdjustedPositionForSpread: ({ position: { x, y }, pageSizeWidth, visibleAreaRectWidth, }: {
+    position: ViewportPosition;
+    pageSizeWidth: number;
+    visibleAreaRectWidth: number;
+}) => ViewportPosition;

package/dist/navigation/resolvers/getNavigationForPosition.d.ts

@@ -0,0 +1,11 @@
+import { Context } from '../../context/Context';
+import { SpineLocator } from '../../spine/locator/SpineLocator';
+import { SpineItemNavigationResolver } from '../../spineItem/navigationResolver';
+import { ViewportPosition } from '../viewport/ViewportNavigator';
+
+export declare const getNavigationForPosition: ({ viewportPosition, spineLocator, context, spineItemNavigationResolver, }: {
+    viewportPosition: ViewportPosition;
+    spineLocator: SpineLocator;
+    context: Context;
+    spineItemNavigationResolver: SpineItemNavigationResolver;
+}) => ViewportPosition;

package/dist/navigation/resolvers/getNavigationForSpineItemPage.d.ts

@@ -0,0 +1,15 @@
+import { Context } from '../../context/Context';
+import { SpineLocator } from '../../spine/locator/SpineLocator';
+import { SpineItem } from '../../spineItem/createSpineItem';
+import { SpineItemNavigationResolver } from '../../spineItem/navigationResolver';
+import { SpineItemsManager } from '../../spine/SpineItemsManager';
+import { ViewportPosition } from '../viewport/ViewportNavigator';
+
+export declare const getNavigationForSpineItemPage: ({ pageIndex, spineItemsManager, spineItemId, context, spineLocator, spineItemNavigationResolver, }: {
+    pageIndex: number;
+    spineItemId: SpineItem | number | string;
+    spineItemsManager: SpineItemsManager;
+    spineItemNavigationResolver: SpineItemNavigationResolver;
+    spineLocator: SpineLocator;
+    context: Context;
+}) => ViewportPosition;

package/dist/navigation/resolvers/getNavigationForUrl.d.ts

@@ -0,0 +1,16 @@
+import { Context } from '../../context/Context';
+import { ViewportPosition } from '../viewport/ViewportNavigator';
+import { SpineLocator } from '../../spine/locator/SpineLocator';
+import { SpineItemsManager } from '../../spine/SpineItemsManager';
+
+export declare const getNavigationForUrl: ({ context, spineItemsManager, spineLocator, url, pageSizeWidth, visibleAreaRectWidth, }: {
+    url: string | URL;
+    spineItemsManager: SpineItemsManager;
+    spineLocator: SpineLocator;
+    context: Context;
+    pageSizeWidth: number;
+    visibleAreaRectWidth: number;
+}) => {
+    position: ViewportPosition;
+    spineItemId: string;
+} | undefined;

package/dist/navigation/resolvers/getNavigationFromSpineItemPosition.d.ts

@@ -0,0 +1,13 @@
+import { Context } from '../../context/Context';
+import { SpineLocator } from '../../spine/locator/SpineLocator';
+import { SpineItem } from '../../spineItem/createSpineItem';
+import { SpineItemLocator } from '../../spineItem/locationResolver';
+import { UnsafeSpineItemPosition } from '../../spineItem/types';
+
+export declare const getNavigationFromSpineItemPosition: ({ spineItem, spineItemPosition, spineLocator, spineItemLocator, context, }: {
+    spineItemPosition: UnsafeSpineItemPosition;
+    spineItem: SpineItem;
+    spineLocator: SpineLocator;
+    spineItemLocator: SpineItemLocator;
+    context: Context;
+}) => import('../viewport/ViewportNavigator').ViewportPosition;

package/dist/navigation/resolvers/wrapPositionWithSafeEdge.d.ts

@@ -0,0 +1,14 @@
+import { SpineItemsManager } from '../../spine/SpineItemsManager';
+import { ViewportPosition } from '../viewport/ViewportNavigator';
+
+export declare const NAMESPACE = "spineNavigator";
+export declare const wrapPositionWithSafeEdge: ({ position, isRTL, pageSizeWidth, pageSizeHeight, spineItemsManager, }: {
+    position: ViewportPosition;
+    isRTL: boolean;
+    pageSizeWidth: number;
+    pageSizeHeight: number;
+    spineItemsManager: SpineItemsManager;
+}) => {
+    x: number;
+    y: number;
+};

package/dist/navigation/restoration/restoreNavigationForControlledPageTurnMode.d.ts

@@ -0,0 +1,11 @@
+import { SpineLocator } from '../../spine/locator/SpineLocator';
+import { SpineItemsManager } from '../../spine/SpineItemsManager';
+import { InternalNavigationEntry } from '../InternalNavigator';
+import { NavigationResolver } from '../resolvers/NavigationResolver';
+
+export declare const restoreNavigationForControlledPageTurnMode: ({ spineLocator, navigation, navigationResolver, spineItemsManager, }: {
+    navigation: InternalNavigationEntry;
+    spineLocator: SpineLocator;
+    navigationResolver: NavigationResolver;
+    spineItemsManager: SpineItemsManager;
+}) => import('../viewport/ViewportNavigator').ViewportPosition;

package/dist/navigation/restoration/restoreNavigationForControlledPageTurnMode.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/navigation/restoration/restorePosition.d.ts

@@ -0,0 +1,18 @@
+import { Context } from '../../context/Context';
+import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
+import { SpineLocator } from '../../spine/locator/SpineLocator';
+import { SpineItemLocator } from '../../spineItem/locationResolver';
+import { SpineItemsManager } from '../../spine/SpineItemsManager';
+import { InternalNavigationEntry } from '../InternalNavigator';
+import { NavigationResolver } from '../resolvers/NavigationResolver';
+import { ViewportPosition } from '../viewport/ViewportNavigator';
+
+export declare const restorePosition: ({ navigation, spineItemsManager, settings, spineLocator, navigationResolver, }: {
+    spineLocator: SpineLocator;
+    settings: ReaderSettingsManager;
+    navigationResolver: NavigationResolver;
+    navigation: InternalNavigationEntry;
+    spineItemsManager: SpineItemsManager;
+    spineItemLocator: SpineItemLocator;
+    context: Context;
+}) => ViewportPosition;

package/dist/navigation/restoration/withRestoredPosition.d.ts

@@ -0,0 +1,21 @@
+import { Observable } from 'rxjs';
+import { InternalNavigationEntry } from '../InternalNavigator';
+import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
+import { SpineLocator } from '../../spine/locator/SpineLocator';
+import { SpineItemsManager } from '../../spine/SpineItemsManager';
+import { NavigationResolver } from '../resolvers/NavigationResolver';
+import { SpineItemLocator } from '../../spineItem/locationResolver';
+import { Context } from '../../context/Context';
+
+type Navigation = {
+    navigation: InternalNavigationEntry;
+};
+export declare const withRestoredPosition: ({ spineItemsManager, settings, spineLocator, navigationResolver, spineItemLocator, context, }: {
+    spineLocator: SpineLocator;
+    navigationResolver: NavigationResolver;
+    spineItemsManager: SpineItemsManager;
+    settings: ReaderSettingsManager;
+    spineItemLocator: SpineItemLocator;
+    context: Context;
+}) => <N extends Navigation>(stream: Observable<N>) => Observable<N>;
+export {};

package/dist/navigation/tests/SpineItemsManagerMock.d.ts

@@ -0,0 +1,27 @@
+import { Subject } from 'rxjs';
+
+export type Item = {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+};
+export declare class SpineItemsManagerMock {
+    items: Item[];
+    layout$: Subject<unknown>;
+    load(items: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+        width: number;
+        height: number;
+    }[]): void;
+    get(id: number): Item | undefined;
+    getAll(): Item[];
+    getLength(): number;
+    getSpineItemIndex(item: Item): number;
+    getAbsolutePositionOf(spineItem: any): Item;
+}

package/dist/navigation/tests/utils.d.ts

@@ -0,0 +1,12 @@
+import { Context } from '../../context/Context';
+import { InternalNavigator } from '../InternalNavigator';
+import { UserNavigator } from '../UserNavigator';
+import { Item, SpineItemsManagerMock } from './SpineItemsManagerMock';
+
+export declare const generateItems: (size: number, number: number) => Item[];
+export declare const createNavigator: () => {
+    internalNavigator: InternalNavigator;
+    userNavigator: UserNavigator;
+    context: Context;
+    spineItemsManagerMock: SpineItemsManagerMock;
+};

package/dist/navigation/viewport/ViewportNavigator.d.ts

@@ -0,0 +1,36 @@
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
+import { HookManager } from '../../hooks/HookManager';
+import { Context } from '../../context/Context';
+import { DestroyableClass } from '../../utils/DestroyableClass';
+import { Spine } from '../../spine/Spine';
+
+export type ViewportPosition = {
+    x: number;
+    y: number;
+    __symbol?: `ViewportPosition`;
+    spineItem?: false;
+};
+export type ViewportNavigationEntry = {
+    position: ViewportPosition;
+    animation?: boolean | "turn" | "snap";
+};
+export declare class ViewportNavigator extends DestroyableClass {
+    protected settings: ReaderSettingsManager;
+    protected viewportElement$: BehaviorSubject<HTMLElement>;
+    protected hookManager: HookManager;
+    protected context: Context;
+    protected spine: Spine;
+    protected navigateSubject: Subject<ViewportNavigationEntry>;
+    protected scrollingSubject: BehaviorSubject<boolean>;
+    isNavigating$: Observable<boolean>;
+    isScrolling$: Observable<boolean>;
+    layout$: Observable<unknown>;
+    constructor(settings: ReaderSettingsManager, viewportElement$: BehaviorSubject<HTMLElement>, hookManager: HookManager, context: Context, spine: Spine);
+    protected setViewportPosition({ x, y }: ViewportPosition): void;
+    navigate(navigation: ViewportNavigationEntry): void;
+    get viewportPosition(): {
+        x: number;
+        y: number;
+    };
+}

package/dist/navigation/viewport/getScaledDownPosition.d.ts

@@ -0,0 +1,11 @@
+import { Spine } from '../../spine/Spine';
+import { ViewportPosition } from './ViewportNavigator';
+
+export declare const getScaledDownPosition: ({ position: { x, y }, spine, element, }: {
+    position: ViewportPosition;
+    spine: Spine;
+    element: HTMLElement;
+}) => {
+    x: number;
+    y: number;
+};

package/dist/pagination/Pagination.d.ts

@@ -0,0 +1,26 @@
+import { BehaviorSubject } from 'rxjs';
+import { Context } from '../context/Context';
+import { SpineItemsManager } from '../spine/SpineItemsManager';
+import { DestroyableClass } from '../utils/DestroyableClass';
+
+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;
+    navigationId?: symbol;
+};
+export declare class Pagination extends DestroyableClass {
+    protected context: Context;
+    protected spineItemsManager: SpineItemsManager;
+    protected paginationSubject: BehaviorSubject<PaginationInfo>;
+    pagination$: import('rxjs').Observable<PaginationInfo>;
+    constructor(context: Context, spineItemsManager: SpineItemsManager);
+    update(pagination: Partial<PaginationInfo>): void;
+    get pagination(): PaginationInfo;
+    destroy(): void;
+}