@prose-reader/core 1.66.0 → 1.68.0

package/dist/spine/createSpine.d.ts

@@ -1,31 +0,0 @@
-import { Observable } from 'rxjs';
-import { Context } from '../context/Context';
-import { Pagination } from '../pagination/pagination';
-import { SpineItemManager } from '../spineItemManager';
-import { createLocationResolver as createSpineLocationResolver } from './locationResolver';
-import { createLocationResolver as createSpineItemLocationResolver } from '../spineItem/locationResolver';
-import { createCfiLocator } from './cfiLocator';
-import { Spine } from '../types/Spine';
-import { AdjustedNavigation, Navigation } from '../viewportNavigator/types';
-import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
-import { HookManager } from '../hooks/HookManager';
-
-export declare const createSpine: ({ element$, context, pagination, spineItemManager, spineItemLocator, spineLocator, cfiLocator, navigation$, navigationAdjusted$, currentNavigationPosition$, viewportState$, settings, hookManager, }: {
-    element$: Observable<HTMLElement>;
-    context: Context;
-    pagination: Pagination;
-    spineItemManager: SpineItemManager;
-    spineItemLocator: ReturnType<typeof createSpineItemLocationResolver>;
-    spineLocator: ReturnType<typeof createSpineLocationResolver>;
-    cfiLocator: ReturnType<typeof createCfiLocator>;
-    navigation$: Observable<Navigation>;
-    navigationAdjusted$: Observable<AdjustedNavigation>;
-    currentNavigationPosition$: Observable<{
-        x: number;
-        y: number;
-    }>;
-    viewportState$: Observable<`free` | `busy`>;
-    settings: ReaderSettingsManager;
-    hookManager: HookManager;
-}) => Spine;
-export { Spine };

package/dist/spine/navigationResolver.d.ts

@@ -1,48 +0,0 @@
-import { Context } from '../context/Context';
-import { SpineItemManager } from '../spineItemManager';
-import { SpineItem } from '../spineItem/createSpineItem';
-import { createLocationResolver } from './locationResolver';
-import { createCfiLocator } from './cfiLocator';
-import { SpinePosition, UnsafeSpinePosition } from './types';
-import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
-
-export type ViewportNavigationEntry = {
-    x: number;
-    y: number;
-    spineItem?: SpineItem;
-};
-type ViewportPosition = {
-    x: number;
-    y: number;
-};
-export declare const createNavigationResolver: ({ context, spineItemManager, cfiLocator, locator, settings, }: {
-    context: Context;
-    spineItemManager: SpineItemManager;
-    cfiLocator: ReturnType<typeof createCfiLocator>;
-    locator: ReturnType<typeof createLocationResolver>;
-    settings: ReaderSettingsManager;
-}) => {
-    getNavigationForCfi: (cfi: string) => ViewportNavigationEntry;
-    getNavigationForPage: (pageIndex: number, spineItem?: SpineItem) => ViewportNavigationEntry;
-    getNavigationForLastPage: (spineItem: SpineItem) => ViewportNavigationEntry;
-    getNavigationForSpineIndexOrId: (indexOrId: number | string) => ViewportNavigationEntry;
-    getNavigationForRightPage: (position: SpinePosition) => ViewportNavigationEntry;
-    getNavigationForLeftPage: (position: UnsafeSpinePosition) => SpinePosition;
-    getNavigationForUrl: (url: string | URL) => (ViewportNavigationEntry & {
-        url: URL;
-    }) | undefined;
-    getNavigationForAnchor: (anchor: string, spineItem: SpineItem) => ViewportNavigationEntry;
-    getNavigationForPosition: (viewportPosition: ViewportPosition) => ViewportNavigationEntry;
-    getMostPredominantNavigationForPosition: (viewportPosition: ViewportPosition) => ViewportNavigationEntry;
-    wrapPositionWithSafeEdge: ((position: SpinePosition) => {
-        x: number;
-        y: number;
-    }) | ((position: SpinePosition) => ReturnType<(position: SpinePosition) => {
-        x: number;
-        y: number;
-    }>);
-    isNavigationGoingForwardFrom: (to: ViewportPosition, from: ViewportPosition) => boolean;
-    areNavigationDifferent: (a: ViewportNavigationEntry, b: ViewportNavigationEntry) => boolean;
-    arePositionsDifferent: (a: ViewportNavigationEntry, b: ViewportNavigationEntry) => boolean;
-};
-export {};

