@prose-reader/core 1.67.0 → 1.68.0

package/dist/spine/{locationResolver.d.ts → SpineItemsManager.d.ts}

@@ -1,21 +1,23 @@
+import { BehaviorSubject, Subject } from 'rxjs';
 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 { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
+import { DestroyableClass } from '../utils/DestroyableClass';
 
-export declare const createLocationResolver: ({ spineItemManager, context, spineItemLocator, settings, }: {
-    spineItemManager: SpineItemManager;
-    context: Context;
-    spineItemLocator: ReturnType<typeof createSpineItemLocator>;
-    settings: ReaderSettingsManager;
-}) => {
-    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: {
+export declare class SpineItemsManager extends DestroyableClass {
+    protected context: Context;
+    protected settings: ReaderSettingsManager;
+    constructor(context: Context, settings: ReaderSettingsManager);
+    protected layoutSubject: Subject<boolean>;
+    protected itemLayoutInformation: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        width: number;
+        height: number;
+    }[];
+    protected orderedSpineItemsSubject: BehaviorSubject<{
         layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
             blankPagePosition: `before` | `after` | `none`;
             minimumWidth: number;
@@ -27,13 +29,13 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
         item: {
             id: string;
             href: string;
-            renditionLayout: `reflowable` | `pre-paginated`;
-            progressionWeight: number;
-            pageSpreadLeft: true | undefined;
-            pageSpreadRight: true | undefined;
+            renditionLayout?: `reflowable` | `pre-paginated`;
+            progressionWeight?: number;
+            pageSpreadLeft?: true | undefined;
+            pageSpreadRight?: true | undefined;
             mediaType?: string;
         };
-        load: () => void;
+        overlayElement: HTMLDivElement;
         adjustPositionOfElement: ({ right, left, top, }: {
             right?: number;
             left?: number;
@@ -42,6 +44,13 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
         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>;
@@ -52,43 +61,10 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
             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;
-                }>;
-            };
-        };
+        load: () => void;
+        unload: () => void;
+        frame: import('../spineItem/frame/FrameItem').FrameItem;
         element: HTMLElement;
         getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
         getViewPortInformation: () => {
@@ -102,17 +78,8 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
         isImageType: () => boolean;
         isReady: () => boolean;
         destroy: () => void;
+        readingDirection: "ltr" | "rtl" | undefined;
         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[];
@@ -167,8 +134,8 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
             loaded$: import('rxjs').Observable<HTMLIFrameElement>;
             isReady$: import('rxjs').Observable<boolean>;
         };
-    }) => ReturnType<(position: UnsafeSpinePosition, spineItem: SpineItem) => UnsafeSpineItemPosition>);
-    getSpineItemFromPosition: ((position: UnsafeSpinePosition) => {
+    }[]>;
+    items$: import('rxjs').Observable<{
         layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
             blankPagePosition: `before` | `after` | `none`;
             minimumWidth: number;
@@ -180,13 +147,13 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
         item: {
             id: string;
             href: string;
-            renditionLayout: `reflowable` | `pre-paginated`;
-            progressionWeight: number;
-            pageSpreadLeft: true | undefined;
-            pageSpreadRight: true | undefined;
+            renditionLayout?: `reflowable` | `pre-paginated`;
+            progressionWeight?: number;
+            pageSpreadLeft?: true | undefined;
+            pageSpreadRight?: true | undefined;
             mediaType?: string;
         };
-        load: () => void;
+        overlayElement: HTMLDivElement;
         adjustPositionOfElement: ({ right, left, top, }: {
             right?: number;
             left?: number;
@@ -195,6 +162,13 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
         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>;
@@ -205,43 +179,10 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
             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;
-                }>;
-            };
-        };
+        load: () => void;
+        unload: () => void;
+        frame: import('../spineItem/frame/FrameItem').FrameItem;
         element: HTMLElement;
         getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
         getViewPortInformation: () => {
@@ -255,17 +196,8 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
         isImageType: () => boolean;
         isReady: () => boolean;
         destroy: () => void;
+        readingDirection: "ltr" | "rtl" | undefined;
         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[];
@@ -320,7 +252,10 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
             loaded$: import('rxjs').Observable<HTMLIFrameElement>;
             isReady$: import('rxjs').Observable<boolean>;
         };
-    } | undefined) | ((position: UnsafeSpinePosition) => ReturnType<(position: UnsafeSpinePosition) => {
+    }[]>;
+    layout$: import('rxjs').Observable<boolean>;
+    layout(): void;
+    get(indexOrId: number | string | SpineItem | undefined): {
         layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
             blankPagePosition: `before` | `after` | `none`;
             minimumWidth: number;
@@ -332,13 +267,13 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
         item: {
             id: string;
             href: string;
-            renditionLayout: `reflowable` | `pre-paginated`;
-            progressionWeight: number;
-            pageSpreadLeft: true | undefined;
-            pageSpreadRight: true | undefined;
+            renditionLayout?: `reflowable` | `pre-paginated`;
+            progressionWeight?: number;
+            pageSpreadLeft?: true | undefined;
+            pageSpreadRight?: true | undefined;
             mediaType?: string;
         };
-        load: () => void;
+        overlayElement: HTMLDivElement;
         adjustPositionOfElement: ({ right, left, top, }: {
             right?: number;
             left?: number;
@@ -347,6 +282,13 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
         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>;
@@ -357,43 +299,10 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
             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;
-                }>;
-            };
-        };
+        load: () => void;
+        unload: () => void;
+        frame: import('../spineItem/frame/FrameItem').FrameItem;
         element: HTMLElement;
         getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
         getViewPortInformation: () => {
@@ -407,17 +316,8 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
         isImageType: () => boolean;
         isReady: () => boolean;
         destroy: () => void;
+        readingDirection: "ltr" | "rtl" | undefined;
         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[];
@@ -472,8 +372,19 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
             loaded$: import('rxjs').Observable<HTMLIFrameElement>;
             isReady$: import('rxjs').Observable<boolean>;
         };
-    } | undefined>);
-    getSpineItemFromIframe: (iframe: Element) => {
+    } | undefined;
+    getAbsolutePositionOf(spineItemOrIndex: SpineItem | number | string | undefined): {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        width: number;
+        height: number;
+    };
+    comparePositionOf(toCompare: SpineItem, withItem: SpineItem): "after" | "before" | "same";
+    getSpineItemIndex(spineItem: SpineItem | undefined): number | undefined;
+    addMany(spineItems: SpineItem[]): void;
+    get items(): {
         layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
             blankPagePosition: `before` | `after` | `none`;
             minimumWidth: number;
@@ -485,13 +396,13 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
         item: {
             id: string;
             href: string;
-            renditionLayout: `reflowable` | `pre-paginated`;
-            progressionWeight: number;
-            pageSpreadLeft: true | undefined;
-            pageSpreadRight: true | undefined;
+            renditionLayout?: `reflowable` | `pre-paginated`;
+            progressionWeight?: number;
+            pageSpreadLeft?: true | undefined;
+            pageSpreadRight?: true | undefined;
             mediaType?: string;
         };
-        load: () => void;
+        overlayElement: HTMLDivElement;
         adjustPositionOfElement: ({ right, left, top, }: {
             right?: number;
             left?: number;
@@ -500,6 +411,13 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
         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>;
@@ -510,43 +428,129 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
             clientX: number;
             clientY: number;
         };
-        setLayoutDirty: () => void;
         injectStyle: (cssText: string) => void;
-        loadContent: () => void;
-        unloadContent: () => void;
-        spineItemFrame: {
-            getIsLoaded: () => boolean;
-            getIsReady: () => boolean;
-            getViewportDimensions: () => {
+        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;
-            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;
-                }>;
-            };
+            $: 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>;
+        };
+    }[];
+    getLength(): number;
+    getSpineItemFromCfi(cfi: string): {
+        layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
+            blankPagePosition: `before` | `after` | `none`;
+            minimumWidth: number;
+            spreadPosition: `none` | `left` | `right`;
+        }) => {
+            width: number;
+            height: number;
         };
