@prose-reader/core 1.72.0 → 1.74.0

package/dist/spine/Spine.d.ts

@@ -8,12 +8,14 @@ import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
 import { HookManager } from '../hooks/HookManager';
 import { SpineItemsLoader } from './loader/SpineItemsLoader';
 import { DestroyableClass } from '../utils/DestroyableClass';
+import { SpineItemsObserver } from './SpineItemsObserver';
+import { SpineLayout } from './SpineLayout';
 
 export declare class Spine extends DestroyableClass {
     protected parentElement$: Observable<HTMLElement>;
     protected context: Context;
     protected pagination: Pagination;
-    protected spineItemsManager: SpineItemsManager;
+    spineItemsManager: SpineItemsManager;
     spineItemLocator: ReturnType<typeof createSpineItemLocationResolver>;
     protected settings: ReaderSettingsManager;
     protected hookManager: HookManager;
@@ -21,12 +23,13 @@ export declare class Spine extends DestroyableClass {
     protected spineItemsLoader: SpineItemsLoader;
     locator: SpineLocator;
     elementResize$: Observable<ResizeObserverEntry[]>;
+    spineItemsObserver: SpineItemsObserver;
+    spineLayout: SpineLayout;
     element$: Observable<HTMLElement>;
     constructor(parentElement$: Observable<HTMLElement>, context: Context, pagination: Pagination, spineItemsManager: SpineItemsManager, spineItemLocator: ReturnType<typeof createSpineItemLocationResolver>, settings: ReaderSettingsManager, hookManager: HookManager);
     get element(): HTMLElement;
     layout(): void;
     isSelecting(): boolean;
     getSelection(): Selection | undefined;
-    get layout$(): Observable<boolean>;
     destroy(): void;
 }

package/dist/spine/SpineItemsManager.d.ts

@@ -1,22 +1,13 @@
-import { BehaviorSubject, Subject } from 'rxjs';
 import { Context } from '../context/Context';
 import { SpineItem } from '../spineItem/createSpineItem';
 import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
 import { DestroyableClass } from '../utils/DestroyableClass';
+import { BehaviorSubject } from 'rxjs';
 
 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`;
@@ -253,8 +244,6 @@ export declare class SpineItemsManager extends DestroyableClass {
             isReady$: import('rxjs').Observable<boolean>;
         };
     }[]>;
-    layout$: import('rxjs').Observable<boolean>;
-    layout(): void;
     get(indexOrId: number | string | SpineItem | undefined): {
         layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
             blankPagePosition: `before` | `after` | `none`;
@@ -373,18 +362,10 @@ export declare class SpineItemsManager extends DestroyableClass {
             isReady$: import('rxjs').Observable<boolean>;
         };
     } | 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(): {
+    getSpineItemFromCfi(cfi: string): {
         layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
             blankPagePosition: `before` | `after` | `none`;
             minimumWidth: number;
@@ -501,9 +482,8 @@ export declare class SpineItemsManager extends DestroyableClass {
             loaded$: import('rxjs').Observable<HTMLIFrameElement>;
             isReady$: import('rxjs').Observable<boolean>;
         };
-    }[];
-    getLength(): number;
-    getSpineItemFromCfi(cfi: string): {
+    } | undefined;
+    get items(): {
         layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
             blankPagePosition: `before` | `after` | `none`;
             minimumWidth: number;
@@ -620,7 +600,6 @@ export declare class SpineItemsManager extends DestroyableClass {
             loaded$: import('rxjs').Observable<HTMLIFrameElement>;
             isReady$: import('rxjs').Observable<boolean>;
         };
-    } | undefined;
+    }[];
     destroyItems(): void;
-    destroy(): void;
 }

package/dist/spine/SpineItemsObserver.d.ts

@@ -2,9 +2,11 @@ import { Observable } from 'rxjs';
 import { SpineItemsManager } from './SpineItemsManager';
 import { DestroyableClass } from '../utils/DestroyableClass';
 import { SpineItem } from '../spineItem/createSpineItem';
+import { SpineLocator } from './locator/SpineLocator';
 
 export declare class SpineItemsObserver extends DestroyableClass {
     protected spineItemsManager: SpineItemsManager;
+    protected spineLocator: SpineLocator;
     itemIsReady$: Observable<{
         item: SpineItem;
         isReady: boolean;
@@ -13,5 +15,5 @@ export declare class SpineItemsObserver extends DestroyableClass {
         item: SpineItem;
         entries: ResizeObserverEntry[];
     }>;
-    constructor(spineItemsManager: SpineItemsManager);
+    constructor(spineItemsManager: SpineItemsManager, spineLocator: SpineLocator);
 }

package/dist/spine/SpineLayout.d.ts

@@ -0,0 +1,49 @@
+import { Observable, Subject } from 'rxjs';
+import { Context } from '../context/Context';
+import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
+import { DestroyableClass } from '../utils/DestroyableClass';
+import { SpineItemsManager } from './SpineItemsManager';
+import { SpineItem } from '../spineItem/createSpineItem';
+
+export type LayoutPosition = {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    __symbol?: `LayoutPosition`;
+};
+export type PageLayoutInformation = {
+    absolutePageIndex: number;
+    itemIndex: number;
+    absolutePosition: LayoutPosition;
+};
+export declare class SpineLayout extends DestroyableClass {
+    protected spineItemsManager: SpineItemsManager;
+    protected context: Context;
+    protected settings: ReaderSettingsManager;
+    protected itemLayoutInformation: LayoutPosition[];
+    protected layoutSubject: Subject<boolean>;
+    layout$: Observable<{
+        hasChanged: boolean;
+        spineItemsAbsolutePositions: LayoutPosition[];
+        spineItemsPagesAbsolutePositions: LayoutPosition[][];
+        pages: PageLayoutInformation[];
+    }>;
+    constructor(spineItemsManager: SpineItemsManager, context: Context, settings: ReaderSettingsManager);
+    layout(): void;
+    getAbsolutePositionOf(spineItemOrIndex: SpineItem | number | string | undefined): {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+    };
+    destroy(): void;
+}

package/dist/spine/layout/convertViewportPositionToLayoutPosition.d.ts

@@ -0,0 +1,10 @@
+import { ViewportPosition } from '../../navigation/viewport/ViewportNavigator';
+import { LayoutPosition } from '../SpineLayout';
+
+export declare const convertSpinePositionToLayoutPosition: ({ position, pageSize, }: {
+    position: ViewportPosition;
+    pageSize: {
+        height: number;
+        width: number;
+    };
+}) => LayoutPosition;

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

@@ -3,11 +3,13 @@ import { SpineLocator } from '../locator/SpineLocator';
 import { Context } from '../../context/Context';
 import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
 import { DestroyableClass } from '../../utils/DestroyableClass';
+import { SpineLayout } from '../SpineLayout';
 
 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);
+    protected spineLayout: SpineLayout;
+    constructor(context: Context, spineItemsManager: SpineItemsManager, spineLocator: SpineLocator, settings: ReaderSettingsManager, spineLayout: SpineLayout);
 }

package/dist/spine/locator/SpineLocator.d.ts

@@ -6,15 +6,146 @@ import { SafeSpineItemPosition, UnsafeSpineItemPosition } from '../../spineItem/
 import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
 import { ViewportPosition } from '../../navigation/viewport/ViewportNavigator';
 import { getVisibleSpineItemsFromPosition } from './getVisibleSpineItemsFromPosition';
+import { SpineLayout } from '../SpineLayout';
+import { getSpineInfoFromAbsolutePageIndex } from './getSpineInfoFromAbsolutePageIndex';
+import { getAbsolutePageIndexFromPageIndex } from './getAbsolutePageIndexFromPageIndex';
 
 export type SpineLocator = ReturnType<typeof createSpineLocator>;
-export declare const createSpineLocator: ({ spineItemsManager, context, spineItemLocator, settings, }: {
+export declare const createSpineLocator: ({ spineItemsManager, context, spineItemLocator, settings, spineLayout, }: {
     spineItemsManager: SpineItemsManager;
     context: Context;
     spineItemLocator: ReturnType<typeof createSpineItemLocator>;
     settings: ReaderSettingsManager;
+    spineLayout: SpineLayout;
 }) => {
-    getSpinePositionFromSpineItemPosition: (spineItemPosition: SafeSpineItemPosition, spineItem: SpineItem) => ViewportPosition;
+    getSpinePositionFromSpineItemPosition: ({ spineItem, spineItemPosition, }: {
+        spineItemPosition: SafeSpineItemPosition;
+        spineItem: SpineItem;
+    }) => ViewportPosition;
+    getAbsolutePageIndexFromPageIndex: (params: Omit<Parameters<typeof getAbsolutePageIndexFromPageIndex>[0], "context" | "settings" | "spineLayout" | "spineItemsManager">) => number | undefined;
+    getSpineInfoFromAbsolutePageIndex: (params: Omit<Parameters<typeof getSpineInfoFromAbsolutePageIndex>[0], "context" | "settings" | "spineLayout" | "spineItemsManager">) => {
+        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>;
+            };
+        };
+        pageIndex: number;
+        itemIndex: number;
+        currentAbsolutePage: number;
+    } | undefined;
     getSpinePositionFromSpineItem: (spineItem: SpineItem) => ViewportPosition;
     getSpineItemPositionFromSpinePosition: ((position: ViewportPosition, spineItem: SpineItem) => UnsafeSpineItemPosition) | ((position: ViewportPosition, spineItem: {
         layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
@@ -371,7 +502,7 @@ export declare const createSpineLocator: ({ spineItemsManager, context, spineIte
         };
     } | undefined;
     getSpineItemPageIndexFromNode: (node: Node, offset: number | undefined, spineItemOrIndex: SpineItem | number) => number | undefined;
-    getVisibleSpineItemsFromPosition: (params: Omit<Parameters<typeof getVisibleSpineItemsFromPosition>[0], "context" | "spineItemsManager" | "settings">) => {
+    getVisibleSpineItemsFromPosition: (params: Omit<Parameters<typeof getVisibleSpineItemsFromPosition>[0], "context" | "spineItemsManager" | "settings" | "spineLayout">) => {
         beginIndex: number;
         endIndex: number;
     } | undefined;
@@ -390,7 +521,14 @@ export declare const createSpineLocator: ({ spineItemsManager, context, spineIte
             x: number;
             y: number;
         } | undefined;
-        getSpineItemPositionFromPageIndex: (pageIndex: number, spineItem: SpineItem) => SafeSpineItemPosition;
+        getSpineItemPositionFromPageIndex: ({ pageIndex, itemLayout, isUsingVerticalWriting, }: {
+            pageIndex: number;
+            itemLayout: {
+                width: number;
+                height: number;
+            };
+            isUsingVerticalWriting: boolean;
+        }) => SafeSpineItemPosition;
         getSpineItemPageIndexFromPosition: ({ itemWidth, itemHeight, position, isUsingVerticalWriting, }: {
             itemWidth: number;
             itemHeight: number;
@@ -406,7 +544,10 @@ export declare const createSpineLocator: ({ spineItemsManager, context, spineIte
             node: Node;
             offset: number;
         } | undefined;
-        getSpineItemNumberOfPages: ({ itemHeight, itemWidth, isUsingVerticalWriting, }: {
+        getSpineItemPagesPosition: ({ item }: {
+            item: SpineItem;
+        }) => SafeSpineItemPosition[];
+        getSpineItemNumberOfPages: (params: {
             itemWidth: number;
             itemHeight: number;
             isUsingVerticalWriting: boolean;

package/dist/spine/locator/getAbsolutePageIndexFromPageIndex.d.ts

@@ -0,0 +1,14 @@
+import { Context } from '../../context/Context';
+import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
+import { SpineItem } from '../../spineItem/createSpineItem';
+import { SpineItemsManager } from '../SpineItemsManager';
+import { SpineLayout } from '../SpineLayout';
+
+export declare const getAbsolutePageIndexFromPageIndex: ({ pageIndex, spineItemOrId, spineLayout, spineItemsManager, context, settings, }: {
+    pageIndex: number;
+    spineItemOrId: number | SpineItem | string;
+    spineLayout: SpineLayout;
+    spineItemsManager: SpineItemsManager;
+    context: Context;
+    settings: ReaderSettingsManager;
+}) => number | undefined;

package/dist/spine/locator/getSpineInfoFromAbsolutePageIndex.d.ts

@@ -0,0 +1,134 @@
+import { Context } from '../../context/Context';
+import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
+import { SpineItemsManager } from '../SpineItemsManager';
+import { SpineLayout } from '../SpineLayout';
+
+export declare const getSpineInfoFromAbsolutePageIndex: ({ absolutePageIndex, spineLayout, spineItemsManager, context, settings, }: {
+    absolutePageIndex: number;
+    spineLayout: SpineLayout;
+    spineItemsManager: SpineItemsManager;
+    context: Context;
+    settings: ReaderSettingsManager;
+}) => {
+    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>;
+        };
+    };
+    pageIndex: number;
+    itemIndex: number;
+    currentAbsolutePage: number;
+} | undefined;

package/dist/spine/locator/getSpineItemFromPosition.d.ts

@@ -1,10 +1,12 @@
 import { ViewportPosition } from '../../navigation/viewport/ViewportNavigator';
 import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
 import { SpineItemsManager } from '../SpineItemsManager';
+import { SpineLayout } from '../SpineLayout';
 
-export declare const getSpineItemFromPosition: ({ position, spineItemsManager, settings, }: {
+export declare const getSpineItemFromPosition: ({ position, spineItemsManager, spineLayout, settings, }: {
     position: ViewportPosition;
     spineItemsManager: SpineItemsManager;
+    spineLayout: SpineLayout;
     settings: ReaderSettingsManager;
 }) => {
     layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {

package/dist/spine/locator/getSpinePositionFromSpineItemPageIndex.d.ts

@@ -0,0 +1,13 @@
+import { Context } from '../../context/Context';
+
+export declare const getSpinePositionFromSpineItemPageIndex: ({ pageIndex, context, isUsingVerticalWriting, itemLayout, }: {
+    pageIndex: number;
+    isUsingVerticalWriting: boolean;
+    context: Context;
+    itemLayout: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+}) => import('../../navigation/viewport/ViewportNavigator').ViewportPosition;

package/dist/spine/locator/getSpinePositionFromSpineItemPosition.d.ts

@@ -0,0 +1,10 @@
+import { ViewportPosition } from '../../navigation/viewport/ViewportNavigator';
+import { SafeSpineItemPosition } from '../../spineItem/types';
+
+export declare const getSpinePositionFromSpineItemPosition: ({ spineItemPosition, itemLayout: { left, top }, }: {
+    spineItemPosition: SafeSpineItemPosition;
+    itemLayout: {
+        left: number;
+        top: number;
+    };
+}) => ViewportPosition;

package/dist/spine/locator/getVisibleSpineItemsFromPosition.d.ts

@@ -2,14 +2,16 @@ import { Context } from '../../context/Context';
 import { ViewportPosition } from '../../navigation/viewport/ViewportNavigator';
 import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
 import { SpineItemsManager } from '../SpineItemsManager';
+import { SpineLayout } from '../SpineLayout';
 
-export declare const getVisibleSpineItemsFromPosition: ({ position, threshold, restrictToScreen, spineItemsManager, context, settings, }: {
+export declare const getVisibleSpineItemsFromPosition: ({ position, threshold, restrictToScreen, spineItemsManager, context, settings, spineLayout, }: {
     position: ViewportPosition;
     threshold: number;
     restrictToScreen?: boolean;
     spineItemsManager: SpineItemsManager;
     context: Context;
     settings: ReaderSettingsManager;
+    spineLayout: SpineLayout;
 }) => {
     beginIndex: number;
     endIndex: number;

package/dist/spineItem/locationResolver.d.ts

@@ -12,7 +12,14 @@ export declare const createSpineItemLocator: ({ context, settings, }: {
         x: number;
         y: number;
     } | undefined;
-    getSpineItemPositionFromPageIndex: (pageIndex: number, spineItem: SpineItem) => SafeSpineItemPosition;
+    getSpineItemPositionFromPageIndex: ({ pageIndex, itemLayout, isUsingVerticalWriting, }: {
+        pageIndex: number;
+        itemLayout: {
+            width: number;
+            height: number;
+        };
+        isUsingVerticalWriting: boolean;
+    }) => SafeSpineItemPosition;
     getSpineItemPageIndexFromPosition: ({ itemWidth, itemHeight, position, isUsingVerticalWriting, }: {
         itemWidth: number;
         itemHeight: number;
@@ -28,7 +35,10 @@ export declare const createSpineItemLocator: ({ context, settings, }: {
         node: Node;
         offset: number;
     } | undefined;
-    getSpineItemNumberOfPages: ({ itemHeight, itemWidth, isUsingVerticalWriting, }: {
+    getSpineItemPagesPosition: ({ item }: {
+        item: SpineItem;
+    }) => SafeSpineItemPosition[];
+    getSpineItemNumberOfPages: (params: {
         itemWidth: number;
         itemHeight: number;
         isUsingVerticalWriting: boolean;

package/dist/spineItem/locator/getSpineItemNumberOfPages.d.ts

@@ -0,0 +1,10 @@
+import { Context } from '../../context/Context';
+import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
+
+export declare const getSpineItemNumberOfPages: ({ itemHeight, itemWidth, isUsingVerticalWriting, settings, context, }: {
+    itemWidth: number;
+    itemHeight: number;
+    isUsingVerticalWriting: boolean;
+    settings: ReaderSettingsManager;
+    context: Context;
+}) => number;

package/dist/spineItem/locator/getSpineItemPagesPosition.d.ts

@@ -0,0 +1,12 @@
+import { Context } from '../../context/Context';
+import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
+
+export declare const getSpineItemPagesPosition: ({ context, isUsingVerticalWriting, settings, itemLayout, }: {
+    itemLayout: {
+        width: number;
+        height: number;
+    };
+    isUsingVerticalWriting: boolean;
+    settings: ReaderSettingsManager;
+    context: Context;
+}) => import('../types').SafeSpineItemPosition[];

package/dist/spineItem/locator/getSpineItemPositionFromPageIndex.d.ts

@@ -0,0 +1,12 @@
+import { Context } from '../../context/Context';
+import { SafeSpineItemPosition } from '../types';
+
+export declare const getSpineItemPositionFromPageIndex: ({ pageIndex, itemLayout, context, isUsingVerticalWriting, }: {
+    pageIndex: number;
+    itemLayout: {
+        width: number;
+        height: number;
+    };
+    context: Context;
+    isUsingVerticalWriting: boolean;
+}) => SafeSpineItemPosition;

package/dist/utils/frames.d.ts

@@ -0,0 +1 @@
+export declare const getAttributeValueFromString: (string: string, key: string) => number;