package/dist/spine/types.d.ts

@@ -1,10 +0,0 @@
-export type SpinePosition = {
-    x: number;
-    y: number;
-    __symbol?: `SpinePosition`;
-};
-export type UnsafeSpinePosition = {
-    x: number;
-    y: number;
-    __symbol?: `UnsafeSpinePosition` | `SpinePosition`;
-};

package/dist/spineItem/frameItem/createFrame$.d.ts

@@ -1 +0,0 @@
-export declare const createFrame$: (() => import('rxjs').Observable<HTMLIFrameElement>) | (() => ReturnType<() => import('rxjs').Observable<HTMLIFrameElement>>);

package/dist/spineItem/frameItem/createFrameManipulator.d.ts

@@ -1,5 +0,0 @@
-export declare const createFrameManipulator: (frameElement: HTMLIFrameElement) => {
-    frame: HTMLIFrameElement;
-    removeStyle: (id: string) => void;
-    addStyle: (id: string, style: string, prepend?: boolean) => void;
-};

package/dist/spineItem/frameItem/frameItem.d.ts

@@ -1,48 +0,0 @@
-import { Observable } from 'rxjs';
-import { Manifest } from '../../types';
-import { Context } from '../../context/Context';
-import { createFrameManipulator } from './createFrameManipulator';
-import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
-import { HookManager } from '../../hooks/HookManager';
-
-export declare const createFrameItem: ({ item, parent, context, viewportState$, settings, hookManager, }: {
-    parent: HTMLElement;
-    item: Manifest[`spineItems`][number];
-    context: Context;
-    viewportState$: Observable<`free` | `busy`>;
-    settings: ReaderSettingsManager;
-    hookManager: HookManager;
-}) => {
-    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 createFrameManipulator> | undefined;
-    getReadingDirection: () => `ltr` | `rtl` | undefined;
-    isUsingVerticalWriting: () => boolean;
-    getWritingMode: () => `vertical-rl` | `horizontal-tb` | undefined;
-    destroy: () => void;
-    $: {
-        unload$: Observable<void>;
-        unloaded$: Observable<void>;
-        loaded$: Observable<HTMLIFrameElement>;
-        ready$: Observable<FontFaceSet | undefined>;
-        isReady$: Observable<boolean>;
-        contentLayoutChange$: Observable<{
-            isFirstLayout: boolean;
-        } | {
-            isFirstLayout: boolean;
-        }>;
-    };
-};
-export type SpineItemFrame = ReturnType<typeof createFrameItem>;

package/dist/spineItem/frameItem/loader.d.ts

@@ -1,29 +0,0 @@
-import { BehaviorSubject, Observable } from 'rxjs';
-import { Context } from '../../context/Context';
-import { Manifest } from '../../types';
-import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
-import { HookManager } from '../../hooks/HookManager';
-
-export declare const createLoader: ({ item, parent, context, viewportState$, settings, hookManager, }: {
-    item: Manifest[`spineItems`][number];
-    parent: HTMLElement;
-    context: Context;
-    settings: ReaderSettingsManager;
-    viewportState$: Observable<`free` | `busy`>;
-    hookManager: HookManager;
-}) => {
-    load: () => void;
-    unload: () => void;
-    destroy: () => void;
-    getComputedStyleAfterLoad: () => CSSStyleDeclaration | undefined;
-    $: {
-        load$: Observable<void>;
-        unload$: Observable<void>;
-        loaded$: Observable<HTMLIFrameElement>;
-        isLoaded$: Observable<boolean>;
-        isReady$: Observable<boolean>;
-        ready$: Observable<FontFaceSet | undefined>;
-        unloaded$: Observable<void>;
-        frameElement$: BehaviorSubject<HTMLIFrameElement | undefined>;
-    };
-};

