@prose-reader/core 1.117.0 → 1.119.0

package/dist/spine/locator/getSpineItemFromPosition.d.ts

@@ -7,121 +7,4 @@ export declare const getSpineItemFromPosition: ({ position, spineItemsManager, s
     spineItemsManager: SpineItemsManager;
     spineLayout: SpineLayout;
     settings: ReaderSettingsManager;
-}) => {
-    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;
-    };
-    overlayElement: HTMLDivElement;
-    adjustPositionOfElement: ({ right, left, top, }: {
-        right?: number;
-        left?: number;
-        top?: number;
-    }) => void;
-    getElementDimensions: () => {
-        width: number;
-        height: number;
-        x: number;
-        y: number;
-        bottom: number;
-        left: number;
-        right: number;
-        top: number;
-        toJSON(): any;
-    };
-    getHtmlFromResource: (response: Response) => Promise<string>;
-    getResource: () => Promise<Response>;
-    translateFramePositionIntoPage: (position: {
-        clientX: number;
-        clientY: number;
-    }) => {
-        clientX: number;
-        clientY: number;
-    };
-    injectStyle: (cssText: string) => void;
-    load: () => void;
-    unload: () => void;
-    frame: import('../../spineItem/frame/FrameItem').FrameItem;
-    element: HTMLElement;
-    getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
-    getViewPortInformation: () => {
-        computedScale: number;
-        computedWidthScale: number;
-        viewportDimensions: {
-            width: number;
-            height: number;
-        };
-    } | undefined;
-    isImageType: () => boolean;
-    isReady: () => boolean;
-    destroy: () => void;
-    readingDirection: "ltr" | "rtl" | undefined;
-    isUsingVerticalWriting: () => boolean | undefined;
-    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;
+}) => import('../../spineItem/SpineItem').SpineItem | undefined;

package/dist/spineItem/DocumentRenderer.d.ts

@@ -0,0 +1,48 @@
+import { Manifest } from '@prose-reader/shared';
+import { Context } from '../context/Context';
+import { HookManager } from '../hooks/HookManager';
+import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ResourceHandler } from './ResourceHandler';
+type Layer = {
+    element: HTMLElement;
+};
+export declare abstract class DocumentRenderer {
+    protected context: Context;
+    protected settings: ReaderSettingsManager;
+    protected hookManager: HookManager;
+    protected item: Manifest[`spineItems`][number];
+    protected containerElement: HTMLElement;
+    protected resourcesHandler: ResourceHandler;
+    protected stateSubject: BehaviorSubject<"idle" | "loading" | "loaded" | "unloading" | "ready">;
+    private triggerSubject;
+    layers: Layer[];
+    protected unload$: Observable<undefined>;
+    protected load$: Observable<undefined>;
+    constructor(context: Context, settings: ReaderSettingsManager, hookManager: HookManager, item: Manifest[`spineItems`][number], containerElement: HTMLElement, resourcesHandler: ResourceHandler);
+    protected destroy$: Observable<"destroy">;
+    get state$(): BehaviorSubject<"idle" | "loading" | "loaded" | "unloading" | "ready">;
+    load(): void;
+    unload(): void;
+    destroy(): void;
+    abstract onUnload(): Observable<unknown>;
+    abstract onCreateDocument(): Observable<unknown>;
+    abstract onLoadDocument(): Observable<unknown>;
+    abstract layout(params: {
+        minPageSpread: number;
+        blankPagePosition: `before` | `after` | `none`;
+        spreadPosition: `none` | `left` | `right`;
+    }): {
+        width: number;
+        height: number;
+    } | undefined;
+    get writingMode(): `vertical-rl` | `horizontal-tb` | undefined;
+    get readingDirection(): `rtl` | `ltr` | undefined;
+}
+export declare class DefaultRenderer extends DocumentRenderer {
+    onUnload(): Observable<unknown>;
+    onCreateDocument(): Observable<unknown>;
+    onLoadDocument(): Observable<unknown>;
+    layout(): undefined;
+}
+export {};

