@file-viewer/core 2.0.0

package/dist/documentZoom.d.ts

@@ -0,0 +1,47 @@
+import type { FileViewerOperationType, FileViewerZoomProvider, FileViewerZoomState } from './types';
+export type FileViewerZoomOperation = Extract<FileViewerOperationType, 'zoom-in' | 'zoom-out' | 'zoom-reset'>;
+export interface CreateFileViewerZoomControllerOptions {
+    root: () => HTMLElement | null | undefined;
+    enabled?: () => boolean;
+    beforeZoom?: (operation: FileViewerZoomOperation) => Promise<boolean> | boolean;
+}
+export type MutableFileViewerZoomState = FileViewerZoomState;
+export interface FileViewerZoomController {
+    readonly provider: FileViewerZoomProvider | null;
+    readonly state: FileViewerZoomState;
+    hasProvider(): boolean;
+    refreshProvider(): FileViewerZoomProvider | null;
+    observe(): void;
+    clearProvider(): void;
+    getState(): FileViewerZoomState;
+    zoomIn(): Promise<FileViewerZoomState>;
+    zoomOut(): Promise<FileViewerZoomState>;
+    resetZoom(): Promise<FileViewerZoomState>;
+    destroy(): void;
+}
+export interface FileViewerZoomControllerActionHandlers {
+    hasZoomProvider(): boolean;
+    refreshZoomProvider(): FileViewerZoomProvider | null;
+    startZoomObserver(): FileViewerZoomState;
+    stopZoomObserver(): FileViewerZoomState;
+    clearZoomProvider(): FileViewerZoomState;
+    getZoomState(): FileViewerZoomState;
+    zoomIn(): Promise<FileViewerZoomState>;
+    zoomOut(): Promise<FileViewerZoomState>;
+    resetZoom(): Promise<FileViewerZoomState>;
+}
+export declare const cloneFileViewerZoomState: (state: FileViewerZoomState) => FileViewerZoomState;
+export declare const applyFileViewerZoomState: <Target extends MutableFileViewerZoomState>(target: Target, source?: Partial<FileViewerZoomState> | null) => Target;
+export declare const createFileViewerZoomChangeState: (state: FileViewerZoomState) => FileViewerZoomState;
+export declare const syncFileViewerZoomControllerState: <Target extends MutableFileViewerZoomState>(target: Target, controller: Pick<FileViewerZoomController, "state">) => Target;
+export declare const refreshFileViewerZoomControllerProvider: <Target extends MutableFileViewerZoomState>(target: Target, controller: Pick<FileViewerZoomController, "refreshProvider" | "state">) => FileViewerZoomProvider | null;
+export declare const observeFileViewerZoomController: <Target extends MutableFileViewerZoomState>(target: Target, controller: Pick<FileViewerZoomController, "observe" | "state">) => Target;
+export declare const clearFileViewerZoomControllerProvider: <Target extends MutableFileViewerZoomState>(target: Target, controller: Pick<FileViewerZoomController, "clearProvider" | "state">) => Target;
+export declare const destroyFileViewerZoomController: <Target extends MutableFileViewerZoomState>(target: Target, controller: Pick<FileViewerZoomController, "destroy" | "state">) => Target;
+export declare const runFileViewerZoomControllerAction: <Target extends MutableFileViewerZoomState>(target: Target, action: () => Promise<FileViewerZoomState>) => Promise<FileViewerZoomState>;
+export declare const createFileViewerZoomControllerActionHandlers: <Target extends MutableFileViewerZoomState>(target: Target, controller: FileViewerZoomController) => FileViewerZoomControllerActionHandlers;
+export declare const createFileViewerZoomChangeEmitter: () => {
+    emit(): void;
+    subscribe(listener: () => void): () => void;
+};
+export declare const createFileViewerZoomController: ({ root, enabled, beforeZoom, }: CreateFileViewerZoomControllerOptions) => FileViewerZoomController;

package/dist/documentZoom.js

