@prose-reader/core 1.57.0 → 1.59.0

package/dist/spineItem/reflowableSpineItem.d.ts

@@ -0,0 +1,165 @@
+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 createReflowableSpineItem: ({ 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, }: {
+        blankPagePosition: `before` | `after` | `none`;
+        minimumWidth: number;
+    }) => {
+        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>;
+    };
+};

package/dist/spineItem/styles/getStyleForViewportDocument.d.ts

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

package/dist/spineItem/trackers.d.ts

@@ -0,0 +1,34 @@
+export declare const createFingerTracker: () => {
+    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;
+    }>;
+};
+export declare const createSelectionTracker: () => {
+    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;
+    }>;
+};

package/dist/spineItem/types.d.ts

@@ -0,0 +1,19 @@
+export type SpineItemPosition = {
+    x: number;
+    y: number;
+    __symbol?: `SpineItemPosition`;
+};
+export type UnsafeSpineItemPosition = {
+    x: number;
+    y: number;
+    __symbol?: `UnsafeSpineItemPosition` | `SpineItemPosition`;
+};
+export declare class SpineItemNavigationPosition {
+    __symbol: string;
+    x: number;
+    y: number;
+    constructor(position: {
+        x: number;
+        y: number;
+    });
+}