package/dist/types/Spine.d.ts

@@ -1,40 +0,0 @@
-import { Observable } from 'rxjs';
-import { SpineItem } from '../spineItem/createSpineItem';
-import { createSelection } from '../selection';
-import { createCfiLocator } from '../spine/cfiLocator';
-import { createLocationResolver } from '../spine/locationResolver';
-import { createLocationResolver as createSpineItemLocator } from '../spineItem/locationResolver';
-import { ViewportNavigationEntry } from '../spine/navigationResolver';
-
-type RequireLayout = boolean;
-type ManipulableSpineItemCallback = Parameters<SpineItem[`manipulateSpineItem`]>[0];
-type ManipulableSpineItemCallbackPayload = Parameters<ManipulableSpineItemCallback>[0];
-type CfiLocator = ReturnType<typeof createCfiLocator>;
-type SpineItemLocator = ReturnType<typeof createSpineItemLocator>;
-type Locator = ReturnType<typeof createLocationResolver>;
-type Event = {
-    type: `onSelectionChange`;
-    data: ReturnType<typeof createSelection> | null;
-};
-export type Spine = {
-    element$: Observable<HTMLElement>;
-    getElement: () => HTMLElement | undefined;
-    locator: Locator;
-    spineItemLocator: SpineItemLocator;
-    cfiLocator: CfiLocator;
-    manipulateSpineItems: (cb: (payload: ManipulableSpineItemCallbackPayload & {
-        index: number;
-    }) => RequireLayout) => void;
-    manipulateSpineItem: (id: string, cb: Parameters<SpineItem[`manipulateSpineItem`]>[0]) => void;
-    destroy: () => void;
-    isSelecting: () => boolean | undefined;
-    getSelection: () => Selection | undefined;
-    adjustPagination: (position: ViewportNavigationEntry) => Observable<`free` | `busy`>;
-    $: {
-        $: Observable<Event>;
-        layout$: Observable<boolean>;
-        spineItems$: Observable<SpineItem[]>;
-        itemsBeforeDestroy$: Observable<void>;
-    };
-};
-export {};

package/dist/types/index.d.ts

@@ -1,12 +0,0 @@
-import { Manifest } from '@prose-reader/shared';
-
-export type ViewportPosition = {
-    x: number;
-    y: number;
-};
-declare global {
-    interface Window {
-        __PROSE_READER_DEBUG?: boolean;
-    }
-}
-export { Manifest };

package/dist/types/reader.d.ts

@@ -1,44 +0,0 @@
-import { Observable } from 'rxjs';
-import { Spine } from './Spine';
-import { Pagination } from '../pagination/pagination';
-import { Manifest } from '@prose-reader/shared';
-import { SpineItemManager } from '../spineItemManager';
-import { ViewportNavigator } from '../viewportNavigator/viewportNavigator';
-import { ComputedCoreSettings, CoreInputSettings } from '../settings/types';
-import { Context } from '../context/Context';
-import { HookManager } from '../hooks/HookManager';
-import { SettingsInterface } from '../settings/SettingsInterface';
-
-export type ContextSettings = Partial<CoreInputSettings>;
-export type LoadOptions = {
-    cfi?: string | null;
-    containerElement: HTMLElement;
-};
-export type ReaderInternal = {
-    context: Context;
-    spine: Spine;
-    spineItemManager: SpineItemManager;
-    viewportNavigator: ViewportNavigator;
-    settings: SettingsInterface<CoreInputSettings, CoreInputSettings & ComputedCoreSettings>;
-    hookManager: HookManager;
-    layout: () => void;
-    load: (manifest: Manifest, loadOptions: LoadOptions) => void;
-    destroy: () => void;
-    pagination: Pagination;
-    element$: Observable<HTMLElement>;
-    $: {
-        state$: Observable<{
-            supportedPageTurnAnimation: NonNullable<ContextSettings[`pageTurnAnimation`]>[];
-            supportedPageTurnMode: NonNullable<ContextSettings[`pageTurnMode`]>[];
-            supportedPageTurnDirection: NonNullable<ContextSettings[`pageTurnDirection`]>[];
-            supportedComputedPageTurnDirection: NonNullable<ContextSettings[`pageTurnDirection`]>[];
-        }>;
-        loadStatus$: Observable<"idle" | "loading" | "ready">;
-        selection$: Observable<{
-            toString: () => string;
-            getAnchorCfi: () => string | undefined;
-            getFocusCfi: () => string | undefined;
-        } | null>;
-        destroy$: Observable<void>;
-    };
-};

