@prose-reader/core 1.57.0 → 1.59.0

package/dist/enhancers/pagination/spine.d.ts

@@ -0,0 +1,13 @@
+import { Observable } from 'rxjs';
+import { Reader } from '../../reader';
+import { SpineItem } from '../../spineItem/createSpineItem';
+
+export declare const getSpineItemNumberOfPages: ({ spineItem, reader }: {
+    spineItem: SpineItem;
+    reader: Reader;
+}) => number;
+export declare const getNumberOfPagesForAllSpineItems: (reader: Reader) => number[];
+export declare const trackTotalPages: (reader: Reader) => Observable<{
+    numberOfPagesPerItems: number[];
+    numberOfTotalPages: number;
+}>;

package/dist/enhancers/pagination/types.d.ts

@@ -0,0 +1,19 @@
+import { PaginationInfo } from '../../pagination/types';
+import { Reader } from '../../reader';
+import { progressionEnhancer } from '../progression';
+import { EnhancerOutput } from '../types/enhancer';
+import { ChapterInfo } from './chapters';
+
+export type ReaderWithProgression = Reader & EnhancerOutput<typeof progressionEnhancer>;
+export type ExtraPaginationInfo = {
+    beginChapterInfo: ChapterInfo | undefined;
+    beginSpineItemReadingDirection: `rtl` | `ltr` | undefined;
+    beginAbsolutePageIndex: number | undefined;
+    endChapterInfo: ChapterInfo | undefined;
+    endSpineItemReadingDirection: `rtl` | `ltr` | undefined;
+    endAbsolutePageIndex: number | undefined;
+    percentageEstimateOfBook: number | undefined;
+    numberOfTotalPages: number | undefined;
+    isUsingSpread: boolean;
+};
+export type EnhancerPaginationInto = PaginationInfo & ExtraPaginationInfo;

package/dist/enhancers/pagination.test.d.ts

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

package/dist/enhancers/progression.d.ts

@@ -0,0 +1,16 @@
+import { Context } from '../context/Context';
+import { SpineItem } from '../spineItem/createSpineItem';
+import { Reader } from '../reader';
+
+export declare const progressionEnhancer: <InheritOptions, InheritOutput extends Reader>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput & {
+    progression: {
+        getPercentageEstimate: (context: Context, currentSpineIndex: number, numberOfPages: number, pageIndex: number, currentPosition: {
+            x: number;
+            y: number;
+        }, currentItem: SpineItem) => number;
+        getScrollPercentageWithinItem: (context: Context, currentPosition: {
+            x: number;
+            y: number;
+        }, currentItem: SpineItem) => number;
+    };
+};

package/dist/enhancers/publicApi.d.ts

@@ -0,0 +1,5 @@
+import { Reader } from '../reader';
+
+export declare const publicApiEnhancer: <InheritOptions, InheritOutput extends Reader>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => Omit<InheritOutput, "pagination"> & {
+    pagination: Pick<InheritOutput["pagination"], "paginationInfo$" | "getPaginationInfo">;
+};

package/dist/enhancers/resources/index.d.ts

@@ -0,0 +1,3 @@
+import { EnhancerOutput, RootEnhancer } from '../types/enhancer';
+
+export declare const resourcesEnhancer: <InheritOptions, InheritOutput extends EnhancerOutput<RootEnhancer>>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput;

package/dist/enhancers/resources/indexedDB.d.ts

@@ -0,0 +1,6 @@
+export declare const openDatabase: (name: string) => Promise<{
+    put: (key: string, data: Blob) => Promise<void>;
+    keys: () => Promise<IDBValidKey[]>;
+    get: (key: string) => Promise<Blob | null>;
+    remove: (key: globalThis.IDBValidKey) => Promise<void>;
+}>;

package/dist/enhancers/resources/resourcesManager.d.ts

@@ -0,0 +1,7 @@
+import { Context } from '../../context/Context';
+import { Manifest } from '../../types';
+
+export declare const createResourcesManager: (context: Context) => {
+    get: (itemIndexOrId: number | Pick<Manifest[`spineItems`][number], `id`>, fetchResource?: (item: Manifest[`spineItems`][number]) => Promise<Response>) => Promise<Response>;
+    destroy: () => void;
+};

package/dist/enhancers/theme.d.ts

