@prose-reader/core 0.0.36

package/dist/spineItemManager.d.ts

@@ -0,0 +1,264 @@
+import { Context } from "./context";
+import { SpineItem } from "./spineItem/createSpineItem";
+import { ViewportPosition } from "./types";
+export declare const createSpineItemManager: ({ context }: {
+    context: Context;
+}) => {
+    add: (spineItem: SpineItem) => void;
+    get: (indexOrId: number | string) => SpineItem | undefined;
+    getAll: () => SpineItem[];
+    getLength: () => number;
+    layout: () => void;
+    focus: (indexOrSpineItem: number | SpineItem) => void;
+    loadContents: ((rangeOfIndex: [number, number]) => void) | ((rangeOfIndex: [number, number]) => void);
+    comparePositionOf: (toCompare: SpineItem, withItem: SpineItem) => "before" | "after";
+    getAbsolutePositionOf: ((spineItemOrIndex: SpineItem | number) => {
+        leftStart: number;
+        leftEnd: number;
+        topStart: number;
+        topEnd: number;
+        width: number;
+        height: number;
+    }) | ((spineItemOrIndex: number | SpineItem) => {
+        leftStart: number;
+        leftEnd: number;
+        topStart: number;
+        topEnd: number;
+        width: number;
+        height: number;
+    });
+    getSpineItemAtPosition: ((position: ViewportPosition) => SpineItem | undefined) | ((position: ViewportPosition) => SpineItem | undefined);
+    getFocusedSpineItem: () => ({
+        item: {
+            id: string;
+            href: string;
+            path: string;
+            renditionLayout: "reflowable" | "pre-paginated";
+            progressionWeight: number;
+            pageSpreadLeft: true | undefined;
+            pageSpreadRight: true | undefined;
+            mediaType?: string | undefined;
+        };
+    } & {
+        layout: (layoutInformation: {
+            blankPagePosition: "after" | "before" | "none";
+            minimumWidth: number;
+            spreadPosition: "right" | "left" | "none";
+        }) => {
+            width: number;
+            height: number;
+        };
+        load: () => void;
+        adjustPositionOfElement: ({ right, left, top }: {
+            right?: number | undefined;
+            left?: number | undefined;
+            top?: number | undefined;
+        }) => void;
+        createLoadingElement: (containerElement: HTMLElement, item: {
+            id: string;
+            href: string;
+            path: string;
+            renditionLayout: "reflowable" | "pre-paginated";
+            progressionWeight: number;
+            pageSpreadLeft: true | undefined;
+            pageSpreadRight: true | undefined;
+            mediaType?: string | undefined;
+        }, context: {
+            load: (newManifest: import("@prose-reader/shared/src/Manifest").Manifest, newLoadOptions: import("./types").LoadOptions) => void;
+            isRTL: () => boolean;
+            areAllItemsPrePaginated: () => boolean;
+            destroy: () => void;
+            getLoadOptions: () => import("./types").LoadOptions | undefined;
+            getCalculatedInnerMargin: () => number;
+            getVisibleAreaRect: () => {
+                width: number;
+                height: number;
+                x: number;
+                y: number;
+            };
+            shouldDisplaySpread: () => boolean;
+            setHasVerticalWriting: () => void;
+            setVisibleAreaRect: (x: number, y: number, width: number, height: number) => void;
+            getManifest: () => import("@prose-reader/shared/src/Manifest").Manifest | undefined;
+            getReadingDirection: () => "ltr" | "rtl" | undefined;
+            getPageSize: () => {
+                width: number;
+                height: number;
+            };
+            getSettings: () => import("./settings").PublicSettings & {
+                computedPageTurnMode: "controlled" | "scrollable";
+                computedPageTurnDirection: "vertical" | "horizontal";
+                computedPageTurnAnimation: "none" | "fade" | "slide";
+                computedPageTurnAnimationDuration: number;
+                computedSnapAnimationDuration: number;
+            };
+            setSettings: (data: Partial<import("./settings").PublicSettings>) => void;
+            $: {
+                hasVerticalWriting$: import("rxjs").Observable<boolean>;
+                destroy$: import("rxjs").Observable<void>;
+                settings$: import("rxjs").Observable<import("./settings").PublicSettings & {
+                    computedPageTurnMode: "controlled" | "scrollable";
+                    computedPageTurnDirection: "vertical" | "horizontal";
+                    computedPageTurnAnimation: "none" | "fade" | "slide";
+                    computedPageTurnAnimationDuration: number;
+                    computedSnapAnimationDuration: number;
+                }>;
+                load$: import("rxjs").Observable<import("@prose-reader/shared/src/Manifest").Manifest>;
+            };
+        }) => HTMLDivElement;
+        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: () => {
+                frame: HTMLIFrameElement;
+                removeStyle: (id: string) => void;
+                addStyle: (id: string, style: string, prepend?: boolean) => void;
+            } | undefined;
+            getReadingDirection: () => "ltr" | "rtl" | undefined;
+            isUsingVerticalWriting: () => boolean;
+            getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined;
+            destroy: () => void;
+            $: {
+                unload$: import("rxjs").Observable<void>;
+                unloaded$: import("rxjs").Observable<void>;
+                loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                ready$: import("rxjs").Observable<FontFaceSet | undefined>;
+                isReady$: import("rxjs").Observable<boolean>;
+                contentLayoutChange$: import("rxjs").Observable<{
+                    isFirstLayout: boolean;
+                } | {
+                    isFirstLayout: boolean;
+                }>;
+            };
+        };
+        element: HTMLElement;
+        loadingElement: HTMLDivElement;
+        isReflowable: boolean;
+        getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+        getViewPortInformation: () => {
+            computedScale: number;
+            computedWidthScale: number;
+            viewportDimensions: {
+                width: number;
+                height: number;
+            };
+        } | {
+            width?: number | undefined;
+            height?: number | undefined;
+            computedScale: number;
+            computedWidthScale: number;
+            viewportDimensions?: undefined;
+        };
+        isImageType: () => boolean | undefined;
+        isReady: () => boolean;
+        destroy: () => void;
+        isUsingVerticalWriting: () => boolean | undefined;
+        getReadingDirection: () => "ltr" | "rtl" | undefined;
+        manipulateSpineItem: (cb: (options: {
+            container: HTMLElement;
+            loadingElement: HTMLElement;
+            item: {
+                id: string;
+                href: string;
+                path: string;
+                renditionLayout: "reflowable" | "pre-paginated";
+                progressionWeight: number;
+                pageSpreadLeft: true | undefined;
+                pageSpreadRight: true | undefined;
+                mediaType?: string | undefined;
+            };
+            overlayElement: HTMLDivElement;
+        } & ({
+            frame: HTMLIFrameElement;
+            removeStyle: (id: string) => void;
+            addStyle: (id: string, style: string, prepend?: boolean) => void;
+        } | {
+            frame: undefined;
+            removeStyle: (id: string) => void;
+            addStyle: (id: string, style: string) => void;
+        })) => boolean) => boolean;
+        executeOnLayoutBeforeMeasurmentHook: (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;
+            }>;
+        };
+        $: {
+            contentLayoutChangeSubject$: import("rxjs").Observable<{
+                isFirstLayout: boolean;
+                isReady: boolean;
+            }>;
+            loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+        };
+    }) | undefined;
+    getFocusedSpineItemIndex: () => number | undefined;
+    getSpineItemIndex: (spineItem: SpineItem | undefined) => number | undefined;
+    destroy: () => void;
+    $: {
+        focus$: import("rxjs").Observable<{
+            data: SpineItem;
+        }>;
+        layout$: import("rxjs").Observable<boolean>;
+    };
+};
+export declare type SpineItemManager = ReturnType<typeof createSpineItemManager>;