package/dist/spineItem/ResourceHandler.d.ts

@@ -0,0 +1,15 @@
+import { Manifest } from '@prose-reader/shared';
+import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
+export declare class ResourceHandler {
+    protected item: Manifest["items"][number];
+    protected settings: ReaderSettingsManager;
+    constructor(item: Manifest["items"][number], settings: ReaderSettingsManager);
+    getResource(): Promise<URL | Response | {
+        custom: true;
+        data: unknown;
+    }>;
+    fetchResource(): Promise<Response | {
+        custom: true;
+        data: unknown;
+    }>;
+}

package/dist/spineItem/SpineItem.d.ts

@@ -0,0 +1,64 @@
+import { Context } from '../context/Context';
+import { Manifest } from '..';
+import { Observable, Subject } from 'rxjs';
+import { createFingerTracker, createSelectionTracker } from './trackers';
+import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
+import { HookManager } from '../hooks/HookManager';
+import { DocumentRenderer } from './DocumentRenderer';
+import { ResourceHandler } from './ResourceHandler';
+export declare class SpineItem {
+    item: Manifest[`spineItems`][number];
+    parentElement: HTMLElement;
+    context: Context;
+    settings: ReaderSettingsManager;
+    hookManager: HookManager;
+    index: number;
+    destroySubject$: Subject<void>;
+    containerElement: HTMLElement;
+    fingerTracker: ReturnType<typeof createFingerTracker>;
+    selectionTracker: ReturnType<typeof createSelectionTracker>;
+    contentLayout$: Observable<{
+        isFirstLayout: boolean;
+        isReady: boolean;
+    }>;
+    renderer: DocumentRenderer;
+    resourcesHandler: ResourceHandler;
+    constructor(item: Manifest[`spineItems`][number], parentElement: HTMLElement, context: Context, settings: ReaderSettingsManager, hookManager: HookManager, index: number);
+    adjustPositionOfElement: ({ right, left, top, }: {
+        right?: number;
+        left?: number;
+        top?: number;
+    }) => void;
+    getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+    layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
+        blankPagePosition: `before` | `after` | `none`;
+        minimumWidth: number;
+        spreadPosition: `left` | `right` | `none`;
+    }) => {
+        width: number;
+        height: number;
+    };
+    load: () => void;
+    unload: () => void;
+    getElementDimensions: () => {
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+        bottom: number;
+        left: number;
+        right: number;
+        top: number;
+        toJSON(): any;
+    };
+    destroy: () => void;
+    get element(): HTMLElement;
+    get readingDirection(): "rtl" | "ltr" | undefined;
+    isUsingVerticalWriting: () => boolean;
+    get isReady(): boolean;
+    get ready$(): Observable<"ready">;
+    get loaded$(): Observable<"loaded">;
+    get unloaded$(): Observable<"idle">;
+    get isReady$(): Observable<boolean>;
+    upsertCSS(id: string, style: string, prepend?: boolean): void;
+}

package/dist/spineItem/locationResolver.d.ts

@@ -1,7 +1,7 @@
 import { Context } from '../context/Context';
-import { SpineItem } from './createSpineItem';
 import { SafeSpineItemPosition, UnsafeSpineItemPosition } from './types';
 import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