package/dist/viewportNavigator/manualViewportNavigator.d.ts

@@ -1,96 +0,0 @@
-import { BehaviorSubject } from 'rxjs';
-import { Context } from '../context/Context';
-import { SpineItemManager } from '../spineItemManager';
-import { createNavigationResolver, ViewportNavigationEntry } from '../spine/navigationResolver';
-import { createLocationResolver } from '../spine/locationResolver';
-
-export declare const createManualViewportNavigator: ({ navigator, spineItemManager, currentNavigationSubject$, locator, context, }: {
-    context: Context;
-    navigator: ReturnType<typeof createNavigationResolver>;
-    currentNavigationSubject$: BehaviorSubject<ViewportNavigationEntry>;
-    spineItemManager: SpineItemManager;
-    locator: ReturnType<typeof createLocationResolver>;
-}) => {
-    destroy: () => void;
-    adjustReadingOffset: () => boolean;
-    turnLeft: ({ allowSpineItemChange, }?: {
-        allowSpineItemChange?: boolean;
-    }) => void;
-    turnRight: ({ allowSpineItemChange, }?: {
-        allowSpineItemChange?: boolean;
-    }) => void;
-    goToCfi: (cfi: string, options?: {
-        animate: boolean;
-    }) => void;
-    goToPageOfCurrentChapter: (pageIndex: number) => void;
-    goToSpineItem: (indexOrId: number | string, options?: {
-        animate: boolean;
-    }) => void;
-    goToUrl: (url: string | URL) => void;
-    goToPage: (pageIndex: number) => void;
-    $: {
-        state$: import('rxjs').Observable<"start" | "end">;
-        navigation$: import('rxjs').Observable<{
-            animate: boolean;
-            lastUserExpectedNavigation: {
-                type: "navigate-from-anchor";
-                data: string;
-            };
-            x: number;
-            y: number;
-            spineItem?: import('../spineItem/createSpineItem').SpineItem;
-            url: URL;
-        } | {
-            animate: boolean;
-            lastUserExpectedNavigation: {
-                type: "navigate-from-previous-item";
-            };
-            x: number;
-            y: number;
-            spineItem?: import('../spineItem/createSpineItem').SpineItem;
-        } | {
-            lastUserExpectedNavigation: undefined;
-            animate: boolean;
-            x: number;
-            y: number;
-            spineItem?: import('../spineItem/createSpineItem').SpineItem;
-        } | {
-            lastUserExpectedNavigation: {
-                type: "navigate-from-next-item";
-            };
-            animate: boolean;
-            x: number;
-            y: number;
-            spineItem?: import('../spineItem/createSpineItem').SpineItem;
-        } | {
-            lastUserExpectedNavigation: {
-                type: "navigate-from-previous-item";
-            };
-            animate: boolean;
-            x: number;
-            y: number;
-            spineItem?: import('../spineItem/createSpineItem').SpineItem;
-        } | {
-            lastUserExpectedNavigation: undefined;
-            animate: boolean;
-            x: number;
-            y: number;
-            spineItem?: import('../spineItem/createSpineItem').SpineItem;
-        } | {
-            animate: boolean;
-            lastUserExpectedNavigation: {
-                type: "navigate-from-cfi";
-                data: string;
-            };
-            x: number;
-            y: number;
-            spineItem?: import('../spineItem/createSpineItem').SpineItem;
-        } | {
-            lastUserExpectedNavigation: undefined;
-            animate: boolean;
-            x: number;
-            y: number;
-            spineItem?: import('../spineItem/createSpineItem').SpineItem;
-        }>;
-    };
-};

package/dist/viewportNavigator/panViewportNavigator.d.ts