package/dist/tryEnhancer/compose.d.ts

@@ -0,0 +1,20 @@
+import { Enhancer, ExtractApi, ExtractHiddenApi, ExtractOptions } from "./enhancer";
+declare type ComposeEnhancer2<A extends Enhancer<any, any, any>, B extends Enhancer<any, any, any>> = Enhancer<ExtractOptions<A> & ExtractOptions<B>, ExtractHiddenApi<A> & ExtractHiddenApi<B>, Parameters<ExtractApi<A>[`setSettings`]>[0] & Parameters<ExtractApi<B>[`setSettings`]>[0]>;
+declare type ComposeEnhancer3<A extends Enhancer<any, any, any>, B extends Enhancer<any, any, any>, C extends Enhancer<any, any, any>> = Enhancer<ExtractOptions<A> & ExtractOptions<B> & ExtractOptions<C>, ExtractHiddenApi<A> & ExtractHiddenApi<B> & ExtractHiddenApi<C>, Parameters<ExtractApi<A>[`setSettings`]>[0] & Parameters<ExtractApi<B>[`setSettings`]>[0] & Parameters<ExtractApi<C>[`setSettings`]>[0]>;
+export declare type ComposeEnhancer<A extends Enhancer<any, any, any> = Enhancer, B extends Enhancer<any, any, any> = Enhancer, C extends Enhancer<any, any, any> = Enhancer, D extends Enhancer<any, any, any> = Enhancer, E extends Enhancer<any, any, any> = Enhancer, F extends Enhancer<any, any, any> = Enhancer, G extends Enhancer<any, any, any> = Enhancer, H extends Enhancer<any, any, any> = Enhancer, I extends Enhancer<any, any, any> = Enhancer, J extends Enhancer<any, any, any> = Enhancer, K extends Enhancer<any, any, any> = Enhancer, L extends Enhancer<any, any, any> = Enhancer, M extends Enhancer<any, any, any> = Enhancer, N extends Enhancer<any, any, any> = Enhancer, O extends Enhancer<any, any, any> = Enhancer> = Enhancer<ExtractOptions<A> & ExtractOptions<B> & ExtractOptions<C> & ExtractOptions<D> & ExtractOptions<E> & ExtractOptions<F> & ExtractOptions<G> & ExtractOptions<H> & ExtractOptions<I> & ExtractOptions<J> & ExtractOptions<K> & ExtractOptions<L> & ExtractOptions<M> & ExtractOptions<N> & ExtractOptions<O>, ExtractHiddenApi<A> & ExtractHiddenApi<B> & ExtractHiddenApi<C> & ExtractHiddenApi<D> & ExtractHiddenApi<E> & ExtractHiddenApi<F> & ExtractHiddenApi<G> & ExtractHiddenApi<H> & ExtractHiddenApi<I> & ExtractHiddenApi<J> & ExtractHiddenApi<K> & ExtractHiddenApi<L> & ExtractHiddenApi<M> & ExtractHiddenApi<N> & ExtractHiddenApi<O>, Parameters<ExtractApi<A>[`setSettings`]>[0] & Parameters<ExtractApi<B>[`setSettings`]>[0] & Parameters<ExtractApi<C>[`setSettings`]>[0] & Parameters<ExtractApi<D>[`setSettings`]>[0] & Parameters<ExtractApi<E>[`setSettings`]>[0] & Parameters<ExtractApi<F>[`setSettings`]>[0] & Parameters<ExtractApi<G>[`setSettings`]>[0] & Parameters<ExtractApi<H>[`setSettings`]>[0] & Parameters<ExtractApi<I>[`setSettings`]>[0] & Parameters<ExtractApi<J>[`setSettings`]>[0] & Parameters<ExtractApi<K>[`setSettings`]>[0] & Parameters<ExtractApi<L>[`setSettings`]>[0] & Parameters<ExtractApi<M>[`setSettings`]>[0] & Parameters<ExtractApi<N>[`setSettings`]>[0] & Parameters<ExtractApi<O>[`setSettings`]>[0]>;
+export declare function composeEnhancer<A extends Enhancer<any, any, any>>(a: A): ComposeEnhancer<A>;
+export declare function composeEnhancer<A extends Enhancer<any, any, any>, B extends Enhancer<any, any, any>>(a: A, b: B): ComposeEnhancer2<A, B>;
+export declare function composeEnhancer<A extends Enhancer<any, any, any>, B extends Enhancer<any, any, any>, C extends Enhancer<any, any, any>>(a: A, b: B, c: C): ComposeEnhancer3<A, B, C>;
+export declare function composeEnhancer<A extends Enhancer<any, any, any>, B extends Enhancer<any, any, any>, C extends Enhancer<any, any, any>, D extends Enhancer<any, any, any>>(a: A, b: B, c: C, d: D): ComposeEnhancer<A, B, C, D>;
+export declare function composeEnhancer<A extends Enhancer<any, any, any>, B extends Enhancer<any, any, any>, C extends Enhancer<any, any, any>, D extends Enhancer<any, any, any>, E extends Enhancer<any, any, any>>(a: A, b: B, c: C, d: D, e: E): ComposeEnhancer<A, B, C, D, E>;
+export declare function composeEnhancer<A extends Enhancer<any, any, any>, B extends Enhancer<any, any, any>, C extends Enhancer<any, any, any>, D extends Enhancer<any, any, any>, E extends Enhancer<any, any, any>, F extends Enhancer<any, any, any>>(a: A, b: B, c: C, d: D, e: E, f: F): ComposeEnhancer<A, B, C, D, E, F>;
+export declare function composeEnhancer<A extends Enhancer<any, any, any>, B extends Enhancer<any, any, any>, C extends Enhancer<any, any, any>, D extends Enhancer<any, any, any>, E extends Enhancer<any, any, any>, F extends Enhancer<any, any, any>, G extends Enhancer<any, any, any>>(a: A, b: B, c: C, d: D, e: E, f: F, g: G): ComposeEnhancer<A, B, C, D, E, F, G>;
+export declare function composeEnhancer<A extends Enhancer<any, any, any>, B extends Enhancer<any, any, any>, C extends Enhancer<any, any, any>, D extends Enhancer<any, any, any>, E extends Enhancer<any, any, any>, F extends Enhancer<any, any, any>, G extends Enhancer<any, any, any>, H extends Enhancer<any, any, any>>(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H): ComposeEnhancer<A, B, C, D, E, F, G, H>;
+export declare function composeEnhancer<A extends Enhancer<any, any, any>, B extends Enhancer<any, any, any>, C extends Enhancer<any, any, any>, D extends Enhancer<any, any, any>, E extends Enhancer<any, any, any>, F extends Enhancer<any, any, any>, G extends Enhancer<any, any, any>, H extends Enhancer<any, any, any>, I extends Enhancer<any, any, any>>(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I): ComposeEnhancer<A, B, C, D, E, F, G, H, I>;
+export declare function composeEnhancer<A extends Enhancer<any, any, any>, B extends Enhancer<any, any, any>, C extends Enhancer<any, any, any>, D extends Enhancer<any, any, any>, E extends Enhancer<any, any, any>, F extends Enhancer<any, any, any>, G extends Enhancer<any, any, any>, H extends Enhancer<any, any, any>, I extends Enhancer<any, any, any>, J extends Enhancer<any, any, any>>(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J): ComposeEnhancer<A, B, C, D, E, F, G, H, I, J>;
+export declare function composeEnhancer<A extends Enhancer<any, any, any>, B extends Enhancer<any, any, any>, C extends Enhancer<any, any, any>, D extends Enhancer<any, any, any>, E extends Enhancer<any, any, any>, F extends Enhancer<any, any, any>, G extends Enhancer<any, any, any>, H extends Enhancer<any, any, any>, I extends Enhancer<any, any, any>, J extends Enhancer<any, any, any>, K extends Enhancer<any, any, any>>(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K): ComposeEnhancer<A, B, C, D, E, F, G, H, I, J, K>;
+export declare function composeEnhancer<A extends Enhancer<any, any, any>, B extends Enhancer<any, any, any>, C extends Enhancer<any, any, any>, D extends Enhancer<any, any, any>, E extends Enhancer<any, any, any>, F extends Enhancer<any, any, any>, G extends Enhancer<any, any, any>, H extends Enhancer<any, any, any>, I extends Enhancer<any, any, any>, J extends Enhancer<any, any, any>, K extends Enhancer<any, any, any>, L extends Enhancer<any, any, any>>(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L): ComposeEnhancer<A, B, C, D, E, F, G, H, I, J, K, L>;
+export declare function composeEnhancer<A extends Enhancer<any, any, any>, B extends Enhancer<any, any, any>, C extends Enhancer<any, any, any>, D extends Enhancer<any, any, any>, E extends Enhancer<any, any, any>, F extends Enhancer<any, any, any>, G extends Enhancer<any, any, any>, H extends Enhancer<any, any, any>, I extends Enhancer<any, any, any>, J extends Enhancer<any, any, any>, K extends Enhancer<any, any, any>, L extends Enhancer<any, any, any>, M extends Enhancer<any, any, any>>(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M): ComposeEnhancer<A, B, C, D, E, F, G, H, I, J, K, L, M>;
+export declare function composeEnhancer<A extends Enhancer<any, any, any>, B extends Enhancer<any, any, any>, C extends Enhancer<any, any, any>, D extends Enhancer<any, any, any>, E extends Enhancer<any, any, any>, F extends Enhancer<any, any, any>, G extends Enhancer<any, any, any>, H extends Enhancer<any, any, any>, I extends Enhancer<any, any, any>, J extends Enhancer<any, any, any>, K extends Enhancer<any, any, any>, L extends Enhancer<any, any, any>, M extends Enhancer<any, any, any>, N extends Enhancer<any, any, any>>(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N): ComposeEnhancer<A, B, C, D, E, F, G, H, I, J, K, L, M, N>;
+export declare function composeEnhancer<A extends Enhancer<any, any, any>, B extends Enhancer<any, any, any>, C extends Enhancer<any, any, any>, D extends Enhancer<any, any, any>, E extends Enhancer<any, any, any>, F extends Enhancer<any, any, any>, G extends Enhancer<any, any, any>, H extends Enhancer<any, any, any>, I extends Enhancer<any, any, any>, J extends Enhancer<any, any, any>, K extends Enhancer<any, any, any>, L extends Enhancer<any, any, any>, M extends Enhancer<any, any, any>, N extends Enhancer<any, any, any>, O extends Enhancer<any, any, any>>(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O): ComposeEnhancer<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>;
+export {};

