@prose-reader/core 1.57.0 → 1.59.0

package/dist/spineItem/commonSpineItem.d.ts

@@ -0,0 +1,165 @@
+import { Context } from '../context/Context';
+import { Manifest } from '../types';
+import { Observable } from 'rxjs';
+import { createFrameManipulator } from './frameItem/createFrameManipulator';
+import { SettingsManager } from '../settings/SettingsManager';
+import { HookManager } from '../hooks/HookManager';
+
+export declare const createCommonSpineItem: ({ item, context, parentElement, viewportState$, settings, hookManager, }: {
+    item: Manifest[`spineItems`][number];
+    parentElement: HTMLElement;
+    context: Context;
+    viewportState$: Observable<`free` | `busy`>;
+    settings: SettingsManager;
+    hookManager: HookManager;
+}) => {
+    item: {
+        id: string;
+        href: string;
+        renditionLayout: `reflowable` | `pre-paginated`;
+        progressionWeight: number;
+        pageSpreadLeft: true | undefined;
+        pageSpreadRight: true | undefined;
+        mediaType?: string;
+    };
+    load: () => void;
+    layout: ({ height, width, blankPagePosition, minimumWidth, }: {
+        height: number;
+        width: number;
+        blankPagePosition: `before` | `after` | `none`;
+        minimumWidth: number;
+    }) => void;
+    adjustPositionOfElement: ({ right, left, top }: {
+        right?: number;
+        left?: number;
+        top?: number;
+    }) => void;
+    getElementDimensions: () => {
+        width: number;
+        height: number;
+    };
+    getHtmlFromResource: (response: Response) => Promise<string>;
+    getResource: () => Promise<Response>;
+    translateFramePositionIntoPage: (position: {
+        clientX: number;
+        clientY: number;
+    }) => {
+        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 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;
+            }>;
+        };
+    };
+    element: HTMLElement;
+    getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+    getViewPortInformation: () => {
+        computedScale: number;
+        computedWidthScale: number;
+        viewportDimensions: {
+            width: number;
+            height: number;
+        };
+    } | undefined;
+    isImageType: () => boolean;
+    isReady: () => boolean;
+    destroy: () => void;
+    isUsingVerticalWriting: () => boolean | undefined;
+    getReadingDirection: () => "ltr" | "rtl" | undefined;
+    manipulateSpineItem: (cb: (options: {
+        container: HTMLElement;
+        item: Manifest[`spineItems`][number];
+        overlayElement: HTMLDivElement;
+    } & (ReturnType<typeof createFrameManipulator> | {
+        frame: undefined;
+        removeStyle: (id: string) => void;
+        addStyle: (id: string, style: string) => void;
+    })) => boolean) => boolean;
+    executeOnLayoutBeforeMeasurementHook: (options: {
+        minimumWidth: number;
+    }) => void[];
+    selectionTracker: {
+        track: (frameToTrack: HTMLIFrameElement) => void;
+        destroy: () => void;
+        isSelecting: () => boolean;
+        getSelection: () => Selection | undefined;
+        $: 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;
+        $: 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$: Observable<{
+            isFirstLayout: boolean;
+            isReady: boolean;
+        }>;
+        loaded$: Observable<HTMLIFrameElement>;
+        isReady$: Observable<boolean>;
+    };
+};

package/dist/spineItem/createSpineItem.d.ts

