@prose-reader/core 1.67.0 → 1.68.0

package/dist/pagination/PaginationController.d.ts

@@ -0,0 +1,15 @@
+import { Context } from '../context/Context';
+import { Pagination } from './Pagination';
+import { SpineItemsManager } from '../spine/SpineItemsManager';
+import { DestroyableClass } from '../utils/DestroyableClass';
+import { createSpineItemLocator } from '../spineItem/locationResolver';
+import { Spine } from '../spine/Spine';
+
+export declare class PaginationController extends DestroyableClass {
+    protected context: Context;
+    protected pagination: Pagination;
+    protected spineItemsManager: SpineItemsManager;
+    protected spine: Spine;
+    protected spineItemLocator: ReturnType<typeof createSpineItemLocator>;
+    constructor(context: Context, pagination: Pagination, spineItemsManager: SpineItemsManager, spine: Spine, spineItemLocator: ReturnType<typeof createSpineItemLocator>);
+}

package/dist/reader.d.ts

@@ -1,8 +1,114 @@
-import { ReaderInternal } from './types/reader';
+import { Subject } from 'rxjs';
+import { Context } from './context/Context';
+import { Manifest } from '@prose-reader/shared';
+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';
 
 export type CreateReaderOptions = Partial<CoreInputSettings>;
 export type CreateReaderParameters = CreateReaderOptions;
-export declare const createReader: (inputSettings: CreateReaderOptions) => ReaderInternal;
+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;
+    spine: Spine;
+    hookManager: HookManager<import('./hooks/types').CoreHook>;
+    cfi: {
+        generateCfiFromRange: ({ startNode, start, end, endNode, }: {
+            startNode: Node;
+            start: number;
+            endNode: Node;
+            end: number;
+        }, item: Manifest[`spineItems`][number]) => {
+            start: string;
+            end: string;
+        };
+        resolveCfi: (params: Omit<Parameters<typeof resolveCfi>[0], "spineItemsManager">) => {
+            node: Node | undefined;
+            offset: number | undefined;
+            spineItemIndex: number;
+        } | {
+            spineItemIndex: number;
+            node?: undefined;
+            offset?: undefined;
+        } | undefined;
+    };
+    navigation: {
+        viewportFree$: import('rxjs').Observable<"free">;
+        viewportBusy$: import('rxjs').Observable<"busy">;
+        readonly viewportPosition: {
+            x: number;
+            y: number;
+        };
+        getNavigation: () => import('./navigation/InternalNavigator').InternalNavigationEntry;
+        getElement: () => HTMLElement;
+        navigate: (to: import('./navigation/UserNavigator').UserNavigationEntry) => void;
+        lock: () => () => void;
+        navigationResolver: {
+            getNavigationForUrl: (url: string | URL) => {
+                position: import('./navigation/viewport/ViewportNavigator').ViewportPosition;
+                spineItemId: string;
+            } | undefined;
+            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;
+            }) => 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;
+            getNavigationForPosition: (viewportPosition: import('./navigation/viewport/ViewportNavigator').ViewportPosition) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
+            getMostPredominantNavigationForPosition: (viewportPosition: import('./navigation/viewport/ViewportNavigator').ViewportPosition) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
+            wrapPositionWithSafeEdge: (position: import('./navigation/viewport/ViewportNavigator').ViewportPosition) => {
+                x: number;
+                y: number;
+            };
+            isNavigationGoingForwardFrom: (to: import('./navigation/viewport/ViewportNavigator').ViewportPosition, from: import('./navigation/viewport/ViewportNavigator').ViewportPosition) => boolean;
+            areNavigationDifferent: (a: import('./navigation/viewport/ViewportNavigator').ViewportPosition, b: import('./navigation/viewport/ViewportNavigator').ViewportPosition) => boolean;
+            arePositionsDifferent: (a: {
+                x: number;
+                y: number;
+            }, b: {
+                x: number;
+                y: number;
+            }) => 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;
+            };
+        };
+    };
+    spineItemsObserver: SpineItemsObserver;
+    spineItemsManager: SpineItemsManager;
+    layout: () => void;
+    load: (manifest: Manifest, loadOptions: LoadOptions) => void;
+    destroy: () => void;
+    pagination: {
+        pagination: import('./pagination/Pagination').PaginationInfo;
+        pagination$: import('rxjs').Observable<import('./pagination/Pagination').PaginationInfo>;
+    };
+    settings: SettingsInterface<NonNullable<CoreInputSettings>, NonNullable<import('./settings/types').CoreOutputSettings | undefined>>;
+    element$: import('rxjs').Observable<HTMLElement>;
+    $: {
+        state$: import('rxjs').Observable<{
+            supportedPageTurnAnimation: NonNullable<ContextSettings[`pageTurnAnimation`]>[];
+            supportedPageTurnMode: NonNullable<ContextSettings[`pageTurnMode`]>[];
+            supportedPageTurnDirection: NonNullable<ContextSettings[`pageTurnDirection`]>[];
+            supportedComputedPageTurnDirection: NonNullable<ContextSettings[`pageTurnDirection`]>[];
+        }>;
+        loadStatus$: import('rxjs').Observable<"idle" | "ready">;
+        destroy$: Subject<void>;
+    };
+};
 type Reader = ReturnType<typeof createReader>;
 export type { Reader };