package/dist/tryEnhancer/createReader.d.ts

@@ -0,0 +1,3 @@
+import { createReader, Reader } from '../reader';
+export declare type ReaderOptions = Parameters<typeof createReader>[0];
+export { createReader, Reader };

package/dist/tryEnhancer/enhancer.d.ts

@@ -0,0 +1,24 @@
+import { Observable, ObservedValueOf } from "rxjs";
+import { Reader, ReaderOptions } from "./createReader";
+declare type AnyObject = Record<string, any>;
+declare type DeepPartialAny<T> = {
+    [P in keyof T]?: T[P] extends AnyObject ? DeepPartialAny<T[P]> : any;
+};
+declare type Primitive = number | string | ((...args: any) => any);
+declare type ModifyDeep<A extends AnyObject, B extends DeepPartialAny<A>> = {
+    [K in keyof A]-?: B[K] extends never ? A[K] : B[K] extends Function ? B[K] : B[K] extends Observable<any> ? B[K] : B[K] extends AnyObject ? ModifyDeep<A[K], B[K]> : B[K] extends Primitive ? B[K] : A[K];
+} & (A extends AnyObject ? Omit<B, keyof A> : A);
+declare type CreateReader = (options: ReaderOptions) => Reader;
+declare type RawEnhancer = (createReader: CreateReader) => (options: ReaderOptions) => Reader;
+export declare type ExtractOptions<E extends (...args: any) => (options: any) => any> = Parameters<ReturnType<E>>[0];
+export declare type ExtractApi<E extends (...args: any) => (options: any) => any> = ReturnType<ReturnType<E>>;
+export declare type ExtractHiddenApi<E extends (...args: any) => (options: any) => any> = NonNullable<ReturnType<ReturnType<E>>[`__API`]>;
+export declare type Enhancer<Options = {}, Api = {}, Settings = {}, DependsOn extends Enhancer<any, any, any> = RawEnhancer> = (createReader: (options: ExtractOptions<DependsOn>) => Omit<ReturnType<ReturnType<DependsOn>>, `__API`>) => (options: ExtractOptions<DependsOn> & Options) => ModifyDeep<Omit<ExtractApi<DependsOn>, `__API` | `$`>, {
+    setSettings: (settings: Parameters<ExtractApi<DependsOn>[`setSettings`]>[0] & Settings) => void;
+    $: Omit<ExtractApi<DependsOn>[`$`], `settings$`> & {
+        settings$: Observable<Settings & ObservedValueOf<ExtractApi<DependsOn>[`$`][`settings$`]>>;
+    };
+} & Api> & {
+    __API?: Api;
+};
+export {};