@@ -0,0 +1,167 @@
+import { Observable } from 'rxjs';
+import { Context } from '../context/Context';
+import { Manifest } from '../types';
+import { SettingsManager } from '../settings/SettingsManager';
+import { HookManager } from '../hooks/HookManager';
+
+export declare const createSpineItem: ({ item, context, containerElement, viewportState$, settings, hookManager, }: {
+    item: Manifest[`spineItems`][number];
+    containerElement: HTMLElement;
+    context: Context;
+    viewportState$: Observable<`free` | `busy`>;
+    settings: SettingsManager;
+    hookManager: HookManager;
+}) => {
+    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;
+    };
+    load: () => void;
+    adjustPositionOfElement: ({ right, left, top }: {
+        right?: number;
+        left?: number;
+        top?: number;
+    }) => void;
+    getElementDimensions: () => {
+        width: number;
+        height: number;
+    };
+    getHtmlFromResource: (response: Response) => Promise<string>;
+    getResource: () => Promise<Response>;
+    translateFramePositionIntoPage: (position: {
+        clientX: number;
+        clientY: number;
+    }) => {
+        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('./frameItem/createFrameManipulator').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;
+            }>;
+        };
+    };
+    element: HTMLElement;
+    getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+    getViewPortInformation: () => {
+        computedScale: number;
+        computedWidthScale: number;
+        viewportDimensions: {
+            width: number;
+            height: number;
+        };
+    } | undefined;
+    isImageType: () => boolean;
+    isReady: () => boolean;
+    destroy: () => void;
+    isUsingVerticalWriting: () => boolean | undefined;
+    getReadingDirection: () => "ltr" | "rtl" | undefined;
+    manipulateSpineItem: (cb: (options: {
+        container: HTMLElement;
+        item: Manifest[`spineItems`][number];
+        overlayElement: HTMLDivElement;
+    } & (ReturnType<typeof import('./frameItem/createFrameManipulator').createFrameManipulator> | {
+        frame: undefined;
+        removeStyle: (id: string) => void;
+        addStyle: (id: string, style: string) => void;
+    })) => boolean) => boolean;
+    executeOnLayoutBeforeMeasurementHook: (options: {
+        minimumWidth: number;
+    }) => void[];
+    selectionTracker: {
+        track: (frameToTrack: HTMLIFrameElement) => void;
+        destroy: () => void;
+        isSelecting: () => boolean;
+        getSelection: () => Selection | undefined;
+        $: 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;
+        $: 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$: Observable<{
+            isFirstLayout: boolean;
+            isReady: boolean;
+        }>;
+        loaded$: Observable<HTMLIFrameElement>;
+        isReady$: Observable<boolean>;
+    };
+};
+export type SpineItem = ReturnType<typeof createSpineItem>;

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

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

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

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

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

@@ -0,0 +1,3 @@
+import { Manifest } from '../../types';
+
+export declare const createHtmlPageFromResource: (resourceResponse: Response | string, item: Manifest[`spineItems`][number]) => Promise<string>;

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