package/dist/report.d.ts

@@ -2,6 +2,7 @@ export declare const Report: {
     namespace: (namespace: string) => {
         log: (...data: any[]) => void;
         warn: (...data: any[]) => void;
+        info: (...data: any[]) => void;
         error: (...data: any[]) => void;
         time: (name: string, targetDuration?: number) => () => void;
         logMetric: (performanceEntry: PerformanceEntry | {
@@ -14,6 +15,7 @@ export declare const Report: {
     };
     log: (...data: any[]) => void;
     warn: (...data: any[]) => void;
+    info: (...data: any[]) => void;
     error: (...data: any[]) => void;
     time: (name: string, targetDuration?: number) => () => void;
     logMetric: (performanceEntry: PerformanceEntry | {

package/dist/selection.d.ts

@@ -1,4 +1,4 @@
-import { Manifest } from './types';
+import { Manifest } from '.';
 
 export declare const createSelection: (selection: Selection, item: Manifest[`spineItems`][number]) => {
     toString: () => string;

package/dist/settings/ReaderSettingsManager.d.ts

@@ -1,8 +1,9 @@
 import { CoreInputSettings, ComputedCoreSettings, CoreOutputSettings } from './types';
 import { Context } from '../context/Context';
 import { SettingsManager } from './SettingsManager';
+import { SettingsInterface } from './SettingsInterface';
 
-export declare class ReaderSettingsManager extends SettingsManager<CoreInputSettings, CoreOutputSettings> {
+export declare class ReaderSettingsManager extends SettingsManager<CoreInputSettings, CoreOutputSettings> implements SettingsInterface<CoreInputSettings, CoreOutputSettings> {
     protected context: Context;
     constructor(initialSettings: Partial<CoreInputSettings>, context: Context);
     private getComputedSettings;

package/dist/spine/Spine.d.ts

@@ -0,0 +1,32 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { Context } from '../context/Context';
+import { Pagination } from '../pagination/Pagination';
+import { SpineItemsManager } from './SpineItemsManager';
+import { SpineLocator } from './locator/SpineLocator';
+import { createSpineItemLocator as createSpineItemLocationResolver } from '../spineItem/locationResolver';
+import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
+import { HookManager } from '../hooks/HookManager';
+import { SpineItemsLoader } from './loader/SpineItemsLoader';
+import { DestroyableClass } from '../utils/DestroyableClass';
+
+export declare class Spine extends DestroyableClass {
+    protected parentElement$: Observable<HTMLElement>;
+    protected context: Context;
+    protected pagination: Pagination;
+    protected spineItemsManager: SpineItemsManager;
+    spineItemLocator: ReturnType<typeof createSpineItemLocationResolver>;
+    protected settings: ReaderSettingsManager;
+    protected hookManager: HookManager;
+    protected elementSubject: BehaviorSubject<HTMLElement>;
+    protected spineItemsLoader: SpineItemsLoader;
+    locator: SpineLocator;
+    elementResize$: Observable<ResizeObserverEntry[]>;
+    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;
+}