@prose-reader/core 0.0.36

package/dist/enhancers/accessibility.d.ts

@@ -0,0 +1,2 @@
+import { Enhancer } from "./types";
+export declare const accessibilityEnhancer: Enhancer<{}, {}>;

package/dist/enhancers/chrome.d.ts

@@ -0,0 +1,2 @@
+import { Enhancer } from "./types";
+export declare const chromeEnhancer: Enhancer<{}, {}>;

package/dist/enhancers/composeEnhancer.d.ts

@@ -0,0 +1,21 @@
+import { Enhancer, ExtractApi, ExtractHiddenApi, ExtractOptions } from "./types";
+export declare type ComposableEnhancer = (createReader: any) => (options: any) => {
+    setSettings?: any;
+    __OutputSettings?: any;
+};
+export declare type ComposeEnhancer<A extends ComposableEnhancer = Enhancer, B extends ComposableEnhancer = Enhancer, C extends ComposableEnhancer = Enhancer, D extends ComposableEnhancer = Enhancer, E extends ComposableEnhancer = Enhancer, F extends ComposableEnhancer = Enhancer, G extends ComposableEnhancer = Enhancer, H extends ComposableEnhancer = Enhancer, I extends ComposableEnhancer = Enhancer, J extends ComposableEnhancer = Enhancer, K extends ComposableEnhancer = Enhancer, L extends ComposableEnhancer = Enhancer, M extends ComposableEnhancer = Enhancer, N extends ComposableEnhancer = Enhancer, O extends ComposableEnhancer = 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], ExtractApi<A>[`__OutputSettings`] & ExtractApi<B>[`__OutputSettings`] & ExtractApi<C>[`__OutputSettings`] & ExtractApi<D>[`__OutputSettings`] & ExtractApi<E>[`__OutputSettings`] & ExtractApi<F>[`__OutputSettings`] & ExtractApi<G>[`__OutputSettings`] & ExtractApi<H>[`__OutputSettings`] & ExtractApi<I>[`__OutputSettings`] & ExtractApi<J>[`__OutputSettings`] & ExtractApi<K>[`__OutputSettings`] & ExtractApi<L>[`__OutputSettings`] & ExtractApi<M>[`__OutputSettings`] & ExtractApi<N>[`__OutputSettings`] & ExtractApi<O>[`__OutputSettings`]>;
+export declare function composeEnhancer<A extends ComposableEnhancer>(a: A): ComposeEnhancer<A>;
+export declare function composeEnhancer<A extends ComposableEnhancer, B extends ComposableEnhancer>(a: A, b: B): ComposeEnhancer<A, B>;
+export declare function composeEnhancer<A extends ComposableEnhancer, B extends ComposableEnhancer, C extends ComposableEnhancer>(a: A, b: B, c: C): ComposeEnhancer<A, B, C>;
+export declare function composeEnhancer<A extends ComposableEnhancer, B extends ComposableEnhancer, C extends ComposableEnhancer, D extends ComposableEnhancer>(a: A, b: B, c: C, d: D): ComposeEnhancer<A, B, C, D>;
+export declare function composeEnhancer<A extends ComposableEnhancer, B extends ComposableEnhancer, C extends ComposableEnhancer, D extends ComposableEnhancer, E extends ComposableEnhancer>(a: A, b: B, c: C, d: D, e: E): ComposeEnhancer<A, B, C, D, E>;
+export declare function composeEnhancer<A extends ComposableEnhancer, B extends ComposableEnhancer, C extends ComposableEnhancer, D extends ComposableEnhancer, E extends ComposableEnhancer, F extends ComposableEnhancer>(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 ComposableEnhancer, B extends ComposableEnhancer, C extends ComposableEnhancer, D extends ComposableEnhancer, E extends ComposableEnhancer, F extends ComposableEnhancer, G extends ComposableEnhancer>(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 ComposableEnhancer, B extends ComposableEnhancer, C extends ComposableEnhancer, D extends ComposableEnhancer, E extends ComposableEnhancer, F extends ComposableEnhancer, G extends ComposableEnhancer, H extends ComposableEnhancer>(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 ComposableEnhancer, B extends ComposableEnhancer, C extends ComposableEnhancer, D extends ComposableEnhancer, E extends ComposableEnhancer, F extends ComposableEnhancer, G extends ComposableEnhancer, H extends ComposableEnhancer, I extends ComposableEnhancer>(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 ComposableEnhancer, B extends ComposableEnhancer, C extends ComposableEnhancer, D extends ComposableEnhancer, E extends ComposableEnhancer, F extends ComposableEnhancer, G extends ComposableEnhancer, H extends ComposableEnhancer, I extends ComposableEnhancer, J extends ComposableEnhancer>(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 ComposableEnhancer, B extends ComposableEnhancer, C extends ComposableEnhancer, D extends ComposableEnhancer, E extends ComposableEnhancer, F extends ComposableEnhancer, G extends ComposableEnhancer, H extends ComposableEnhancer, I extends ComposableEnhancer, J extends ComposableEnhancer, K extends ComposableEnhancer>(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 ComposableEnhancer, B extends ComposableEnhancer, C extends ComposableEnhancer, D extends ComposableEnhancer, E extends ComposableEnhancer, F extends ComposableEnhancer, G extends ComposableEnhancer, H extends ComposableEnhancer, I extends ComposableEnhancer, J extends ComposableEnhancer, K extends ComposableEnhancer, L extends ComposableEnhancer>(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 ComposableEnhancer, B extends ComposableEnhancer, C extends ComposableEnhancer, D extends ComposableEnhancer, E extends ComposableEnhancer, F extends ComposableEnhancer, G extends ComposableEnhancer, H extends ComposableEnhancer, I extends ComposableEnhancer, J extends ComposableEnhancer, K extends ComposableEnhancer, L extends ComposableEnhancer, M extends ComposableEnhancer>(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 ComposableEnhancer, B extends ComposableEnhancer, C extends ComposableEnhancer, D extends ComposableEnhancer, E extends ComposableEnhancer, F extends ComposableEnhancer, G extends ComposableEnhancer, H extends ComposableEnhancer, I extends ComposableEnhancer, J extends ComposableEnhancer, K extends ComposableEnhancer, L extends ComposableEnhancer, M extends ComposableEnhancer, N extends ComposableEnhancer>(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 ComposableEnhancer, B extends ComposableEnhancer, C extends ComposableEnhancer, D extends ComposableEnhancer, E extends ComposableEnhancer, F extends ComposableEnhancer, G extends ComposableEnhancer, H extends ComposableEnhancer, I extends ComposableEnhancer, J extends ComposableEnhancer, K extends ComposableEnhancer, L extends ComposableEnhancer, M extends ComposableEnhancer, N extends ComposableEnhancer, O extends ComposableEnhancer>(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>;

package/dist/enhancers/firefox.d.ts

@@ -0,0 +1,2 @@
+import { Enhancer } from "./types";
+export declare const firefoxEnhancer: Enhancer<{}, {}>;

package/dist/enhancers/fonts.d.ts

@@ -0,0 +1,12 @@
+import { Enhancer } from "./types";
+declare const FONT_WEIGHT: readonly [100, 200, 300, 400, 500, 600, 700, 800, 900];
+declare const FONT_JUSTIFICATION: readonly ["center", "left", "right", "justify"];
+declare type Options = {
+    fontScale?: number;
+    lineHeight?: number | `publisher`;
+    fontWeight?: typeof FONT_WEIGHT[number] | `publisher`;
+    fontJustification?: typeof FONT_JUSTIFICATION[number] | `publisher`;
+};
+declare type OutputOptions = Required<Options>;
+export declare const fontsEnhancer: Enhancer<Options, {}, Options, OutputOptions>;
+export {};

package/dist/enhancers/hotkeys.d.ts

@@ -0,0 +1,2 @@
+import { Enhancer } from "./types";
+export declare const hotkeysEnhancer: Enhancer<{}, {}>;

package/dist/enhancers/layoutEnhancer/createMovingSafePan$.d.ts

@@ -0,0 +1,3 @@
+import { Observable } from "rxjs";
+import { Reader } from "../../reader";
+export declare const createMovingSafePan$: (reader: Reader) => Observable<"free" | "busy" | undefined>;

package/dist/enhancers/layoutEnhancer/layoutEnhancer.d.ts

@@ -0,0 +1,10 @@
+import { Enhancer } from "../types";
+declare type SettingsInput = {
+    pageHorizontalMargin?: number;
+    pageVerticalMargin?: number;
+};
+declare type SettingsOutput = Required<SettingsInput>;
+export declare const layoutEnhancer: Enhancer<SettingsInput & {
+    layoutAutoResize?: `container` | false;
+}, {}, SettingsInput, SettingsOutput>;
+export {};

package/dist/enhancers/links.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from "rxjs";
+import { Enhancer } from "./types";
+declare type SubjectData = {
+    event: `linkClicked`;
+    data: HTMLAnchorElement;
+};
+export declare const linksEnhancer: Enhancer<{}, {
+    $: {
+        links$: Observable<SubjectData>;
+    };
+}>;
+export {};

package/dist/enhancers/media.d.ts

@@ -0,0 +1,2 @@
+import { Enhancer } from "./types";
+export declare const mediaEnhancer: Enhancer<{}, {}>;

package/dist/enhancers/navigation.d.ts

@@ -0,0 +1,5 @@
+import { Enhancer } from "./types";
+export declare const navigationEnhancer: Enhancer<{}, {
+    goToLeftSpineItem: () => void;
+    goToRightSpineItem: () => void;
+}>;

package/dist/enhancers/pagination.d.ts

@@ -0,0 +1,46 @@
+import { Observable } from "rxjs";
+import { Enhancer } from "./types";
+import { Manifest } from "../types";
+import { progressionEnhancer } from "./progression";
+declare type ChapterInfo = {
+    title: string;
+    subChapter?: {
+        title: string;
+        subChapter?: {
+            title: string;
+            subChapter?: {
+                title: string;
+                path: string;
+            };
+            path: string;
+        };
+        path: string;
+    };
+    path: string;
+};
+declare type PaginationInfo = {
+    beginChapterInfo: ChapterInfo | undefined;
+    beginPageIndexInChapter: number | undefined;
+    beginNumberOfPagesInChapter: number | undefined;
+    beginSpineItemIndex: number | undefined;
+    beginCfi: string | undefined;
+    beginSpineItemReadingDirection: `rtl` | `ltr` | undefined;
+    beginAbsolutePageIndex: number | undefined;
+    endChapterInfo: ChapterInfo | undefined;
+    endPageIndexInChapter: number | undefined;
+    endNumberOfPagesInChapter: number | undefined;
+    endSpineItemIndex: number | undefined;
+    endCfi: string | undefined;
+    endSpineItemReadingDirection: `rtl` | `ltr` | undefined;
+    endAbsolutePageIndex: number | undefined;
+    percentageEstimateOfBook: number | undefined;
+    numberOfTotalPages: number | undefined;
+    isUsingSpread: boolean;
+};
+export declare const paginationEnhancer: Enhancer<{}, {
+    $: {
+        pagination$: Observable<PaginationInfo>;
+    };
+}, {}, {}, typeof progressionEnhancer>;
+export declare const buildChapterInfoFromSpineItem: (manifest: Manifest, item: Manifest[`spineItems`][number]) => ChapterInfo | undefined;
+export {};

package/dist/enhancers/progression.d.ts

@@ -0,0 +1,15 @@
+import { Context } from "../context";
+import { Enhancer } from "./types";
+import { SpineItem } from "../spineItem/createSpineItem";
+export declare const progressionEnhancer: Enhancer<{}, {
+    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/resources/index.d.ts

@@ -0,0 +1,2 @@
+import { Enhancer } from "../types";
+export declare const resourcesEnhancer: Enhancer<{}, {}>;

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,6 @@
+import { Context } from "../../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>) | undefined) => Promise<Response>;
+    destroy: () => void;
+};

package/dist/enhancers/theme.d.ts

@@ -0,0 +1,22 @@
+import { Enhancer } from "./types";
+declare const defaultThemes: ({
+    name: "bright";
+    backgroundColor: string;
+    foregroundColor?: undefined;
+} | {
+    name: "sepia";
+    backgroundColor: string;
+    foregroundColor: string;
+} | {
+    name: "night";
+    backgroundColor: string;
+    foregroundColor: string;
+})[];
+export declare type Theme = (typeof defaultThemes[number])[`name`];
+export declare const themeEnhancer: Enhancer<{
+    theme?: Theme;
+}, {
+    setTheme: (theme: Theme | undefined) => void;
+    getTheme: () => Theme | undefined;
+}>;
+export {};

package/dist/enhancers/types.d.ts

@@ -0,0 +1,28 @@
+import { Observable, ObservedValueOf } from "rxjs";
+import { Reader, createReader } from "../reader";
+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);
+export 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 ReaderOptions = Parameters<typeof createReader>[0];
+declare type CreateReader<Options = ReaderOptions, Api = Reader> = (options: Options) => Api;
+declare type RawEnhancer<Options = ReaderOptions, Api = Reader> = (createReader: CreateReader<Options, Api>) => (options: Options) => Api;
+declare type ASd<A> = A extends AnyObject ? A : {};
+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> = ASd<NonNullable<ReturnType<ReturnType<E>>[`__API`]>>;
+export declare type Enhancer<Options = {}, Api = {}, Settings = {}, OutputSettings = Settings, DependsOn extends (createReader: any) => (options: any) => any = RawEnhancer, Foo extends ExtractApi<DependsOn> = ExtractApi<DependsOn>> = (createReader: (options: ExtractOptions<DependsOn>) => Omit<ReturnType<ReturnType<DependsOn>>, `__API` | `__OutputSettings`>) => (options: ExtractOptions<DependsOn> & Options) => ModifyDeep<Omit<Foo, `__API` | `__OutputSettings` | `$`> & {
+    $: Omit<Foo[`$`], `settings$`> & {
+        settings$: Observable<OutputSettings & ObservedValueOf<Foo[`$`][`settings$`]>>;
+    };
+}, {
+    setSettings: (settings: Parameters<Foo[`setSettings`]>[0] & Settings) => void;
+} & Api> & {
+    __API?: Api;
+    __OutputSettings?: OutputSettings;
+};
+export {};

package/dist/enhancers/utils.d.ts

@@ -0,0 +1,6 @@
+import { Enhancer } from "./types";
+export declare const utilsEnhancer: Enhancer<{}, {
+    utils: {
+        isOrIsWithinValidLink: (target: Event[`target`]) => boolean;
+    };
+}>;

package/dist/enhancers/webkit.d.ts

@@ -0,0 +1,2 @@
+import { Enhancer } from "./types";
+export declare const webkitEnhancer: Enhancer<{}, {}>;

package/dist/enhancers/zoom.d.ts

@@ -0,0 +1,16 @@
+import { Enhancer } from "./types";
+export declare const zoomEnhancer: Enhancer<{}, {
+    zoom: {
+        enter: (imgElement: HTMLImageElement) => void;
+        exit: () => void;
+        move: (position: {
+            x: number;
+            y: number;
+        } | undefined, details: {
+            isFirst: boolean;
+            isLast: boolean;
+        }) => void;
+        isEnabled: () => boolean;
+        scale: (scale: number) => void;
+    };
+}>;

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/index.d.ts

@@ -0,0 +1,10 @@
+import { createReaderWithEnhancer as createReader, Reader, ExternalEnhancer as Enhancer } from './createReaderWithEnhancer';
+import { createSelection } from './selection';
+export { compose } from './utils/compose';
+export { ComposeEnhancer } from './enhancers/composeEnhancer';
+export { Manifest } from './types';
+export { createReader, Reader, Enhancer };
+export declare type ReaderSelection = ReturnType<typeof createSelection>;
+export { Report } from './report';
+export { composeEnhancer } from './enhancers/composeEnhancer';
+export { groupBy, isShallowEqual } from './utils/objects';