+import { SpineItem } from './SpineItem';
 export type SpineItemLocator = ReturnType<typeof createSpineItemLocator>;
 export declare const createSpineItemLocator: ({ context, settings, }: {
     context: Context;

package/dist/spineItem/navigationResolver.d.ts

@@ -1,7 +1,7 @@
-import { SpineItem } from './createSpineItem';
 import { Context } from '../context/Context';
 import { SafeSpineItemPosition, UnsafeSpineItemPosition } from './types';
 import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
+import { SpineItem } from './SpineItem';
 export type SpineItemNavigationResolver = ReturnType<typeof createNavigationResolver>;
 export declare const createNavigationResolver: ({ context, settings, }: {
     context: Context;

package/dist/utils/frames.d.ts

@@ -1 +1,16 @@
+import { Observable } from 'rxjs';
 export declare const getAttributeValueFromString: (string: string, key: string) => number;
+export declare const injectCSS: (frameElement: HTMLIFrameElement, id: string, style: string, prepend?: boolean) => void;
+export declare const removeCSS: (frameElement: HTMLIFrameElement, id: string) => void;
+export declare const upsertCSS: (frameElement: HTMLIFrameElement | undefined, id: string, style: string, prepend?: boolean) => void;
+export declare const getFrameViewportInfo: (frame: HTMLIFrameElement | undefined) => {
+    hasViewport: boolean;
+    width: number;
+    height: number;
+} | {
+    hasViewport: boolean;
+    width?: undefined;
+    height?: undefined;
+};
+export declare const waitForFrameLoad: (stream: Observable<HTMLIFrameElement>) => Observable<HTMLIFrameElement>;
+export declare const waitForFrameReady: (stream: Observable<HTMLIFrameElement>) => Observable<HTMLIFrameElement>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prose-reader/core",
-  "version": "1.117.0",
+  "version": "1.119.0",
   "type": "module",
   "main": "./dist/index.umd.cjs",
   "module": "./dist/index.js",
@@ -25,7 +25,7 @@
     "tsc": "tsc"
   },
   "dependencies": {
-    "@prose-reader/shared": "^1.117.0"
+    "@prose-reader/shared": "^1.119.0"
   },
   "peerDependencies": {
     "rxjs": "*"
@@ -33,5 +33,5 @@
   "devDependencies": {
     "jsdom": "^24.0.0"
   },
-  "gitHead": "7979b7ba99701920e600a1c3a798d141fa3679f3"
+  "gitHead": "8fba086fc519af1bef577817629bd55a914cd923"
 }

package/dist/enhancers/media.d.ts

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

package/dist/spineItem/commonSpineItem.d.ts

@@ -1,128 +0,0 @@
-import { Context } from '../context/Context';
-import { FrameItem } from './frame/FrameItem';
-import { Manifest } from '..';
-import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
-import { HookManager } from '../hooks/HookManager';
-export declare const createCommonSpineItem: ({ item, context, parentElement, settings, hookManager, index, }: {
-    item: Manifest[`spineItems`][number];
-    parentElement: HTMLElement;
-    context: Context;
-    settings: ReaderSettingsManager;
-    hookManager: HookManager;
-    index: number;
-}) => {
-    item: {
-        id: string;
-        href: string;
-        renditionLayout?: `reflowable` | `pre-paginated`;
-        progressionWeight?: number;
-        pageSpreadLeft?: true | undefined;
-        pageSpreadRight?: true | undefined;
-        mediaType?: string;
-    };
-    layout: ({ height, width, blankPagePosition, minimumWidth, }: {
-        height: number;
-        width: number;
-        blankPagePosition: `before` | `after` | `none`;
-        minimumWidth: number;
-    }) => void;
-    overlayElement: HTMLDivElement;
-    adjustPositionOfElement: ({ right, left, top, }: {
-        right?: number;
-        left?: number;
-        top?: number;
-    }) => void;
-    getElementDimensions: () => {
-        width: number;
-        height: number;
-        x: number;
-        y: number;
-        bottom: number;
-        left: number;
-        right: number;
-        top: number;
-        toJSON(): any;
-    };
-    getHtmlFromResource: (response: Response) => Promise<string>;
-    getResource: () => Promise<Response>;
-    translateFramePositionIntoPage: (position: {
-        clientX: number;
-        clientY: number;
-    }) => {
-        clientX: number;
-        clientY: number;
-    };
-    injectStyle: (cssText: string) => void;
-    load: () => void;
-    unload: () => void;
-    frame: FrameItem;
-    element: HTMLElement;
-    getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
-    getViewPortInformation: () => {
-        computedScale: number;
-        computedWidthScale: number;
-        viewportDimensions: {
-            width: number;
-            height: number;
-        };
-    } | undefined;
-    isImageType: () => boolean;
-    isReady: () => boolean;
-    destroy: () => void;
-    readonly readingDirection: "ltr" | "rtl" | undefined;
-    isUsingVerticalWriting: () => boolean | undefined;
-    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>;
-    };
-};

package/dist/spineItem/createSpineItem.d.ts

@@ -1,130 +0,0 @@
-import { Context } from '../context/Context';
-import { Manifest } from '..';
-import { ReaderSettingsManager } from '../settings/ReaderSettingsManager';
-import { HookManager } from '../hooks/HookManager';
-export declare const createSpineItem: ({ item, context, containerElement, settings, hookManager, index, }: {
-    item: Manifest[`spineItems`][number];
-    containerElement: HTMLElement;
-    context: Context;
-    settings: ReaderSettingsManager;
-    hookManager: HookManager;
-    index: number;
-}) => {
-    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;
-    };
-    overlayElement: HTMLDivElement;
-    adjustPositionOfElement: ({ right, left, top, }: {
-        right?: number;
-        left?: number;
-        top?: number;
-    }) => void;
-    getElementDimensions: () => {
-        width: number;
-        height: number;
-        x: number;
-        y: number;
-        bottom: number;
-        left: number;
-        right: number;
-        top: number;
-        toJSON(): any;
-    };
-    getHtmlFromResource: (response: Response) => Promise<string>;
-    getResource: () => Promise<Response>;
-    translateFramePositionIntoPage: (position: {
-        clientX: number;
-        clientY: number;
-    }) => {
-        clientX: number;
-        clientY: number;
-    };
-    injectStyle: (cssText: string) => void;
-    load: () => void;
-    unload: () => void;
-    frame: import('./frame/FrameItem').FrameItem;
-    element: HTMLElement;
-    getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
-    getViewPortInformation: () => {
-        computedScale: number;
-        computedWidthScale: number;
-        viewportDimensions: {
-            width: number;
-            height: number;
-        };
-    } | undefined;
-    isImageType: () => boolean;
-    isReady: () => boolean;
-    destroy: () => void;
-    readingDirection: "ltr" | "rtl" | undefined;
-    isUsingVerticalWriting: () => boolean | undefined;
-    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>;
-    };
-};
-export type SpineItem = ReturnType<typeof createSpineItem>;