@@ -0,0 +1,32 @@
+import { Observable } from 'rxjs';
+import { EnhancerOutput, RootEnhancer } from './types/enhancer';
+
+declare const defaultThemes: ({
+    name: "bright";
+    backgroundColor: string;
+    foregroundColor?: undefined;
+} | {
+    name: "sepia";
+    backgroundColor: string;
+    foregroundColor: string;
+} | {
+    name: "night";
+    backgroundColor: string;
+    foregroundColor: string;
+})[];
+export type Theme = (typeof defaultThemes)[number][`name`] | `publisher`;
+export interface ThemeEnhancer {
+    <InheritOptions, InheritOutput extends EnhancerOutput<RootEnhancer>>(next: (options: InheritOptions) => InheritOutput): (options: InheritOptions & {
+        theme?: Theme;
+    }) => InheritOutput & {
+        theme: {
+            set: (theme: Theme) => void;
+            get: () => Theme;
+            $: {
+                theme$: Observable<Theme>;
+            };
+        };
+    };
+}
+export declare const themeEnhancer: ThemeEnhancer;
+export {};

package/dist/enhancers/types/enhancer.d.ts

@@ -0,0 +1,9 @@
+import { CreateReaderParameters } from '../../reader';
+import { ReaderInternal } from '../../types/reader';
+
+export type EnhancerOutput<Enhancer extends (options: any) => any> = ReturnType<ReturnType<Enhancer>>;
+export type EnhancerOptions<Enhancer extends (options: any) => any> = Parameters<ReturnType<Enhancer>>[0];
+export interface RootEnhancer<Options extends CreateReaderParameters = CreateReaderParameters, Reader extends ReaderInternal = ReaderInternal> {
+    (next: (options: Options) => Reader): (options: Options) => Reader;
+}
+export declare const rootEnhancer: <Options extends CreateReaderParameters, Reader extends ReaderInternal>(next: (options: Options) => Reader) => (options: Options) => Reader;

package/dist/enhancers/utils.d.ts

@@ -0,0 +1,7 @@
+import { EnhancerOutput, RootEnhancer } from './types/enhancer';
+
+export declare const utilsEnhancer: <InheritOptions, InheritOutput extends EnhancerOutput<RootEnhancer>>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput & {
+    utils: {
+        isOrIsWithinValidLink: (target: Event[`target`]) => boolean;
+    };
+};

package/dist/enhancers/webkit.d.ts