@@ -1,55 +0,0 @@
-import { BehaviorSubject, Subject } from 'rxjs';
-import { Context } from '../context/Context';
-import { SpineItemManager } from '../spineItemManager';
-import { createNavigationResolver, ViewportNavigationEntry } from '../spine/navigationResolver';
-import { createLocationResolver } from '../spine/locationResolver';
-import { ViewportPosition } from '../types';
-import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
-
-export declare const createPanViewportNavigator: ({ getCurrentViewportPosition, navigator, spineItemManager, locator, context, currentNavigationSubject$, settings, }: {
-    context: Context;
-    navigator: ReturnType<typeof createNavigationResolver>;
-    currentNavigationSubject$: BehaviorSubject<ViewportNavigationEntry>;
-    spineItemManager: SpineItemManager;
-    locator: ReturnType<typeof createLocationResolver>;
-    getCurrentViewportPosition: () => ViewportPosition;
-    settings: ReaderSettingsManager;
-}) => {
-    moveTo: ((delta: {
-        x: number;
-        y: number;
-    } | undefined, { final, start }?: {
-        start?: boolean;
-        final?: boolean;
-    }) => void) | ((delta: {
-        x: number;
-        y: number;
-    } | undefined, args_1?: {
-        start?: boolean;
-        final?: boolean;
-    } | undefined) => ReturnType<(delta: {
-        x: number;
-        y: number;
-    } | undefined, { final, start }?: {
-        start?: boolean;
-        final?: boolean;
-    }) => void>);
-    destroy: () => void;
-    adjustReadingOffset: () => boolean;
-    $: {
-        moveToSubject$: Subject<{
-            position: ViewportNavigationEntry;
-        }>;
-        state$: import('rxjs').Observable<"start" | "end">;
-        navigation$: import('rxjs').Observable<{
-            lastUserExpectedNavigation: {
-                type: "navigate-from-next-item";
-            } | {
-                type: "navigate-from-previous-item";
-            } | undefined;
-            x: number;
-            y: number;
-            spineItem?: import('../spineItem/createSpineItem').SpineItem;
-        }>;
-    };
-};

package/dist/viewportNavigator/scrollViewportNavigator.d.ts

@@ -1,38 +0,0 @@
-import { BehaviorSubject, Observable } from 'rxjs';
-import { Context } from '../context/Context';
-import { Spine } from '../spine/createSpine';
-import { createNavigationResolver, ViewportNavigationEntry } from '../spine/navigationResolver';
-import { SpineItemManager } from '../spineItemManager';
-import { ViewportPosition } from '../types';
-import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
-
-type ScaledDownPosition = ViewportPosition;
-export declare const createScrollViewportNavigator: ({ context, element$, navigator, currentNavigationSubject$, settings, spine, }: {
-    context: Context;
-    settings: ReaderSettingsManager;
-    element$: BehaviorSubject<HTMLElement>;
-    navigator: ReturnType<typeof createNavigationResolver>;
-    currentNavigationSubject$: BehaviorSubject<ViewportNavigationEntry>;
-    spine: Spine;
-    spineItemManager: SpineItemManager;
-}) => {
-    destroy: () => void;
-    adjustReadingOffset: ({ x, y }: {
-        x: number;
-        y: number;
-    }) => boolean;
-    getNavigationForPosition: (position: ScaledDownPosition) => ViewportNavigationEntry;
-    getCurrentViewportPosition: () => {
-        x: number;
-        y: number;
-    };
-    $: {
-        state$: Observable<"start" | "end">;
-        navigation$: Observable<{
-            position: ViewportNavigationEntry;
-            animate: boolean;
-            lastUserExpectedNavigation: undefined;
-        }>;
-    };
-};
-export {};

package/dist/viewportNavigator/types.d.ts