package/dist/spineItem/frame/FrameItem.d.ts

@@ -1,43 +0,0 @@
-import { Observable } from 'rxjs';
-import { Manifest } from '../..';
-import { Context } from '../../context/Context';
-import { createLoader } from './loader/loader';
-import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
-import { HookManager } from '../../hooks/HookManager';
-import { DestroyableClass } from '../../utils/DestroyableClass';
-export declare class FrameItem extends DestroyableClass {
-    protected parent: HTMLElement;
-    protected item: Manifest[`spineItems`][number];
-    protected context: Context;
-    protected settings: ReaderSettingsManager;
-    protected hookManager: HookManager;
-    protected loader: ReturnType<typeof createLoader>;
-    contentLayoutChange$: Observable<{
-        isFirstLayout: boolean;
-    }>;
-    constructor(parent: HTMLElement, item: Manifest[`spineItems`][number], context: Context, settings: ReaderSettingsManager, hookManager: HookManager);
-    getComputedStyleAfterLoad(): CSSStyleDeclaration | undefined;
-    getViewportDimensions: () => {
-        width: number;
-        height: number;
-    } | undefined;
-    getWritingMode: () => `vertical-rl` | `horizontal-tb` | undefined;
-    isUsingVerticalWriting: () => boolean;
-    getHtmlFromResource: (response: Response) => Promise<string>;
-    get element(): HTMLIFrameElement | undefined;
-    get unloaded$(): Observable<"success">;
-    get loaded$(): Observable<HTMLIFrameElement>;
-    get ready$(): Observable<FontFaceSet | undefined>;
-    get isReady$(): Observable<boolean>;
-    get isLoaded(): boolean;
-    get isReady(): boolean;
-    load(): void;
-    unload(): void;
-    staticLayout: (size: {
-        width: number;
-        height: number;
-    }) => void;
-    addStyle(id: string, style: string, prepend?: boolean): void;
-    removeStyle(id: string): void;
-    destroy: () => void;
-}

