@prose-reader/core 1.56.0 → 1.58.0

package/dist/spineItemManager.d.ts

@@ -0,0 +1,505 @@
+import { Context } from './context/Context';
+import { SpineItem } from './spineItem/createSpineItem';
+import { SettingsManager } from './settings/SettingsManager';
+
+export declare const createSpineItemManager: ({ context, settings }: {
+    context: Context;
+    settings: SettingsManager;
+}) => {
+    destroyItems: () => void;
+    add: (spineItem: SpineItem) => void;
+    get: (indexOrId: number | string) => {
+        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('./spineItem/frameItem/createFrameManipulator').createFrameManipulator> | 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;
+        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: import('@prose-reader/shared').Manifest[`spineItems`][number];
+            overlayElement: HTMLDivElement;
+        } & (ReturnType<typeof import('./spineItem/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;
+            $: 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;
+            }>;
+        };
+        getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
+            columnHeight: number;
+            columnWidth: number;
+            width: number;
+        };
+        getDimensionsForPaginatedContent: () => {
+            columnHeight: number;
+            columnWidth: number;
+        };
+        $: {
+            contentLayout$: import('rxjs').Observable<{
+                isFirstLayout: boolean;
+                isReady: boolean;
+            }>;
+            loaded$: import('rxjs').Observable<HTMLIFrameElement>;
+            isReady$: import('rxjs').Observable<boolean>;
+        };
+    } | undefined;
+    getAll: () => {
+        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('./spineItem/frameItem/createFrameManipulator').createFrameManipulator> | 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;
+        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: import('@prose-reader/shared').Manifest[`spineItems`][number];
+            overlayElement: HTMLDivElement;
+        } & (ReturnType<typeof import('./spineItem/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;
+            $: 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;
+            }>;
+        };
+        getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
+            columnHeight: number;
+            columnWidth: number;
+            width: number;
+        };
+        getDimensionsForPaginatedContent: () => {
+            columnHeight: number;
+            columnWidth: number;
+        };
+        $: {
+            contentLayout$: import('rxjs').Observable<{
+                isFirstLayout: boolean;
+                isReady: boolean;
+            }>;
+            loaded$: import('rxjs').Observable<HTMLIFrameElement>;
+            isReady$: import('rxjs').Observable<boolean>;
+        };
+    }[];
+    getLength: () => number;
+    layout: () => void;
+    focus: (indexOrSpineItem: number | SpineItem) => void;
+    loadContents: ((rangeOfIndex: [number, number]) => void) | ((rangeOfIndex: [number, number]) => ReturnType<(rangeOfIndex: [number, number]) => void>);
+    comparePositionOf: (toCompare: SpineItem, withItem: SpineItem) => "after" | "before";
+    getAbsolutePositionOf: (spineItemOrIndex: SpineItem | number) => {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        width: number;
+        height: number;
+    };
+    getFocusedSpineItem: () => {
+        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('./spineItem/frameItem/createFrameManipulator').createFrameManipulator> | 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;
+        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: import('@prose-reader/shared').Manifest[`spineItems`][number];
+            overlayElement: HTMLDivElement;
+        } & (ReturnType<typeof import('./spineItem/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;
+            $: 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;
+            }>;
+        };
+        getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
+            columnHeight: number;
+            columnWidth: number;
+            width: number;
+        };
+        getDimensionsForPaginatedContent: () => {
+            columnHeight: number;
+            columnWidth: number;
+        };
+        $: {
+            contentLayout$: import('rxjs').Observable<{
+                isFirstLayout: boolean;
+                isReady: boolean;
+            }>;
+            loaded$: import('rxjs').Observable<HTMLIFrameElement>;
+            isReady$: import('rxjs').Observable<boolean>;
+        };
+    } | undefined;
+    getFocusedSpineItemIndex: () => number | undefined;
+    getSpineItemIndex: (spineItem: SpineItem | undefined) => number | undefined;
+    destroy: () => void;
+    $: {
+        focus$: import('rxjs').Observable<{
+            data: SpineItem;
+        }>;
+        layout$: import('rxjs').Observable<boolean>;
+        itemIsReady$: import('rxjs').Observable<{
+            item: {
+                id: string;
+                href: string;
+                renditionLayout: `reflowable` | `pre-paginated`;
+                progressionWeight: number;
+                pageSpreadLeft: true | undefined;
+                pageSpreadRight: true | undefined;
+                mediaType?: string;
+            };
+            isReady: boolean;
+        }>;
+    };
+};
+export type SpineItemManager = ReturnType<typeof createSpineItemManager>;

package/dist/types/Spine.d.ts