package/dist/tryEnhancer/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/Hook.d.ts

@@ -0,0 +1,70 @@
+import { Manifest } from "@prose-reader/shared";
+import { Observable } from "rxjs";
+export declare type Hook = {
+    name: `item.onLoad`;
+    fn: (manipulableFrame: {
+        frame: HTMLIFrameElement;
+        removeStyle: (id: string) => void;
+        item: Manifest[`spineItems`][number];
+        addStyle: (id: string, style: CSSStyleDeclaration[`cssText`]) => void;
+    }) => (() => void) | Observable<any> | void;
+} | {
+    name: `item.onCreated`;
+    fn: (payload: {
+        container: HTMLElement;
+        loadingElement: HTMLElement;
+        item: Manifest[`spineItems`][number];
+    }) => (() => void) | Observable<any> | void;
+} | {
+    name: `item.onBeforeContainerCreated`;
+    fn: (payload: HTMLElement) => HTMLElement;
+} | {
+    name: `item.onLayoutBeforeMeasurment`;
+    fn: (payload: {
+        frame: {
+            getManipulableFrame: () => undefined | {
+                removeStyle: (id: string) => void;
+                addStyle: (id: string, style: CSSStyleDeclaration[`cssText`]) => void;
+            };
+            getViewportDimensions: () => {
+                width: number;
+                height: number;
+            } | undefined;
+            isUsingVerticalWriting: () => boolean;
+            getIsReady: () => boolean;
+        };
+        container: HTMLElement;
+        item: Manifest[`spineItems`][number];
+        minimumWidth: number;
+        isImageType: () => boolean | undefined;
+    }) => void;
+} | {
+    name: `item.onGetResource`;
+    fn: (fetchResource: (item: Manifest[`spineItems`][number]) => Promise<Response>) => (item: Manifest[`spineItems`][number]) => Promise<Response>;
+} | {
+    name: `spine.onBeforeContainerCreated`;
+    fn: (payload: HTMLElement) => HTMLElement;
+} | {
+    name: `onViewportOffsetAdjust`;
+    fn: () => void;
+};
+export interface RegisterHook {
+    (name: `item.onLoad`, fn: Extract<Hook, {
+        name: `item.onLoad`;
+    }>[`fn`]): void;
+    (name: `item.onBeforeContainerCreated`, fn: Extract<Hook, {
+        name: `item.onBeforeContainerCreated`;
+    }>[`fn`]): void;
+    (name: `item.onCreated`, fn: Extract<Hook, {
+        name: `item.onCreated`;
+    }>[`fn`]): void;
+    (name: `item.onGetResource`, fn: Extract<Hook, {
+        name: `item.onGetResource`;
+    }>[`fn`]): void;
+    (name: `item.onLayoutBeforeMeasurment`, fn: Extract<Hook, {
+        name: `item.onLayoutBeforeMeasurment`;
+    }>[`fn`]): void;
+    (name: `onViewportOffsetAdjust`, fn: Extract<Hook, {
+        name: `onViewportOffsetAdjust`;
+    }>[`fn`]): void;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,16 @@
+import { Manifest } from "@prose-reader/shared";
+export declare type ViewportPosition = {
+    x: number;
+    y: number;
+};
+export declare type LoadOptions = {
+    cfi?: string;
+    fetchResource?: ((item: Manifest[`spineItems`][number]) => Promise<Response>);
+    numberOfAdjacentSpineItemToPreLoad?: number;
+};
+declare global {
+    interface Window {
+        __PROSE_READER_DEBUG?: boolean;
+    }
+}
+export { Manifest };

package/dist/utils/compose.d.ts

@@ -0,0 +1,8 @@
+declare type Func<T extends any[], R> = (...a: T) => R;
+declare function compose<F extends Function>(f: F): F;
+declare function compose<A, T extends any[], R>(f1: (a: A) => R, f2: Func<T, A>): Func<T, R>;
+declare function compose<A, B, T extends any[], R>(f1: (b: B) => R, f2: (a: A) => B, f3: Func<T, A>): Func<T, R>;
+declare function compose<A, B, C, T extends any[], R>(f1: (c: C) => R, f2: (b: B) => C, f3: (a: A) => B, f4: Func<T, A>): Func<T, R>;
+declare function compose<R>(f1: (a: any) => R, ...funcs: Function[]): (...args: any[]) => R;
+declare function compose<R>(...funcs: Function[]): (...args: any[]) => R;
+export { compose };

package/dist/utils/contentType.d.ts

@@ -0,0 +1,2 @@
+export declare const detectContentType: (name: string) => "image/png" | "image/jpg" | "image/jpeg" | "text/plain" | "image/webp" | undefined;
+export declare const parseContentType: (str: string) => string | undefined;

package/dist/utils/dom.d.ts

@@ -0,0 +1,19 @@
+export declare const isHtmlElement: (element?: Node | EventTarget | Element | null | undefined) => element is HTMLElement;
+declare type ViewPort = {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
+export declare const getFirstVisibleNodeForViewport: ((documentOrElement: Document | Element, viewport: ViewPort) => {
+    node: Node;
+    offset: number;
+} | undefined) | ((documentOrElement: Element | Document, viewport: ViewPort) => {
+    node: Node;
+    offset: number;
+} | undefined);
+export declare const getRangeFromNode: (node: Node, offset: number) => Range | undefined;
+export declare const isPointerEvent: (event: Event) => event is PointerEvent;
+export declare const isMouseEvent: (event: Event) => event is MouseEvent;
+export declare const isTouchEvent: (event: Event) => event is TouchEvent;
+export {};

package/dist/utils/manifest.d.ts

@@ -0,0 +1,2 @@
+import { Manifest } from "@prose-reader/shared";
+export declare const getCoverItem: (manifest: Manifest) => number;

package/dist/utils/objects.d.ts

@@ -0,0 +1,6 @@
+export declare const is: (x: any, y: any) => boolean;
+export declare const isShallowEqual: <T = any, R = any>(objectA: T, objectB: R, options?: {
+    customEqual?: (<T_1>(a: T_1, b: T_1) => boolean) | undefined;
+} | undefined) => boolean;
+export declare const groupBy: <T, K extends string | number | symbol>(list: T[], getKey: (item: T) => K) => Record<K, T[]>;
+export declare const getBase64FromBlob: (data: Blob) => Promise<string>;

package/dist/utils/objects.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/rxjs.d.ts

@@ -0,0 +1,4 @@
+import { OperatorFunction } from "rxjs";
+export declare const mapKeysTo: <R extends {
+    [key: string]: any;
+}, K extends keyof R>(keys: K[]) => OperatorFunction<R, Pick<R, K>>;

package/dist/utils/url.d.ts

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

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@prose-reader/core",
+  "version": "0.0.36",
+  "main": "dist/index.js",
+  "license": "MIT",
+  "files": [
+    "/dist"
+  ],
+  "scripts": {
+    "start": "concurrently -n src,types \"yarn start-src\" \"yarn start-types\"",
+    "start-src": "NODE_ENV=development webpack build --config ./webpack.config.js --watch",
+    "start-types": "yarn tsc -w --declaration --noEmit false --emitDeclarationOnly",
+    "build": "NODE_ENV=production webpack build --config ./webpack.config.js",
+    "build:prod": "rm -rf dist && yarn build",
+    "lint": "eslint '**/*.{js,ts,tsx}'",
+    "test": "jest",
+    "e2e": "concurrently -n webpack,cypress \"NODE_ENV=development webpack serve --config ./cypress/webpack.config.js\" \"cypress open\"",
+    "tsc": "tsc"
+  },
+  "dependencies": {
+    "@prose-reader/shared": "^0.0.4"
+  },
+  "peerDependencies": {
+    "rxjs": "*"
+  },
+  "devDependencies": {
+    "terser-webpack-plugin": "^5.2.5",
+    "webpack-bundle-analyzer": "^4.5.0",
+    "@typescript-eslint/eslint-plugin": "^5.0.0",
+    "@typescript-eslint/parser": "^5.0.0",
+    "concurrently": "^6.3.0",
+    "cypress": "^9.0.0",
+    "eslint": "^7.32.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-import": "^2.25.2",
+    "eslint-plugin-jest": "^25.3.0",
+    "html-webpack-plugin": "^5.5.0",
+    "ts-loader": "^9.2.6",
+    "typescript": "*",
+    "webpack": "^5.64.3",
+    "webpack-cli": "^4.9.1"
+  },
+  "gitHead": "a005ccf2d302179a488d3f5e79c1f043d3ce29de"
+}