@@ -1,34 +0,0 @@
-import { SpineItem } from '../spineItem/createSpineItem';
-
-export type LastUserExpectedNavigation = undefined | {
-    type: `navigate-from-previous-item`;
-} | {
-    type: `navigate-from-next-item`;
-} | {
-    type: `navigate-from-cfi`;
-    data: string;
-} | {
-    type: `navigate-from-anchor`;
-    data: string;
-};
-export type Navigation = {
-    position: {
-        x: number;
-        y: number;
-        spineItem?: SpineItem | undefined;
-    };
-    triggeredBy: `scroll` | `manual` | `adjust`;
-    animation: false | `turn` | `snap`;
-    lastUserExpectedNavigation: LastUserExpectedNavigation;
-};
-export type AdjustedNavigation = {
-    previousNavigationPosition: {
-        x: number;
-        y: number;
-    };
-    adjustedSpinePosition: {
-        x: number;
-        y: number;
-    };
-    areDifferent: boolean;
-};

package/dist/viewportNavigator/viewportNavigator.d.ts

@@ -1,82 +0,0 @@
-import { Context } from '../context/Context';
-import { Pagination } from '../pagination/pagination';
-import { SpineItemManager } from '../spineItemManager';
-import { createLocationResolver } from '../spine/locationResolver';
-import { ViewportNavigationEntry } from '../spine/navigationResolver';
-import { BehaviorSubject, Observable } from 'rxjs';
-import { createCfiLocator } from '../spine/cfiLocator';
-import { LastUserExpectedNavigation, Navigation } from './types';
-import { Spine } from '../spine/createSpine';
-import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
-import { HookManager } from '../hooks/HookManager';
-
-export declare const createViewportNavigator: ({ spineItemManager, context, pagination, parentElement$, cfiLocator, spineLocator, hookManager, spine, settings, }: {
-    spineItemManager: SpineItemManager;
-    pagination: Pagination;
-    context: Context;
-    parentElement$: BehaviorSubject<HTMLElement | undefined>;
-    cfiLocator: ReturnType<typeof createCfiLocator>;
-    spineLocator: ReturnType<typeof createLocationResolver>;
-    hookManager: HookManager;
-    spine: Spine;
-    settings: ReaderSettingsManager;
-}) => {
-    destroy: () => void;
-    layout: () => void;
-    getCurrentNavigationPosition: () => ViewportNavigationEntry;
-    getCurrentViewportPosition: (() => {
-        x: number;
-        y: number;
-    }) | (() => ReturnType<() => {
-        x: number;
-        y: number;
-    }>);
-    turnLeft: ({ allowSpineItemChange, }?: {
-        allowSpineItemChange?: boolean;
-    }) => void;
-    turnRight: ({ allowSpineItemChange, }?: {
-        allowSpineItemChange?: boolean;
-    }) => void;
-    goToPage: (pageIndex: number) => void;
-    goToSpineItem: (indexOrId: number | string, options?: {
-        animate: boolean;
-    }) => void;
-    goToUrl: (url: string | URL) => void;
-    goToCfi: (cfi: string, options?: {
-        animate: boolean;
-    }) => void;
-    goToPageOfCurrentChapter: (pageIndex: number) => void;
-    moveTo: ((delta: {
-        x: number;
-        y: number;
-    } | undefined, { final, start }?: {
-        start?: boolean;
-        final?: boolean;
-    }) => void) | ((delta: {
-        x: number;
-        y: number;
-    } | undefined, args_1?: {
-        start?: boolean;
-        final?: boolean;
-    } | undefined) => ReturnType<(delta: {
-        x: number;
-        y: number;
-    } | undefined, { final, start }?: {
-        start?: boolean;
-        final?: boolean;
-    }) => void>);
-    getLastUserExpectedNavigation: () => LastUserExpectedNavigation;
-    element$: BehaviorSubject<HTMLElement>;
-    getElement: () => HTMLElement;
-    $: {
-        state$: Observable<"free" | "busy">;
-        navigation$: Observable<Navigation>;
-        navigationAdjustedAfterLayout$: Observable<{
-            previousNavigationPosition: ViewportNavigationEntry;
-            adjustedSpinePosition: ViewportNavigationEntry;
-            areDifferent: boolean;
-        }>;
-        currentNavigationPosition$: Observable<ViewportNavigationEntry>;
-    };
-};
-export type ViewportNavigator = ReturnType<typeof createViewportNavigator>;