@@ -0,0 +1,49 @@
+import { Observable } from 'rxjs';
+import { Manifest } from '../../types';
+import { Context } from '../../context/Context';
+import { createFrameManipulator } from './createFrameManipulator';
+import { SettingsManager } from '../../settings/SettingsManager';
+import { HookManager } from '../../hooks/HookManager';
+
+export declare const createFrameItem: ({ item, parent, fetchResource, context, viewportState$, settings, hookManager, }: {
+    parent: HTMLElement;
+    item: Manifest[`spineItems`][number];
+    context: Context;
+    fetchResource?: (item: Manifest[`spineItems`][number]) => Promise<Response>;
+    viewportState$: Observable<`free` | `busy`>;
+    settings: SettingsManager;
+    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

@@ -0,0 +1,30 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { Context } from '../../context/Context';
+import { Manifest } from '../../types';
+import { SettingsManager } from '../../settings/SettingsManager';
+import { HookManager } from '../../hooks/HookManager';
+
+export declare const createLoader: ({ item, parent, fetchResource, context, viewportState$, settings, hookManager, }: {
+    item: Manifest[`spineItems`][number];
+    parent: HTMLElement;
+    fetchResource?: (item: Manifest[`spineItems`][number]) => Promise<Response>;
+    context: Context;
+    settings: SettingsManager;
+    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/spineItem/locationResolver.d.ts

@@ -0,0 +1,24 @@
+import { Context } from '../context/Context';
+import { SpineItem } from './createSpineItem';
+import { SpineItemPosition, UnsafeSpineItemPosition } from './types';
+
+export declare const createLocationResolver: ({ context }: {
+    context: Context;
+}) => {
+    getSpineItemPositionFromNode: (node: Node, offset: number, spineItem: SpineItem) => {
+        x: number;
+        y: number;
+    } | undefined;
+    getSpineItemPositionFromPageIndex: (pageIndex: number, spineItem: SpineItem) => SpineItemPosition;
+    getSpineItemOffsetFromAnchor: (anchor: string, spineItem: SpineItem) => number;
+    getSpineItemPageIndexFromPosition: (position: UnsafeSpineItemPosition, spineItem: SpineItem) => number;
+    getSpineItemPageIndexFromNode: (node: Node, offset: number, spineItem: SpineItem) => number | undefined;
+    getSpineItemClosestPositionFromUnsafePosition: (unsafePosition: UnsafeSpineItemPosition, spineItem: SpineItem) => {
+        x: number;
+        y: number;
+    };
+    getFirstNodeOrRangeAtPage: (pageIndex: number, spineItem: SpineItem) => {
+        node: Node;
+        offset: number;
+    } | undefined;
+};

package/dist/spineItem/navigationResolver.d.ts

@@ -0,0 +1,16 @@
+import { SpineItem } from './createSpineItem';
+import { Context } from '../context/Context';
+import { SpineItemNavigationPosition, UnsafeSpineItemPosition } from './types';
+import { SettingsManager } from '../settings/SettingsManager';
+
+export declare const createNavigationResolver: ({ context }: {
+    context: Context;
+    settings: SettingsManager;
+}) => {
+    getNavigationForLeftPage: (position: UnsafeSpineItemPosition, spineItem: SpineItem) => SpineItemNavigationPosition;
+    getNavigationForRightPage: (position: UnsafeSpineItemPosition, spineItem: SpineItem) => SpineItemNavigationPosition;
+    getNavigationForLastPage: (spineItem: SpineItem) => SpineItemNavigationPosition;
+    getNavigationForPage: (pageIndex: number, spineItem: SpineItem) => SpineItemNavigationPosition;
+    getNavigationForPosition: (spineItem: SpineItem, position: UnsafeSpineItemPosition) => SpineItemNavigationPosition;
+    getNavigationFromNode: (spineItem: SpineItem, node: Node, offset: number) => SpineItemNavigationPosition;
+};

package/dist/spineItem/prePaginatedSpineItem.d.ts

@@ -0,0 +1,166 @@
+import { Observable } from 'rxjs';
+import { Context } from '../context/Context';
+import { Manifest } from '../types';
+import { SettingsManager } from '../settings/SettingsManager';
+import { HookManager } from '../hooks/HookManager';
+
+export declare const createPrePaginatedSpineItem: ({ item, context, containerElement, viewportState$, settings, hookManager, }: {
+    item: Manifest[`spineItems`][number];
+    containerElement: HTMLElement;
+    context: Context;
+    viewportState$: Observable<`free` | `busy`>;
+    settings: SettingsManager;
+    hookManager: HookManager;
+}) => {
+    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;
+    };
+    load: () => void;
+    adjustPositionOfElement: ({ right, left, top }: {
+        right?: number;
+        left?: number;
+        top?: number;
+    }) => void;
+    getElementDimensions: () => {
+        width: number;
+        height: number;
+    };
+    getHtmlFromResource: (response: Response) => Promise<string>;
+    getResource: () => Promise<Response>;
+    translateFramePositionIntoPage: (position: {
+        clientX: number;
+        clientY: number;
+    }) => {
+        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('./frameItem/createFrameManipulator').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;
+            }>;
+        };
+    };
+    element: HTMLElement;
+    getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+    getViewPortInformation: () => {
+        computedScale: number;
+        computedWidthScale: number;
+        viewportDimensions: {
+            width: number;
+            height: number;
+        };
+    } | undefined;
+    isImageType: () => boolean;
+    isReady: () => boolean;
+    destroy: () => void;
+    isUsingVerticalWriting: () => boolean | undefined;
+    getReadingDirection: () => "ltr" | "rtl" | undefined;
+    manipulateSpineItem: (cb: (options: {
+        container: HTMLElement;
+        item: Manifest[`spineItems`][number];
+        overlayElement: HTMLDivElement;
+    } & (ReturnType<typeof import('./frameItem/createFrameManipulator').createFrameManipulator> | {
+        frame: undefined;
+        removeStyle: (id: string) => void;
+        addStyle: (id: string, style: string) => void;
+    })) => boolean) => boolean;
+    executeOnLayoutBeforeMeasurementHook: (options: {
+        minimumWidth: number;
+    }) => void[];
+    selectionTracker: {
+        track: (frameToTrack: HTMLIFrameElement) => void;
+        destroy: () => void;
+        isSelecting: () => boolean;
+        getSelection: () => Selection | undefined;
+        $: 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;
+        $: 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$: Observable<{
+            isFirstLayout: boolean;
+            isReady: boolean;
+        }>;
+        loaded$: Observable<HTMLIFrameElement>;
+        isReady$: Observable<boolean>;
+    };
+};