@@ -0,0 +1,3 @@
+import { EnhancerOptions, EnhancerOutput, RootEnhancer } from './types/enhancer';
+
+export declare const webkitEnhancer: <InheritOptions extends EnhancerOptions<RootEnhancer>, InheritOutput extends EnhancerOutput<RootEnhancer>>(createReader: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput;

package/dist/enhancers/zoom/elementZoomer.d.ts

@@ -0,0 +1,19 @@
+import { Reader } from '../../reader';
+
+export declare const createElementZoomer: (reader: Reader) => {
+    enter: (imgElement: HTMLImageElement) => void;
+    exit: () => void;
+    move: (delta: {
+        x: number;
+        y: number;
+    } | undefined, { isFirst, isLast }: {
+        isFirst: boolean;
+        isLast: boolean;
+    }) => void;
+    scale: (userScale: number) => void;
+    setCurrentScaleAsBase: () => void;
+    getScaleValue: () => number;
+    isZooming: () => boolean;
+    destroy: () => void;
+    isZooming$: import('rxjs').Observable<boolean>;
+};

package/dist/enhancers/zoom/index.d.ts

@@ -0,0 +1,4 @@
+import { Reader } from '../../reader';
+import { Api } from './types';
+
+export declare const zoomEnhancer: <InheritOptions, InheritOutput extends Reader>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput & Api;

package/dist/enhancers/zoom/types.d.ts

@@ -0,0 +1,23 @@
+import { Observable } from 'rxjs';
+
+export type Api = {
+    zoom: {
+        enter: (imgElement?: HTMLImageElement) => void;
+        exit: () => void;
+        move: (position: {
+            x: number;
+            y: number;
+        } | undefined, details: {
+            isFirst: boolean;
+            isLast: boolean;
+        }) => void;
+        isZooming: () => boolean;
+        isUsingScrollableZoom: () => boolean;
+        getScaleValue: () => number;
+        scale: (scale: number) => void;
+        setCurrentScaleAsBase: () => void;
+        $: {
+            isZooming$: Observable<boolean>;
+        };
+    };
+};

package/dist/enhancers/zoom/viewportZoomer.d.ts

@@ -0,0 +1,19 @@
+import { Reader } from '../../reader';
+
+export declare const createViewportZoomer: (reader: Reader) => {
+    enter: () => void;
+    exit: () => void;
+    move: (_: {
+        x: number;
+        y: number;
+    } | undefined, __: {
+        isFirst: boolean;
+        isLast: boolean;
+    }) => void;
+    scale: (userScale: number) => void;
+    setCurrentScaleAsBase: () => void;
+    getScaleValue: () => number;
+    isZooming: () => boolean;
+    destroy: () => void;
+    isZooming$: import('rxjs').Observable<boolean>;
+};

package/dist/frames.d.ts

@@ -0,0 +1,5 @@
+export declare const createRemoveStyleHelper: (frameElement: HTMLIFrameElement | undefined) => (id: string) => void;
+export declare const createAddStyleHelper: (frameElement: HTMLIFrameElement | undefined) => (id: string, style: string, prepend?: boolean) => void;
+export declare const getAttributeValueFromString: (string: string, key: string) => number;
+export declare const getOriginalFrameEventFromDocumentEvent: <E extends Event>(event: E) => E | undefined;
+export declare const attachOriginalFrameEventToDocumentEvent: <E extends Event>(event: E, frameEvent: E) => void;

package/dist/hooks/HookManager.d.ts

@@ -0,0 +1,10 @@
+import { CoreHook, Hook, HookExecution, HookFrom } from './types';
+
+export declare class HookManager<H extends Hook<any, any, any> = CoreHook> {
+    _hooks: Array<H>;
+    _hookExecutions: Array<HookExecution<H>>;
+    protected deregister(hookToDeregister: H): import('rxjs').Observable<unknown[]>;
+    register<Name extends H["name"]>(name: Name, fn: HookFrom<H, Name>["runFn"]): () => void;
+    execute<Name extends H["name"]>(name: Name, id: string | undefined, params: Omit<Parameters<HookFrom<H, Name>["runFn"]>[0], "destroy" | "destroy$">): ReturnType<HookFrom<H, Name>["runFn"]>[];
+    destroy<Name extends H["name"]>(name: Name, id?: string, ref?: H): import('rxjs').Observable<unknown[]>;
+}

package/dist/hooks/types.d.ts

@@ -0,0 +1,64 @@
+import { Manifest } from '@prose-reader/shared';
+import { Observable } from 'rxjs';
+
+export type UserDestroyFn = () => void | Observable<unknown>;
+export interface Hook<Name, Params, Result> {
+    name: Name;
+    runFn: (params: Params) => Result;
+}
+export type CoreHook = {
+    name: `item.onLoad`;
+    runFn: (params: {
+        destroy$: Observable<void>;
+        destroy: (fn: UserDestroyFn) => void;
+        itemId: string;
+        frame: HTMLIFrameElement;
+    }) => Observable<void> | void;
+} | {
+    name: "item.onAfterLayout";
+    runFn: (params: {
+        blankPagePosition: "before" | "after" | "none";
+        item: Manifest["spineItems"][number];
+        minimumWidth: number;
+    }) => void;
+} | {
+    name: "item.onBeforeContainerCreated";
+    runFn: (params: {
+        element: HTMLElement;
+    }) => void;
+} | {
+    name: "item.onLayoutBeforeMeasurement";
+    runFn: (params: {
+        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: "onViewportOffsetAdjust";
+    runFn: (params: void) => void;
+} | {
+    name: `viewportNavigator.onBeforeContainerCreated`;
+    runFn: (params: {
+        element: HTMLElement;
+    }) => void;
+};
+export type HookExecution<H extends Hook<any, any, any>> = {
+    name: string;
+    id: string | undefined;
+    destroyFn: () => Observable<unknown>;
+    ref: H;
+};
+export type HookFrom<H extends Hook<any, any, any>, Name extends H["name"]> = H extends infer HK ? HK extends H ? HK["name"] extends Name ? HK : never : never : never;