@@ -0,0 +1,184 @@
+import { createFileViewerZoomState } from './document.js';
+import { findFileViewerZoomProvider } from './documentDom.js';
+export const cloneFileViewerZoomState = (state) => ({
+    scale: state.scale,
+    label: state.label,
+    canZoomIn: state.canZoomIn,
+    canZoomOut: state.canZoomOut,
+    canReset: state.canReset,
+    minScale: state.minScale,
+    maxScale: state.maxScale,
+});
+export const applyFileViewerZoomState = (target, source) => {
+    const normalized = createFileViewerZoomState(source || {});
+    target.scale = normalized.scale;
+    target.label = normalized.label;
+    target.canZoomIn = normalized.canZoomIn;
+    target.canZoomOut = normalized.canZoomOut;
+    target.canReset = normalized.canReset;
+    target.minScale = normalized.minScale;
+    target.maxScale = normalized.maxScale;
+    return target;
+};
+export const createFileViewerZoomChangeState = (state) => {
+    return cloneFileViewerZoomState(state);
+};
+export const syncFileViewerZoomControllerState = (target, controller) => {
+    return applyFileViewerZoomState(target, controller.state);
+};
+export const refreshFileViewerZoomControllerProvider = (target, controller) => {
+    const provider = controller.refreshProvider();
+    syncFileViewerZoomControllerState(target, controller);
+    return provider;
+};
+export const observeFileViewerZoomController = (target, controller) => {
+    controller.observe();
+    return syncFileViewerZoomControllerState(target, controller);
+};
+export const clearFileViewerZoomControllerProvider = (target, controller) => {
+    controller.clearProvider();
+    return syncFileViewerZoomControllerState(target, controller);
+};
+export const destroyFileViewerZoomController = (target, controller) => {
+    controller.destroy();
+    return syncFileViewerZoomControllerState(target, controller);
+};
+export const runFileViewerZoomControllerAction = async (target, action) => {
+    const nextState = await action();
+    applyFileViewerZoomState(target, nextState);
+    return createFileViewerZoomChangeState(target);
+};
+export const createFileViewerZoomControllerActionHandlers = (target, controller) => {
+    return {
+        hasZoomProvider() {
+            const nextProvider = refreshFileViewerZoomControllerProvider(target, controller);
+            return !!nextProvider;
+        },
+        refreshZoomProvider() {
+            return refreshFileViewerZoomControllerProvider(target, controller);
+        },
+        startZoomObserver() {
+            return observeFileViewerZoomController(target, controller);
+        },
+        stopZoomObserver() {
+            return destroyFileViewerZoomController(target, controller);
+        },
+        clearZoomProvider() {
+            return clearFileViewerZoomControllerProvider(target, controller);
+        },
+        getZoomState() {
+            return createFileViewerZoomChangeState(target);
+        },
+        zoomIn() {
+            return runFileViewerZoomControllerAction(target, () => controller.zoomIn());
+        },
+        zoomOut() {
+            return runFileViewerZoomControllerAction(target, () => controller.zoomOut());
+        },
+        resetZoom() {
+            return runFileViewerZoomControllerAction(target, () => controller.resetZoom());
+        },
+    };
+};
+export const createFileViewerZoomChangeEmitter = () => {
+    const listeners = new Set();
+    return {
+        emit() {
+            listeners.forEach(listener => listener());
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+};
+const getMutationObserverConstructor = (root) => {
+    var _a, _b;
+    return ((_b = (_a = root === null || root === void 0 ? void 0 : root.ownerDocument) === null || _a === void 0 ? void 0 : _a.defaultView) === null || _b === void 0 ? void 0 : _b.MutationObserver) ||
+        (typeof MutationObserver !== 'undefined' ? MutationObserver : undefined);
+};
+export const createFileViewerZoomController = ({ root, enabled, beforeZoom, }) => {
+    let provider = null;
+    let unsubscribe = null;
+    let observer = null;
+    const state = createFileViewerZoomState();
+    const clearProvider = () => {
+        unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe();
+        unsubscribe = null;
+        provider = null;
+        applyFileViewerZoomState(state, null);
+    };
+    const syncProvider = () => {
+        var _a, _b;
+        if ((enabled === null || enabled === void 0 ? void 0 : enabled()) === false) {
+            clearProvider();
+            return null;
+        }
+        const nextProvider = findFileViewerZoomProvider(root());
+        if (nextProvider !== provider) {
+            unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe();
+            provider = nextProvider;
+            unsubscribe = ((_a = nextProvider === null || nextProvider === void 0 ? void 0 : nextProvider.subscribe) === null || _a === void 0 ? void 0 : _a.call(nextProvider, () => {
+                applyFileViewerZoomState(state, nextProvider.getState());
+            })) || null;
+        }
+        applyFileViewerZoomState(state, ((_b = nextProvider === null || nextProvider === void 0 ? void 0 : nextProvider.getState) === null || _b === void 0 ? void 0 : _b.call(nextProvider)) || null);
+        return nextProvider;
+    };
+    const disconnectObserver = () => {
+        observer === null || observer === void 0 ? void 0 : observer.disconnect();
+        observer = null;
+    };
+    const runZoomAction = async (operation, action) => {
+        const nextProvider = syncProvider();
+        if (!nextProvider) {
+            return cloneFileViewerZoomState(state);
+        }
+        if (beforeZoom && await beforeZoom(operation) === false) {
+            return cloneFileViewerZoomState(state);
+        }
+        const nextState = await action(nextProvider);
+        applyFileViewerZoomState(state, nextState || nextProvider.getState());
+        return cloneFileViewerZoomState(state);
+    };
+    return {
+        get provider() {
+            return provider;
+        },
+        state,
+        hasProvider() {
+            return !!syncProvider();
+        },
+        refreshProvider: syncProvider,
+        observe() {
+            disconnectObserver();
+            const currentRoot = root();
+            const MutationObserverCtor = getMutationObserverConstructor(currentRoot);
+            if (!currentRoot || !MutationObserverCtor) {
+                syncProvider();
+                return;
+            }
+            observer = new MutationObserverCtor(() => {
+                syncProvider();
+            });
+            observer.observe(currentRoot, {
+                childList: true,
+                subtree: true,
+            });
+            syncProvider();
+        },
+        clearProvider,
+        getState() {
+            return cloneFileViewerZoomState(state);
+        },
+        zoomIn: () => runZoomAction('zoom-in', nextProvider => nextProvider.zoomIn()),
+        zoomOut: () => runZoomAction('zoom-out', nextProvider => nextProvider.zoomOut()),
+        resetZoom: () => runZoomAction('zoom-reset', nextProvider => nextProvider.resetZoom()),
+        destroy() {
+            disconnectObserver();
+            clearProvider();
+        },
+    };
+};

package/dist/export.d.ts

@@ -0,0 +1,26 @@
+import type { FileRenderExportAdapter, FileRenderExportMode, FileRenderExportOptions } from './types';
+export interface BuildExportHtmlDocumentOptions {
+    contentHtml: string;
+    includeDocumentStyles?: boolean;
+    printStyle?: string;
+    title: string;
+    watermarkInlineStyle?: string;
+}
+export declare const collectDocumentStyles: () => string;
+export declare const buildExportHtmlDocument: ({ contentHtml, includeDocumentStyles, printStyle, title, watermarkInlineStyle }: BuildExportHtmlDocumentOptions) => string;
+export interface BuildFileViewerRenderedHtmlDocumentOptions {
+    source: HTMLElement;
+    mode?: FileRenderExportMode;
+    title: string;
+    adapter?: FileRenderExportAdapter | null;
+    watermarkInlineStyle?: string;
+}
+export declare const triggerFileViewerBlobDownload: (blob: Blob, name: string) => void;
+export declare const triggerFileViewerUrlDownload: (url: string, name: string) => void;
+export declare const replaceFileViewerCanvasWithImages: (source: HTMLElement, clone: HTMLElement) => void;
+export declare const waitForFileViewerNextPaint: (targetWindow?: Partial<Pick<Window, "requestAnimationFrame" | "setTimeout">>) => Promise<void>;
+export declare const waitForFileViewerImages: (root: ParentNode) => Promise<void>;
+export declare const waitForFileViewerPrintWindowReady: (printWindow: Window) => Promise<void>;
+export declare const resolveFileViewerPrintStyle: (adapter: FileRenderExportAdapter | null, options: FileRenderExportOptions) => Promise<string>;
+export declare const prepareFileViewerRenderedContentForSnapshot: (source: HTMLElement, adapter?: FileRenderExportAdapter | null) => Promise<void>;
+export declare const buildFileViewerRenderedHtmlDocument: ({ source, mode, title, adapter, watermarkInlineStyle }: BuildFileViewerRenderedHtmlDocumentOptions) => Promise<string>;