@prose-reader/core 1.28.0 → 1.30.0

package/dist/spineItem/createSpineItem.d.ts

@@ -1,216 +1,181 @@
-import { BehaviorSubject, Observable } from "rxjs"
-import { Context } from "../context"
-import { Manifest } from "../types"
-import { Hook } from "../types/Hook"
-export declare const createSpineItem: ({
-  item,
-  context,
-  containerElement,
-  iframeEventBridgeElement,
-  hooks$,
-  viewportState$,
-}: {
-  item: Manifest[`spineItems`][number]
-  containerElement: HTMLElement
-  iframeEventBridgeElement: HTMLElement
-  context: Context
-  hooks$: BehaviorSubject<Hook[]>
-  viewportState$: Observable<`free` | `busy`>
+import { BehaviorSubject, Observable } from "rxjs";
+import { Context } from "../context";
+import { Manifest } from "../types";
+import { Hook } from "../types/Hook";
+export declare const createSpineItem: ({ item, context, containerElement, iframeEventBridgeElement, hooks$, viewportState$, }: {
+    item: Manifest[`spineItems`][number];
+    containerElement: HTMLElement;
+    iframeEventBridgeElement: HTMLElement;
+    context: Context;
+    hooks$: BehaviorSubject<Hook[]>;
+    viewportState$: Observable<`free` | `busy`>;
 }) => {
-  layout: ({
-    blankPagePosition,
-    minimumWidth,
-    spreadPosition,
-  }: {
-    blankPagePosition: "after" | "before" | "none"
-    minimumWidth: number
-    spreadPosition: "none" | "right" | "left"
-  }) => {
-    width: number
-    height: number
-  }
-  item: {
-    id: string
-    href: string
-    renditionLayout: "reflowable" | "pre-paginated"
-    progressionWeight: number
-    pageSpreadLeft: true | undefined
-    pageSpreadRight: true | undefined
-    mediaType?: string | undefined
-  }
-  load: () => void
-  adjustPositionOfElement: ({
-    right,
-    left,
-    top,
-  }: {
-    right?: number | undefined
-    left?: number | undefined
-    top?: number | undefined
-  }) => 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: () =>
-      | {
-          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$: 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
+    layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
+        blankPagePosition: "after" | "before" | "none";
+        minimumWidth: number;
+        spreadPosition: "none" | "right" | "left";
+    }) => {
+        width: number;
+        height: number;
+    };
+    item: {
+        id: string;
+        href: string;
+        renditionLayout: "reflowable" | "pre-paginated";
+        progressionWeight: number;
+        pageSpreadLeft: true | undefined;
+        pageSpreadRight: true | undefined;
+        mediaType?: string | undefined;
+    };
+    load: () => void;
+    adjustPositionOfElement: ({ right, left, top }: {
+        right?: number | undefined;
+        left?: number | undefined;
+        top?: number | undefined;
+    }) => 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: () => {
+            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$: 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
+            width: number;
+            height: number;
+        };
+    } | undefined;
+    isImageType: () => boolean;
+    isReady: () => boolean;
+    destroy: () => void;
+    isUsingVerticalWriting: () => boolean | undefined;
+    getReadingDirection: () => "ltr" | "rtl" | undefined;
+    manipulateSpineItem: (cb: (options: {
+        container: HTMLElement;
         item: {
-          id: string
-          href: 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
-  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>
-  }
-}
-export type SpineItem = ReturnType<typeof createSpineItem>
+            id: string;
+            href: 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;
+    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>;
+    };
+};
+export type SpineItem = ReturnType<typeof createSpineItem>;

package/dist/spineItem/frameItem/createFrame$.d.ts

@@ -1,3 +1 @@
-export declare const createFrame$:
-  | (() => import("rxjs").Observable<HTMLIFrameElement>)
-  | (() => import("rxjs").Observable<HTMLIFrameElement>)
+export declare const createFrame$: (() => import("rxjs").Observable<HTMLIFrameElement>) | (() => import("rxjs").Observable<HTMLIFrameElement>);

package/dist/spineItem/frameItem/createFrameManipulator.d.ts

@@ -1,5 +1,5 @@
 export declare const createFrameManipulator: (frameElement: HTMLIFrameElement) => {
-  frame: HTMLIFrameElement
-  removeStyle: (id: string) => void
-  addStyle: (id: string, style: string, prepend?: boolean) => void
-}
+    frame: HTMLIFrameElement;
+    removeStyle: (id: string) => void;
+    addStyle: (id: string, style: string, prepend?: boolean) => void;
+};

