@prose-reader/core 1.72.0 → 1.73.0

package/dist/navigation/InternalNavigator.d.ts

@@ -3,12 +3,11 @@ 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';
+import { Spine } from '../spine/Spine';
 
 export type NavigationConsolidation = {
     spineItemHeight?: number;
@@ -40,8 +39,7 @@ export declare class InternalNavigator extends DestroyableClass {
     protected userNavigation$: Observable<UserNavigationEntry>;
     protected viewportController: ViewportNavigator;
     protected navigationResolver: ReturnType<typeof createNavigationResolver>;
-    protected spineItemsManager: SpineItemsManager;
-    protected spineLocator: SpineLocator;
+    protected spine: Spine;
     protected element$: Observable<HTMLElement>;
     protected isUserLocked$: Observable<boolean>;
     navigationSubject: BehaviorSubject<InternalNavigationEntry>;
@@ -62,6 +60,6 @@ export declare class InternalNavigator extends DestroyableClass {
         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>);
+    constructor(settings: ReaderSettingsManager, context: Context, userNavigation$: Observable<UserNavigationEntry>, viewportController: ViewportNavigator, navigationResolver: ReturnType<typeof createNavigationResolver>, spine: Spine, element$: Observable<HTMLElement>, isUserLocked$: Observable<boolean>);
     get navigation(): InternalNavigationEntry;
 }

package/dist/navigation/Navigator.d.ts

@@ -6,11 +6,9 @@ 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, }: {
+export declare const createNavigator: ({ spineItemsManager, context, parentElement$, hookManager, spine, settings, }: {
     spineItemsManager: SpineItemsManager;
-    spineItemsObserver: SpineItemsObserver;
     context: Context;
     parentElement$: BehaviorSubject<HTMLElement | undefined>;
     hookManager: HookManager;

package/dist/navigation/UserNavigator.d.ts

@@ -4,6 +4,7 @@ import { ViewportPosition } from './viewport/ViewportNavigator';
 import { Context } from '../context/Context';
 import { DestroyableClass } from '../utils/DestroyableClass';
 import { Locker } from './Locker';
+import { Spine } from '../spine/Spine';
 
 export type UserNavigationEntry = {
     position?: ViewportPosition;
@@ -19,9 +20,10 @@ export declare class UserNavigator extends DestroyableClass {
     protected element$: Observable<HTMLElement>;
     protected context: Context;
     protected scrollHappeningFromBrowser$: Observable<unknown>;
+    protected spine: Spine;
     protected navigationSubject: Subject<UserNavigationEntry>;
     locker: Locker;
     navigation$: Observable<UserNavigationEntry>;
-    constructor(settings: ReaderSettingsManager, element$: Observable<HTMLElement>, context: Context, scrollHappeningFromBrowser$: Observable<unknown>);
+    constructor(settings: ReaderSettingsManager, element$: Observable<HTMLElement>, context: Context, scrollHappeningFromBrowser$: Observable<unknown>, spine: Spine);
     navigate(to: UserNavigationEntry): void;
 }

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

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

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

@@ -1,6 +1,5 @@
 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';
@@ -10,7 +9,6 @@ type Navigation = {
     navigation: InternalNavigationEntry | InternalNavigationInput;
 };
 export declare const withSpineItemPosition: ({ settings, spineItemsManager, spineLocator, navigationResolver, }: {
-    context: Context;
     settings: ReaderSettingsManager;
     spineItemsManager: SpineItemsManager;
     navigationResolver: NavigationResolver;

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

@@ -6,14 +6,16 @@ import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
 import { ViewportPosition } from '../viewport/ViewportNavigator';
 import { SafeSpineItemPosition, UnsafeSpineItemPosition } from '../../spineItem/types';
 import { getNavigationForSpineItemPage } from './getNavigationForSpineItemPage';
+import { SpineLayout } from '../../spine/SpineLayout';
 
 export declare const NAMESPACE = "spineNavigator";
 export type NavigationResolver = ReturnType<typeof createNavigationResolver>;
-export declare const createNavigationResolver: ({ context, spineItemsManager, locator, settings, }: {
+export declare const createNavigationResolver: ({ context, spineItemsManager, locator, settings, spineLayout, }: {
     context: Context;
     spineItemsManager: SpineItemsManager;
     locator: SpineLocator;
     settings: ReaderSettingsManager;
+    spineLayout: SpineLayout;
 }) => {
     getNavigationForUrl: (url: string | URL) => {
         position: ViewportPosition;

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

@@ -1,13 +1,15 @@
 import { SpineItemsManager } from '../../spine/SpineItemsManager';
+import { SpineLayout } from '../../spine/SpineLayout';
 import { ViewportPosition } from '../viewport/ViewportNavigator';
 
 export declare const NAMESPACE = "spineNavigator";
-export declare const getAdjustedPositionWithSafeEdge: ({ position, isRTL, pageSizeHeight, spineItemsManager, visibleAreaRectWidth, }: {
+export declare const getAdjustedPositionWithSafeEdge: ({ position, isRTL, pageSizeHeight, spineItemsManager, visibleAreaRectWidth, spineLayout, }: {
     position: ViewportPosition;
     isRTL: boolean;
     pageSizeHeight: number;
     spineItemsManager: SpineItemsManager;
     visibleAreaRectWidth: number;
+    spineLayout: SpineLayout;
 }) => {
     x: number;
     y: number;

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

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

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

@@ -6,8 +6,9 @@ import { SpineItemsManager } from '../../spine/SpineItemsManager';
 import { InternalNavigationEntry } from '../InternalNavigator';
 import { NavigationResolver } from '../resolvers/NavigationResolver';
 import { ViewportPosition } from '../viewport/ViewportNavigator';
+import { SpineLayout } from '../../spine/SpineLayout';
 
-export declare const restorePosition: ({ navigation, spineItemsManager, settings, spineLocator, navigationResolver, }: {
+export declare const restorePosition: ({ navigation, spineItemsManager, settings, spineLocator, navigationResolver, spineLayout, }: {
     spineLocator: SpineLocator;
     settings: ReaderSettingsManager;
     navigationResolver: NavigationResolver;
@@ -15,4 +16,5 @@ export declare const restorePosition: ({ navigation, spineItemsManager, settings
     spineItemsManager: SpineItemsManager;
     spineItemLocator: SpineItemLocator;
     context: Context;
+    spineLayout: SpineLayout;
 }) => ViewportPosition;

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

@@ -1,21 +1,17 @@
 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';
+import { Spine } from '../../spine/Spine';
 
 type Navigation = {
     navigation: InternalNavigationEntry;
 };
-export declare const withRestoredPosition: ({ spineItemsManager, settings, spineLocator, navigationResolver, spineItemLocator, context, }: {
-    spineLocator: SpineLocator;
+export declare const withRestoredPosition: ({ settings, navigationResolver, context, spine, }: {
     navigationResolver: NavigationResolver;
-    spineItemsManager: SpineItemsManager;
     settings: ReaderSettingsManager;
-    spineItemLocator: SpineItemLocator;
     context: Context;
+    spine: Spine;
 }) => <N extends Navigation>(stream: Observable<N>) => Observable<N>;
 export {};

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

@@ -1,4 +1,4 @@
-import { Subject } from 'rxjs';
+import { BehaviorSubject, Subject } from 'rxjs';
 
 export type Item = {
     left: number;
@@ -11,6 +11,7 @@ export type Item = {
 export declare class SpineItemsManagerMock {
     items: Item[];
     layout$: Subject<unknown>;
+    items$: BehaviorSubject<Item[]>;
     load(items: {
         left: number;
         top: number;

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

@@ -2,6 +2,7 @@ import { Context } from '../../context/Context';
 import { InternalNavigator } from '../InternalNavigator';
 import { UserNavigator } from '../UserNavigator';
 import { Item, SpineItemsManagerMock } from './SpineItemsManagerMock';
+import { Spine } from '../../spine/Spine';
 
 export declare const generateItems: (size: number, number: number) => Item[];
 export declare const createNavigator: () => {
@@ -9,4 +10,5 @@ export declare const createNavigator: () => {
     userNavigator: UserNavigator;
     context: Context;
     spineItemsManagerMock: SpineItemsManagerMock;
+    spine: Spine;
 };

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

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

package/dist/reader.d.ts

@@ -1,21 +1,16 @@
 import { Subject } from 'rxjs';
-import { Context } from './context/Context';
-import { Manifest } from '@prose-reader/shared';
+import { Context, ContextState } from './context/Context';
 import { HookManager } from './hooks/HookManager';
 import { CoreInputSettings } from './settings/types';
 import { resolveCfi } from './cfi/lookup/resolveCfi';
-import { SpineItemsObserver } from './spine/SpineItemsObserver';
 import { SpineItemsManager } from './spine/SpineItemsManager';
 import { SettingsInterface } from './settings/SettingsInterface';
 import { Spine } from './spine/Spine';
+import { SpineItem } from './spineItem/createSpineItem';
 
 export type CreateReaderOptions = Partial<CoreInputSettings>;
 export type CreateReaderParameters = CreateReaderOptions;
 export type ContextSettings = Partial<CoreInputSettings>;
-export type LoadOptions = {
-    cfi?: string | null;
-    containerElement: HTMLElement;
-};
 export type ReaderInternal = ReturnType<typeof createReader>;
 export declare const createReader: (inputSettings: CreateReaderOptions) => {
     context: Context;
@@ -27,16 +22,256 @@ export declare const createReader: (inputSettings: CreateReaderOptions) => {
             start: number;
             endNode: Node;
             end: number;
-        }, item: Manifest[`spineItems`][number]) => {
+        }, item: import('@prose-reader/shared').Manifest[`spineItems`][number]) => {
             start: string;
             end: string;
         };
+        generateCfiForSpineItemPage: (params: {
+            pageIndex: number;
+            spineItem: SpineItem;
+        }) => string;
         resolveCfi: (params: Omit<Parameters<typeof resolveCfi>[0], "spineItemsManager">) => {
             node: Node | undefined;
             offset: number | undefined;
             spineItemIndex: 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;
+                };
+                overlayElement: HTMLDivElement;
+                adjustPositionOfElement: ({ right, left, top, }: {
+                    right?: number;
+                    left?: number;
+                    top?: number;
+                }) => void;
+                getElementDimensions: () => {
+                    width: number;
+                    height: number;
+                    x: number;
+                    y: number;
+                    bottom: number;
+                    left: number;
+                    right: number;
+                    top: number;
+                    toJSON(): any;
+                };
+                getHtmlFromResource: (response: Response) => Promise<string>;
+                getResource: () => Promise<Response>;
+                translateFramePositionIntoPage: (position: {
+                    clientX: number;
+                    clientY: number;
+                }) => {
+                    clientX: number;
+                    clientY: number;
+                };
+                injectStyle: (cssText: string) => void;
+                load: () => void;
+                unload: () => void;
+                frame: import('./spineItem/frame/FrameItem').FrameItem;
+                element: HTMLElement;
+                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+                getViewPortInformation: () => {
+                    computedScale: number;
+                    computedWidthScale: number;
+                    viewportDimensions: {
+                        width: number;
+                        height: number;
+                    };
+                } | undefined;
+                isImageType: () => boolean;
+                isReady: () => boolean;
+                destroy: () => void;
+                readingDirection: "ltr" | "rtl" | undefined;
+                isUsingVerticalWriting: () => boolean | undefined;
+                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>;
+                };
+            };
         } | {
             spineItemIndex: 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;
+                };
+                overlayElement: HTMLDivElement;
+                adjustPositionOfElement: ({ right, left, top, }: {
+                    right?: number;
+                    left?: number;
+                    top?: number;
+                }) => void;
+                getElementDimensions: () => {
+                    width: number;
+                    height: number;
+                    x: number;
+                    y: number;
+                    bottom: number;
+                    left: number;
+                    right: number;
+                    top: number;
+                    toJSON(): any;
+                };
+                getHtmlFromResource: (response: Response) => Promise<string>;
+                getResource: () => Promise<Response>;
+                translateFramePositionIntoPage: (position: {
+                    clientX: number;
+                    clientY: number;
+                }) => {
+                    clientX: number;
+                    clientY: number;
+                };
+                injectStyle: (cssText: string) => void;
+                load: () => void;
+                unload: () => void;
+                frame: import('./spineItem/frame/FrameItem').FrameItem;
+                element: HTMLElement;
+                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+                getViewPortInformation: () => {
+                    computedScale: number;
+                    computedWidthScale: number;
+                    viewportDimensions: {
+                        width: number;
+                        height: number;
+                    };
+                } | undefined;
+                isImageType: () => boolean;
+                isReady: () => boolean;
+                destroy: () => void;
+                readingDirection: "ltr" | "rtl" | undefined;
+                isUsingVerticalWriting: () => boolean | undefined;
+                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>;
+                };
+            };
             node?: undefined;
             offset?: undefined;
         } | undefined;
@@ -44,7 +279,7 @@ export declare const createReader: (inputSettings: CreateReaderOptions) => {
     navigation: {
         viewportFree$: import('rxjs').Observable<"free">;
         viewportBusy$: import('rxjs').Observable<"busy">;
-        readonly viewportPosition: {
+        getViewportPosition: () => {
             x: number;
             y: number;
         };
@@ -60,11 +295,11 @@ export declare const createReader: (inputSettings: CreateReaderOptions) => {
             getNavigationForSpineItemPage: (params: Omit<Parameters<typeof import('./navigation/resolvers/getNavigationForSpineItemPage').getNavigationForSpineItemPage>[0], "context" | "spineItemsManager" | "spineItemNavigationResolver" | "spineLocator">) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
             getNavigationFromSpineItemPosition: (params: {
                 spineItemPosition: import('./spineItem/types').UnsafeSpineItemPosition;
-                spineItem: import('./spineItem/createSpineItem').SpineItem;
+                spineItem: SpineItem;
             }) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
             getNavigationForCfi: (cfi: string) => import('./navigation/viewport/ViewportNavigator').ViewportPosition | undefined;
-            getNavigationForLastPage: (spineItem: import('./spineItem/createSpineItem').SpineItem) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
-            getNavigationForSpineIndexOrId: (indexOrId: number | string | import('./spineItem/createSpineItem').SpineItem) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
+            getNavigationForLastPage: (spineItem: SpineItem) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
+            getNavigationForSpineIndexOrId: (indexOrId: number | string | SpineItem) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
             getNavigationForPosition: (viewportPosition: import('./navigation/viewport/ViewportNavigator').ViewportPosition) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
             getMostPredominantNavigationForPosition: (viewportPosition: import('./navigation/viewport/ViewportNavigator').ViewportPosition) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
             getAdjustedPositionWithSafeEdge: (position: import('./navigation/viewport/ViewportNavigator').ViewportPosition) => {
@@ -82,16 +317,16 @@ export declare const createReader: (inputSettings: CreateReaderOptions) => {
             }) => boolean;
             getAdjustedPositionForSpread: (position: import('./navigation/viewport/ViewportNavigator').ViewportPosition) => import('./navigation/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;
+                getNavigationForLastPage: (spineItem: SpineItem) => import('./spineItem/types').SafeSpineItemPosition;
+                getNavigationForPosition: (spineItem: SpineItem, position: import('./spineItem/types').UnsafeSpineItemPosition) => import('./spineItem/types').SafeSpineItemPosition;
+                getNavigationFromNode: (spineItem: SpineItem, node: Node, offset: number) => import('./spineItem/types').SafeSpineItemPosition;
             };
         };
     };
-    spineItemsObserver: SpineItemsObserver;
+    spineItemsObserver: import('./spine/SpineItemsObserver').SpineItemsObserver;
     spineItemsManager: SpineItemsManager;
     layout: () => void;
-    load: (manifest: Manifest, loadOptions: LoadOptions) => void;
+    load: (options: Required<Pick<ContextState, "manifest" | "containerElement">>) => void;
     destroy: () => void;
     pagination: {
         state: import('./pagination/Pagination').PaginationInfo;
@@ -99,6 +334,14 @@ export declare const createReader: (inputSettings: CreateReaderOptions) => {
     };
     settings: SettingsInterface<NonNullable<CoreInputSettings>, NonNullable<import('./settings/types').CoreOutputSettings | undefined>>;
     element$: import('rxjs').Observable<HTMLElement>;
+    layout$: import('rxjs').Observable<{
+        hasChanged: boolean;
+        spineItemsAbsolutePositions: import('./spine/SpineLayout').LayoutPosition[];
+        spineItemsPagesAbsolutePositions: import('./spine/SpineLayout').LayoutPosition[][];
+        pages: import('./spine/SpineLayout').PageLayoutInformation[];
+    }>;
+    viewportState$: import('rxjs').Observable<"free" | "busy">;
+    state$: import('rxjs').Observable<"idle" | "ready">;
     $: {
         state$: import('rxjs').Observable<{
             supportedPageTurnAnimation: NonNullable<ContextSettings[`pageTurnAnimation`]>[];
@@ -106,7 +349,6 @@ export declare const createReader: (inputSettings: CreateReaderOptions) => {
             supportedPageTurnDirection: NonNullable<ContextSettings[`pageTurnDirection`]>[];
             supportedComputedPageTurnDirection: NonNullable<ContextSettings[`pageTurnDirection`]>[];
         }>;
-        loadStatus$: import('rxjs').Observable<"idle" | "ready">;
         destroy$: Subject<void>;
     };
 };

package/dist/settings/SettingsInterface.d.ts

@@ -8,6 +8,6 @@ export interface SettingsInterface<InputSettings, OutputSettings = Record<string
         commit: () => OutputSettings;
     };
     update(settings: Partial<InputSettings>): void;
-    settings$: Observable<OutputSettings>;
-    settings: OutputSettings;
+    values$: Observable<OutputSettings>;
+    values: OutputSettings;
 }

package/dist/settings/SettingsManager.d.ts

@@ -15,7 +15,7 @@ export declare abstract class SettingsManager<InputSettings, OutputSettings> imp
     abstract getOutputSettings(inputSettings: InputSettings): OutputSettings;
     abstract getDefaultSettings(): InputSettings;
     update(settings: Partial<InputSettings>): void;
-    get settings(): OutputSettings;
-    get settings$(): Observable<OutputSettings>;
+    get values(): OutputSettings;
+    get values$(): Observable<OutputSettings>;
     destroy(): void;
 }

package/dist/settings/SettingsManagerOverload.d.ts

@@ -7,7 +7,7 @@ export declare abstract class SettingsManagerOverload<InputSettings, OutputSetti
     protected outputSettings: OutputSettings;
     protected outputSettingsUpdateSubject: Subject<OutputSettings>;
     protected settingsManager: SettingsInterface<ParentInputSettings, ParentOutputSettings>;
-    settings$: Observable<ParentOutputSettings & OutputSettings>;
+    values$: Observable<ParentOutputSettings & OutputSettings>;
     constructor(initialSettings: Partial<InputSettings>, settingsManager: SettingsInterface<ParentInputSettings, ParentOutputSettings>);
     abstract getDefaultSettings(): InputSettings;
     abstract computeOutputSettings(inputSettings: InputSettings): OutputSettings;
@@ -18,6 +18,6 @@ export declare abstract class SettingsManagerOverload<InputSettings, OutputSetti
         commit: () => OutputSettings & ParentOutputSettings;
     };
     update(settings: Partial<InputSettings & ParentInputSettings>): void;
-    get settings(): ParentOutputSettings & OutputSettings;
+    get values(): ParentOutputSettings & OutputSettings;
     destroy(): void;
 }