+        item: {
+            id: string;
+            href: string;
+            renditionLayout?: `reflowable` | `pre-paginated`;
+            progressionWeight?: number;
+            pageSpreadLeft?: true | undefined;
+            pageSpreadRight?: true | undefined;
+            mediaType?: string;
+        };
+        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: () => {
@@ -560,17 +564,8 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
         isImageType: () => boolean;
         isReady: () => boolean;
         destroy: () => void;
+        readingDirection: "ltr" | "rtl" | undefined;
         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[];
@@ -626,11 +621,6 @@ export declare const createLocationResolver: ({ spineItemManager, context, spine
             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;
-};
+    destroyItems(): void;
+    destroy(): void;
+}

package/dist/spine/SpineItemsObserver.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+import { SpineItemsManager } from './SpineItemsManager';
+import { DestroyableClass } from '../utils/DestroyableClass';
+import { SpineItem } from '../spineItem/createSpineItem';
+
+export declare class SpineItemsObserver extends DestroyableClass {
+    protected spineItemsManager: SpineItemsManager;
+    itemIsReady$: Observable<{
+        item: SpineItem;
+        isReady: boolean;
+    }>;
+    itemResize$: Observable<{
+        item: SpineItem;
+        entries: ResizeObserverEntry[];
+    }>;
+    constructor(spineItemsManager: SpineItemsManager);
+}

package/dist/spine/loader/SpineItemsLoader.d.ts

@@ -0,0 +1,13 @@
+import { SpineItemsManager } from '../SpineItemsManager';
+import { SpineLocator } from '../locator/SpineLocator';
+import { Context } from '../../context/Context';
+import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
+import { DestroyableClass } from '../../utils/DestroyableClass';
+
+export declare class SpineItemsLoader extends DestroyableClass {
+    protected context: Context;
+    protected spineItemsManager: SpineItemsManager;
+    protected spineLocator: SpineLocator;
+    protected settings: ReaderSettingsManager;
+    constructor(context: Context, spineItemsManager: SpineItemsManager, spineLocator: SpineLocator, settings: ReaderSettingsManager);
+}

package/dist/spine/loader/loadItems.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from 'rxjs';
+import { SpineItemsManager } from '../SpineItemsManager';
+import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
+
+export declare const loadItems: ({ spineItemsManager, settings, }: {
+    spineItemsManager: SpineItemsManager;
+    settings: ReaderSettingsManager;
+}) => (stream: Observable<readonly [number, number]>) => Observable<readonly [number, number]>;

package/dist/spine/loader/mapToItemsToLoad.d.ts

@@ -0,0 +1,7 @@
+import { Observable } from 'rxjs';
+import { ViewportPosition } from '../../navigation/viewport/ViewportNavigator';
+import { SpineLocator } from '../locator/SpineLocator';
+
+export declare const mapToItemsToLoad: ({ spineLocator }: {
+    spineLocator: SpineLocator;
+}) => (stream: Observable<ViewportPosition>) => Observable<readonly [number, number]>;