package/dist/spineItem/frameItem/createHtmlPageFromResource.d.ts

@@ -1,5 +1,2 @@
-import { Manifest } from "../../types"
-export declare const createHtmlPageFromResource: (
-  resourceResponse: Response | string,
-  item: Manifest[`spineItems`][number]
-) => Promise<string>
+import { Manifest } from "../../types";
+export declare const createHtmlPageFromResource: (resourceResponse: Response | string, item: Manifest[`spineItems`][number]) => Promise<string>;

package/dist/spineItem/frameItem/frameItem.d.ts

@@ -1,55 +1,46 @@
-import { Observable } from "rxjs"
-import { Manifest } from "../../types"
-import { Context } from "../../context"
-import { Hook } from "../../types/Hook"
-import { createFrameManipulator } from "./createFrameManipulator"
-export declare const createFrameItem: ({
-  item,
-  parent,
-  fetchResource,
-  context,
-  hooks$,
-  viewportState$,
-}: {
-  parent: HTMLElement
-  item: Manifest[`spineItems`][number]
-  context: Context
-  fetchResource?: ((item: Manifest[`spineItems`][number]) => Promise<Response>) | undefined
-  hooks$: Observable<Hook[]>
-  viewportState$: Observable<`free` | `busy`>
+import { Observable } from "rxjs";
+import { Manifest } from "../../types";
+import { Context } from "../../context";
+import { Hook } from "../../types/Hook";
+import { createFrameManipulator } from "./createFrameManipulator";
+export declare const createFrameItem: ({ item, parent, fetchResource, context, hooks$, viewportState$, }: {
+    parent: HTMLElement;
+    item: Manifest[`spineItems`][number];
+    context: Context;
+    fetchResource?: ((item: Manifest[`spineItems`][number]) => Promise<Response>) | undefined;
+    hooks$: Observable<Hook[]>;
+    viewportState$: Observable<`free` | `busy`>;
 }) => {
-  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 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
-        }
-    >
-  }
-}
-export type SpineItemFrame = ReturnType<typeof createFrameItem>
+    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 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;
+        }>;
+    };
+};
+export type SpineItemFrame = ReturnType<typeof createFrameItem>;

package/dist/spineItem/frameItem/loader.d.ts