@@ -0,0 +1,40 @@
+import { Observable } from 'rxjs';
+import { SpineItem } from '../spineItem/createSpineItem';
+import { createSelection } from '../selection';
+import { createCfiLocator } from '../spine/cfiLocator';
+import { createLocationResolver } from '../spine/locationResolver';
+import { createLocationResolver as createSpineItemLocator } from '../spineItem/locationResolver';
+import { ViewportNavigationEntry } from '../spine/navigationResolver';
+
+type RequireLayout = boolean;
+type ManipulableSpineItemCallback = Parameters<SpineItem[`manipulateSpineItem`]>[0];
+type ManipulableSpineItemCallbackPayload = Parameters<ManipulableSpineItemCallback>[0];
+type CfiLocator = ReturnType<typeof createCfiLocator>;
+type SpineItemLocator = ReturnType<typeof createSpineItemLocator>;
+type Locator = ReturnType<typeof createLocationResolver>;
+type Event = {
+    type: `onSelectionChange`;
+    data: ReturnType<typeof createSelection> | null;
+};
+export type Spine = {
+    element$: Observable<HTMLElement>;
+    getElement: () => HTMLElement | undefined;
+    locator: Locator;
+    spineItemLocator: SpineItemLocator;
+    cfiLocator: CfiLocator;
+    manipulateSpineItems: (cb: (payload: ManipulableSpineItemCallbackPayload & {
+        index: number;
+    }) => RequireLayout) => void;
+    manipulateSpineItem: (id: string, cb: Parameters<SpineItem[`manipulateSpineItem`]>[0]) => void;
+    destroy: () => void;
+    isSelecting: () => boolean | undefined;
+    getSelection: () => Selection | undefined;
+    adjustPagination: (position: ViewportNavigationEntry) => Observable<`free` | `busy`>;
+    $: {
+        $: Observable<Event>;
+        layout$: Observable<boolean>;
+        spineItems$: Observable<SpineItem[]>;
+        itemsBeforeDestroy$: Observable<void>;
+    };
+};
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+import { Manifest } from '@prose-reader/shared';
+
+export type ViewportPosition = {
+    x: number;
+    y: number;
+};
+declare global {
+    interface Window {
+        __PROSE_READER_DEBUG?: boolean;
+    }
+}
+export { Manifest };

package/dist/types/reader.d.ts

@@ -0,0 +1,44 @@
+import { Observable } from 'rxjs';
+import { Spine } from './Spine';
+import { Pagination } from '../pagination/pagination';
+import { Manifest } from '@prose-reader/shared';
+import { SpineItemManager } from '../spineItemManager';
+import { ViewportNavigator } from '../viewportNavigator/viewportNavigator';
+import { SettingsManager } from '../settings/SettingsManager';
+import { Settings } from '../settings/types';
+import { Context } from '../context/Context';
+import { HookManager } from '../hooks/HookManager';
+
+export type ContextSettings = Partial<Settings>;
+export type LoadOptions = {
+    cfi?: string | null;
+    containerElement: HTMLElement;
+};
+export type ReaderInternal = {
+    context: Context;
+    spine: Spine;
+    spineItemManager: SpineItemManager;
+    viewportNavigator: ViewportNavigator;
+    settings: SettingsManager;
+    hookManager: HookManager;
+    layout: () => void;
+    load: (manifest: Manifest, loadOptions: LoadOptions) => void;
+    destroy: () => void;
+    pagination: Pagination;
+    element$: Observable<HTMLElement>;
+    $: {
+        state$: Observable<{
+            supportedPageTurnAnimation: NonNullable<ContextSettings[`pageTurnAnimation`]>[];
+            supportedPageTurnMode: NonNullable<ContextSettings[`pageTurnMode`]>[];
+            supportedPageTurnDirection: NonNullable<ContextSettings[`pageTurnDirection`]>[];
+            supportedComputedPageTurnDirection: NonNullable<ContextSettings[`pageTurnDirection`]>[];
+        }>;
+        loadStatus$: Observable<"idle" | "loading" | "ready">;
+        selection$: Observable<{
+            toString: () => string;
+            getAnchorCfi: () => string | undefined;
+            getFocusCfi: () => string | undefined;
+        } | null>;
+        destroy$: Observable<void>;
+    };
+};

package/dist/utils/compose.d.ts

@@ -0,0 +1,8 @@
+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/dom.d.ts

@@ -0,0 +1,19 @@
+export declare const isHtmlElement: (element?: Element | Node | null | EventTarget) => element is HTMLElement;
+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: Document | Element, viewport: ViewPort) => ReturnType<(documentOrElement: Document | Element, 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/isDefined.d.ts

@@ -0,0 +1 @@
+export declare function isDefined<T>(arg: T | null | undefined): arg is T extends null | undefined ? never : T;

package/dist/utils/layout.d.ts

@@ -0,0 +1,7 @@
+export declare const getNewScaledOffset: ({ newScale, oldScale, screenSize, scrollOffset, }: {
+    screenSize: number;
+    pageSize: number;
+    scrollOffset: number;
+    newScale: number;
+    oldScale: number;
+}) => number;

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

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

package/dist/utils/manifest.d.ts

@@ -0,0 +1,3 @@
+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;
+}) => boolean;
+export declare const groupBy: <T, K extends keyof any>(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,5 @@
+import { OperatorFunction } from 'rxjs';
+
+export declare const mapKeysTo: <R extends {
+    [key: string]: any;
+}, K extends keyof R>(keys: K[]) => OperatorFunction<R, Pick<R, K>>;