package/dist/spineItem/frame/loader/configureFrame.d.ts

@@ -1,9 +0,0 @@
-import { Observable } from 'rxjs';
-import { ReaderSettingsManager } from '../../../settings/ReaderSettingsManager';
-import { Manifest } from '@prose-reader/shared';
-import { HookManager } from '../../..';
-export declare const configureFrame: ({ settings, item, hookManager, }: {
-    settings: ReaderSettingsManager;
-    item: Manifest[`spineItems`][number];
-    hookManager: HookManager;
-}) => (stream: Observable<HTMLIFrameElement>) => Observable<HTMLIFrameElement>;

package/dist/spineItem/frame/loader/loadFrame.d.ts

@@ -1,11 +0,0 @@
-import { HookManager, Manifest } from '../../..';
-import { ReaderSettingsManager } from '../../../settings/ReaderSettingsManager';
-import { Context } from '../../../context/Context';
-export declare const loadFrame: ({ settings, item, hookManager, element, onFrameElement, context, }: {
-    settings: ReaderSettingsManager;
-    item: Manifest[`spineItems`][number];
-    hookManager: HookManager;
-    element: HTMLElement;
-    onFrameElement: (element: HTMLIFrameElement) => void;
-    context: Context;
-}) => import('rxjs').Observable<HTMLIFrameElement>;

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

@@ -1,22 +0,0 @@
-import { Context } from '../../../context/Context';
-import { Manifest } from '../../..';
-import { ReaderSettingsManager } from '../../../settings/ReaderSettingsManager';
-import { HookManager } from '../../../hooks/HookManager';
-export declare const createLoader: ({ item, parent, context, settings, hookManager, }: {
-    item: Manifest[`spineItems`][number];
-    parent: HTMLElement;
-    context: Context;
-    settings: ReaderSettingsManager;
-    hookManager: HookManager;
-}) => {
-    load: () => void;
-    unload: () => void;
-    destroy: () => void;
-    readonly state: "idle" | "loading" | "loaded" | "unloading" | "ready";
-    readonly element: HTMLIFrameElement | undefined;
-    isReady$: import('rxjs').Observable<boolean>;
-    ready$: import('rxjs').Observable<FontFaceSet | undefined>;
-    loaded$: import('rxjs').Observable<HTMLIFrameElement>;
-    unloaded$: import('rxjs').Observable<"success">;
-    element$: import('rxjs').Observable<HTMLIFrameElement | undefined>;
-};

package/dist/spineItem/frame/loader/unloadFrame.d.ts

@@ -1,8 +0,0 @@
-import { HookManager, Manifest } from '../../..';
-import { Context } from '../../../context/Context';
-export declare const unloadFrame: ({ item, hookManager, frameElement, context, }: {
-    item: Manifest[`spineItems`][number];
-    hookManager: HookManager;
-    frameElement?: HTMLIFrameElement;
-    context: Context;
-}) => import('rxjs').Observable<null>;

package/dist/spineItem/frame/loader/waitForFrameLoad.d.ts

@@ -1,2 +0,0 @@
-import { Observable } from 'rxjs';
-export declare const waitForFrameLoad: (stream: Observable<HTMLIFrameElement>) => Observable<HTMLIFrameElement>;