@@ -1,34 +1,27 @@
-import { BehaviorSubject, Observable } from "rxjs"
-import { Context } from "../../context"
-import { Manifest } from "../../types"
-import { Hook } from "../../types/Hook"
-export declare const createLoader: ({
-  item,
-  parent,
-  fetchResource,
-  hooks$,
-  context,
-  viewportState$,
-}: {
-  item: Manifest[`spineItems`][number]
-  parent: HTMLElement
-  fetchResource?: ((item: Manifest[`spineItems`][number]) => Promise<Response>) | undefined
-  hooks$: Observable<Hook[]>
-  context: Context
-  viewportState$: Observable<`free` | `busy`>
+import { BehaviorSubject, Observable } from "rxjs";
+import { Context } from "../../context";
+import { Manifest } from "../../types";
+import { Hook } from "../../types/Hook";
+export declare const createLoader: ({ item, parent, fetchResource, hooks$, context, viewportState$, }: {
+    item: Manifest[`spineItems`][number];
+    parent: HTMLElement;
+    fetchResource?: ((item: Manifest[`spineItems`][number]) => Promise<Response>) | undefined;
+    hooks$: Observable<Hook[]>;
+    context: Context;
+    viewportState$: Observable<`free` | `busy`>;
 }) => {
-  load: () => void
-  unload: () => void
-  destroy: () => void
-  getComputedStyleAfterLoad: () => CSSStyleDeclaration | undefined
-  $: {
-    load$: Observable<void>
-    unload$: Observable<void>
-    loaded$: Observable<HTMLIFrameElement>
-    isLoaded$: Observable<boolean>
-    isReady$: Observable<boolean>
-    ready$: Observable<FontFaceSet | undefined>
-    unloaded$: Observable<void>
-    frameElement$: BehaviorSubject<HTMLIFrameElement | undefined>
-  }
-}
+    load: () => void;
+    unload: () => void;
+    destroy: () => void;
+    getComputedStyleAfterLoad: () => CSSStyleDeclaration | undefined;
+    $: {
+        load$: Observable<void>;
+        unload$: Observable<void>;
+        loaded$: Observable<HTMLIFrameElement>;
+        isLoaded$: Observable<boolean>;
+        isReady$: Observable<boolean>;
+        ready$: Observable<FontFaceSet | undefined>;
+        unloaded$: Observable<void>;
+        frameElement$: BehaviorSubject<HTMLIFrameElement | undefined>;
+    };
+};

package/dist/spineItem/locationResolver.d.ts

@@ -1,35 +1,23 @@
-import { Context } from "../context"
-import { SpineItem } from "./createSpineItem"
-import { SpineItemPosition, UnsafeSpineItemPosition } from "./types"
-export declare const createLocationResolver: ({ context }: { context: Context }) => {
-  getSpineItemPositionFromNode: (
-    node: Node,
-    offset: number,
-    spineItem: SpineItem
-  ) =>
-    | {
-        x: number
-        y: number
-      }
-    | undefined
-  getSpineItemPositionFromPageIndex: (pageIndex: number, spineItem: SpineItem) => SpineItemPosition
-  getSpineItemOffsetFromAnchor: (anchor: string, spineItem: SpineItem) => number
-  getSpineItemPageIndexFromPosition: (position: UnsafeSpineItemPosition, spineItem: SpineItem) => number
-  getSpineItemPageIndexFromNode: (node: Node, offset: number, spineItem: SpineItem) => number | undefined
-  getSpineItemClosestPositionFromUnsafePosition: (
-    unsafePosition: UnsafeSpineItemPosition,
-    spineItem: SpineItem
-  ) => {
-    x: number
-    y: number
-  }
-  getFirstNodeOrRangeAtPage: (
-    pageIndex: number,
-    spineItem: SpineItem
-  ) =>
-    | {
-        node: Node
-        offset: number
-      }
-    | undefined
-}
+import { Context } from "../context";
+import { SpineItem } from "./createSpineItem";
+import { SpineItemPosition, UnsafeSpineItemPosition } from "./types";
+export declare const createLocationResolver: ({ context }: {
+    context: Context;
+}) => {
+    getSpineItemPositionFromNode: (node: Node, offset: number, spineItem: SpineItem) => {
+        x: number;
+        y: number;
+    } | undefined;
+    getSpineItemPositionFromPageIndex: (pageIndex: number, spineItem: SpineItem) => SpineItemPosition;
+    getSpineItemOffsetFromAnchor: (anchor: string, spineItem: SpineItem) => number;
+    getSpineItemPageIndexFromPosition: (position: UnsafeSpineItemPosition, spineItem: SpineItem) => number;
+    getSpineItemPageIndexFromNode: (node: Node, offset: number, spineItem: SpineItem) => number | undefined;
+    getSpineItemClosestPositionFromUnsafePosition: (unsafePosition: UnsafeSpineItemPosition, spineItem: SpineItem) => {
+        x: number;
+        y: number;
+    };
+    getFirstNodeOrRangeAtPage: (pageIndex: number, spineItem: SpineItem) => {
+        node: Node;
+        offset: number;
+    } | undefined;
+};