@file-viewer/core 2.0.0

package/dist/viewer.js

@@ -0,0 +1,285 @@
+import { createEmptyFileViewerSearchState, } from './document.js';
+import { createFileViewerDocumentFeatureControllerActionHandlers, } from './documentEvents.js';
+import { createFileViewerZoomController } from './documentZoom.js';
+import { DEFAULT_FILE_VIEWER_DOWNLOAD_FILENAME, DEFAULT_FILE_VIEWER_EXPORT_FILENAME, DEFAULT_FILE_VIEWER_PREVIEW_TITLE, createFileViewerOriginalSourceStateFromNormalizedSource, executeFileViewerDownloadOperation, executeFileViewerExportHtmlOperation, executeFileViewerPrintOperation, resolveFileViewerDisplayFilename, resolveFileViewerOperationFilename, } from './viewerOperations.js';
+import { getRendererAvailability, createUnsupportedAvailability } from './capabilities.js';
+import { buildFileViewerLifecycleContextFromNormalizedSource, buildFileViewerOperationContext, runFileViewerBeforeOperation, runFileViewerLifecycleHook, } from './operations.js';
+import { createRendererRegistry } from './registry.js';
+import { applyFileViewerRenderSurfaceState, createFileViewerRenderSurfaceState, } from './rendererHandler.js';
+import { createFileViewerRequestScope } from './sourceLoading.js';
+import { normalizeSource } from './source.js';
+import { buildFileViewerWatermarkInlineStyle } from './watermark.js';
+const emitLifecycle = async (options, onEvent, phase, source, version, startedAt, reason) => {
+    const now = Date.now();
+    const context = buildFileViewerLifecycleContextFromNormalizedSource({
+        phase,
+        source,
+        version,
+        timestamp: now,
+        startedAt,
+        reason,
+    });
+    await runFileViewerLifecycleHook(context, options.hooks, error => {
+        throw error;
+    });
+    onEvent === null || onEvent === void 0 ? void 0 : onEvent({ type: phase, payload: context });
+};
+export const createViewer = (container, createOptions = {}) => {
+    const registry = createOptions.registry || createRendererRegistry();
+    let options = createOptions.options || {};
+    let currentSource = null;
+    const renderSurfaceState = createFileViewerRenderSurfaceState();
+    const requestScope = createFileViewerRequestScope();
+    const documentTarget = {
+        anchors: { value: [] },
+        state: createEmptyFileViewerSearchState(),
+    };
+    const buildCurrentLifecycleContext = () => {
+        const source = currentSource || normalizeSource({});
+        return buildFileViewerLifecycleContextFromNormalizedSource({
+            phase: 'load-complete',
+            source,
+            version: requestScope.getCurrentVersion(),
+            timestamp: Date.now(),
+        });
+    };
+    const runBeforeViewerOperation = async (operation) => {
+        const context = buildFileViewerOperationContext(operation, buildCurrentLifecycleContext());
+        return runFileViewerBeforeOperation({
+            context,
+            options,
+            onBefore: nextContext => {
+                var _a;
+                (_a = createOptions.onEvent) === null || _a === void 0 ? void 0 : _a.call(createOptions, { type: 'operation-before', payload: nextContext });
+            },
+            onCancel: nextContext => {
+                var _a;
+                (_a = createOptions.onEvent) === null || _a === void 0 ? void 0 : _a.call(createOptions, { type: 'operation-cancel', payload: nextContext });
+            },
+            onError(error) {
+                throw error;
+            },
+        });
+    };
+    const getWatermarkInlineStyle = (override) => {
+        if (typeof override === 'string') {
+            return override;
+        }
+        return buildFileViewerWatermarkInlineStyle(options.watermark);
+    };
+    const getCapabilitiesForExtension = (extension) => {
+        const targetExtension = extension || (currentSource === null || currentSource === void 0 ? void 0 : currentSource.extension) || '';
+        const renderer = registry.getByExtension(targetExtension);
+        if (!renderer) {
+            return createUnsupportedAvailability(targetExtension);
+        }
+        return getRendererAvailability(renderer, renderSurfaceState.session);
+    };
+    const emitOperationAvailabilityChange = () => {
+        var _a;
+        (_a = createOptions.onEvent) === null || _a === void 0 ? void 0 : _a.call(createOptions, {
+            type: 'operation-availability-change',
+            payload: getCapabilitiesForExtension(),
+        });
+    };
+    const emitZoomChange = (state = zoomController.getState()) => {
+        var _a;
+        (_a = createOptions.onEvent) === null || _a === void 0 ? void 0 : _a.call(createOptions, {
+            type: 'zoom-change',
+            payload: state,
+        });
+    };
+    const zoomController = createFileViewerZoomController({
+        root: () => container,
+        beforeZoom: runBeforeViewerOperation,
+    });
+    const documentActions = createFileViewerDocumentFeatureControllerActionHandlers({
+        root: () => container,
+        searchTarget: documentTarget,
+        searchOptions: () => options.search,
+        getAiOptions: () => options.ai,
+        onSearchChange: state => {
+            var _a;
+            (_a = createOptions.onEvent) === null || _a === void 0 ? void 0 : _a.call(createOptions, { type: 'search-change', payload: state });
+        },
+        onLocationChange: anchor => {
+            var _a;
+            (_a = createOptions.onEvent) === null || _a === void 0 ? void 0 : _a.call(createOptions, { type: 'location-change', payload: anchor });
+        },
+    });
+    zoomController.observe();
+    const destroyCurrent = async (reason = 'replace') => {
+        var _a, _b;
+        if (!currentSource) {
+            return;
+        }
+        const source = currentSource;
+        const startedAt = Date.now();
+        const version = requestScope.getCurrentVersion();
+        await emitLifecycle(options, createOptions.onEvent, 'unload-start', source, version, startedAt, reason);
+        await ((_b = (_a = renderSurfaceState.session) === null || _a === void 0 ? void 0 : _a.destroy) === null || _b === void 0 ? void 0 : _b.call(_a));
+        currentSource = null;
+        applyFileViewerRenderSurfaceState(renderSurfaceState, {
+            session: null,
+            exportAdapter: null,
+        });
+        await documentActions.clearDocumentState();
+        zoomController.clearProvider();
+        emitOperationAvailabilityChange();
+        emitZoomChange();
+        await emitLifecycle(options, createOptions.onEvent, 'unload-complete', source, version, startedAt, reason);
+    };
+    return {
+        container,
+        async load(source) {
+            await destroyCurrent('replace');
+            const normalized = normalizeSource(source);
+            currentSource = normalized;
+            const version = requestScope.requestController.createVersion();
+            const renderer = registry.getByExtension(normalized.extension);
+            const startedAt = Date.now();
+            await emitLifecycle(options, createOptions.onEvent, 'load-start', normalized, version, startedAt);
+            if (!(renderer === null || renderer === void 0 ? void 0 : renderer.load)) {
+                applyFileViewerRenderSurfaceState(renderSurfaceState, { session: null });
+                emitOperationAvailabilityChange();
+                emitZoomChange();
+                await emitLifecycle(options, createOptions.onEvent, 'load-complete', normalized, version, startedAt);
+                return null;
+            }
+            const session = await renderer.load({
+                source: normalized,
+                surface: { container },
+                options,
+                signal: createOptions.signal,
+                registerExportAdapter: adapter => {
+                    applyFileViewerRenderSurfaceState(renderSurfaceState, { exportAdapter: adapter });
+                },
+            });
+            applyFileViewerRenderSurfaceState(renderSurfaceState, { session });
+            zoomController.refreshProvider();
+            await documentActions.refreshDocumentIndex({ notify: false });
+            emitOperationAvailabilityChange();
+            emitZoomChange();
+            await emitLifecycle(options, createOptions.onEvent, 'load-complete', normalized, version, startedAt);
+            return session;
+        },
+        async destroy(reason = 'component-unmount') {
+            await destroyCurrent(reason);
+            documentActions.destroyDocumentFeatures();
+            zoomController.destroy();
+        },
+        updateOptions(nextOptions) {
+            options = {
+                ...options,
+                ...nextOptions,
+            };
+        },
+        getCapabilities(extension) {
+            return getCapabilitiesForExtension(extension);
+        },
+        getRenderer(extension) {
+            return registry.getByExtension(extension || (currentSource === null || currentSource === void 0 ? void 0 : currentSource.extension) || '');
+        },
+        getSource() {
+            return currentSource;
+        },
+        registerExportAdapter(adapter) {
+            applyFileViewerRenderSurfaceState(renderSurfaceState, { exportAdapter: adapter });
+        },
+        getExportAdapter() {
+            return renderSurfaceState.exportAdapter;
+        },
+        async download(downloadOptions = {}) {
+            const source = createFileViewerOriginalSourceStateFromNormalizedSource(currentSource);
+            await executeFileViewerDownloadOperation({
+                source,
+                filename: downloadOptions.filename || resolveFileViewerOperationFilename({
+                    source,
+                    fallback: DEFAULT_FILE_VIEWER_DOWNLOAD_FILENAME,
+                }),
+                beforeOperation: runBeforeViewerOperation,
+            });
+        },
+        async exportHtml(exportOptions = {}) {
+            return executeFileViewerExportHtmlOperation({
+                source: container,
+                adapter: renderSurfaceState.exportAdapter,
+                download: exportOptions.download,
+                filename: exportOptions.filename || resolveFileViewerOperationFilename({
+                    filename: resolveFileViewerDisplayFilename(currentSource),
+                    fallback: DEFAULT_FILE_VIEWER_EXPORT_FILENAME,
+                }),
+                title: exportOptions.title || resolveFileViewerOperationFilename({
+                    filename: resolveFileViewerDisplayFilename(currentSource),
+                    fallback: DEFAULT_FILE_VIEWER_PREVIEW_TITLE,
+                }),
+                watermarkInlineStyle: getWatermarkInlineStyle(exportOptions.watermarkInlineStyle),
+                beforeOperation: runBeforeViewerOperation,
+            });
+        },
+        async print(printOptions = {}) {
+            await executeFileViewerPrintOperation({
+                source: container,
+                adapter: renderSurfaceState.exportAdapter,
+                autoPrint: printOptions.autoPrint,
+                openWindow: printOptions.openWindow,
+                printWindow: printOptions.printWindow,
+                title: printOptions.title || resolveFileViewerOperationFilename({
+                    filename: resolveFileViewerDisplayFilename(currentSource),
+                    fallback: DEFAULT_FILE_VIEWER_PREVIEW_TITLE,
+                }),
+                watermarkInlineStyle: getWatermarkInlineStyle(printOptions.watermarkInlineStyle),
+                printAvailable: getCapabilitiesForExtension().print,
+                beforeOperation: runBeforeViewerOperation,
+            });
+        },
+        async zoomIn() {
+            const state = await zoomController.zoomIn();
+            emitZoomChange(state);
+            return state;
+        },
+        async zoomOut() {
+            const state = await zoomController.zoomOut();
+            emitZoomChange(state);
+            return state;
+        },
+        async resetZoom() {
+            const state = await zoomController.resetZoom();
+            emitZoomChange(state);
+            return state;
+        },
+        getZoomState() {
+            return zoomController.getState();
+        },
+        search(query) {
+            return documentActions.searchDocument(query);
+        },
+        nextSearchResult() {
+            return documentActions.nextSearchResult();
+        },
+        previousSearchResult() {
+            return documentActions.previousSearchResult();
+        },
+        clearSearch() {
+            return documentActions.clearDocumentSearch();
+        },
+        getSearchState() {
+            return documentActions.getSearchState();
+        },
+        collectDocumentAnchors() {
+            return documentActions.collectDocumentAnchors({ notify: false });
+        },
+        getCurrentDocumentAnchor() {
+            return documentActions.getCurrentDocumentAnchor();
+        },
+        scrollToDocumentAnchor(anchor) {
+            return documentActions.scrollToLoadedAnchor(anchor);
+        },
+        scrollToLine(line) {
+            return documentActions.scrollToLine(line);
+        },
+        getDocumentTextChunks(textOptions) {
+            return documentActions.getDocumentTextChunks(textOptions);
+        },
+    };
+};

package/dist/viewerOperations.d.ts

@@ -0,0 +1,88 @@
+import type { FileViewerErrorMessageFormatter } from './state';
+import type { FileRenderExportAdapter, FileViewerDownloadOptions, FileViewerExportHtmlOptions, FileViewerOperationType, FileViewerPrintOptions, NormalizedFileViewerSource } from './types';
+export interface FileViewerOriginalSourceState {
+    buffer?: ArrayBuffer | null;
+    file?: File | Blob | null;
+    url?: string | null;
+    filename?: string | null;
+    mimeType?: string | null;
+}
+export type CreateFileViewerOriginalSourceStateInput = FileViewerOriginalSourceState;
+export declare const DEFAULT_FILE_VIEWER_PREVIEW_TITLE = "file-viewer-preview";
+export declare const DEFAULT_FILE_VIEWER_EXPORT_FILENAME = "preview";
+export declare const DEFAULT_FILE_VIEWER_DOWNLOAD_FILENAME = "preview.bin";
+export interface ResolveFileViewerOperationFilenameInput {
+    filename?: string | null;
+    source?: FileViewerOriginalSourceState | null;
+    fallback?: string;
+}
+export interface FileViewerOperationExecutorBase {
+    beforeOperation?: (operation: FileViewerOperationType) => boolean | Promise<boolean>;
+}
+export interface ExecuteFileViewerDownloadOperationInput extends FileViewerOperationExecutorBase, FileViewerDownloadOptions {
+    source: FileViewerOriginalSourceState;
+    throwOnMissingSource?: boolean;
+}
+export interface ExecuteFileViewerExportHtmlOperationInput extends FileViewerOperationExecutorBase, FileViewerExportHtmlOptions {
+    source: HTMLElement | null | undefined;
+    adapter?: FileRenderExportAdapter | null;
+}
+export interface ExecuteFileViewerPrintOperationInput extends FileViewerOperationExecutorBase, FileViewerPrintOptions {
+    source: HTMLElement | null | undefined;
+    adapter?: FileRenderExportAdapter | null;
+    printAvailable?: boolean;
+}
+export type FileViewerFileOperationType = Extract<FileViewerOperationType, 'download' | 'export-html' | 'print'>;
+export interface FileViewerOperationActionErrorContext {
+    operation: FileViewerFileOperationType;
+    error: unknown;
+}
+export type FileViewerOperationActionErrorFormatter = FileViewerErrorMessageFormatter;
+export type FileViewerOperationActionErrorPrefixes = Partial<Record<FileViewerFileOperationType, string>>;
+export declare const FILE_VIEWER_OPERATION_ACTION_ERROR_PREFIXES: {
+    readonly download: "下载失败";
+    readonly print: "打印失败";
+    readonly 'export-html': "导出 HTML 失败";
+};
+export interface ResolveFileViewerOperationActionErrorMessageInput {
+    context: FileViewerOperationActionErrorContext;
+    formatErrorMessage: FileViewerOperationActionErrorFormatter;
+    prefixes?: FileViewerOperationActionErrorPrefixes;
+}
+export interface CreateFileViewerOperationActionHandlersInput extends FileViewerOperationExecutorBase {
+    getBuffer?: () => ArrayBuffer | null | undefined;
+    getFile?: () => File | Blob | null | undefined;
+    getUrl?: () => string | null | undefined;
+    getFilename: () => string | null | undefined;
+    getMimeType?: () => string | null | undefined;
+    getRenderedSource: () => HTMLElement | null | undefined;
+    getAdapter?: () => FileRenderExportAdapter | null | undefined;
+    getWatermarkInlineStyle?: () => string | null | undefined;
+    getPrintAvailable?: () => boolean | undefined;
+    onError?: (context: FileViewerOperationActionErrorContext) => void;
+    formatErrorMessage?: FileViewerOperationActionErrorFormatter;
+    errorPrefixes?: FileViewerOperationActionErrorPrefixes;
+    onErrorMessage?: (message: string, context: FileViewerOperationActionErrorContext) => void;
+}
+export interface FileViewerOperationActionHandlers {
+    downloadOriginalFile(): Promise<boolean | undefined>;
+    exportRenderedHtml(): Promise<string | undefined>;
+    printRenderedHtml(): Promise<boolean | undefined>;
+}
+export interface FileViewerPublicOperationActionHandlers {
+    downloadOriginalFile(): Promise<void>;
+    exportRenderedHtml(): Promise<void>;
+    printRenderedHtml(): Promise<void>;
+}
+export declare const createFileViewerOriginalSourceState: ({ buffer, file, url, filename, mimeType, }?: CreateFileViewerOriginalSourceStateInput) => FileViewerOriginalSourceState;
+export declare const resolveFileViewerDisplayFilename: (source?: Pick<NormalizedFileViewerSource, "filename"> | null, fallback?: string) => string;
+export declare const createFileViewerOriginalSourceStateFromNormalizedSource: (source?: NormalizedFileViewerSource | null, fallbackFilename?: string) => FileViewerOriginalSourceState;
+export declare const resolveFileViewerOriginalFilename: (source: FileViewerOriginalSourceState, fallback?: string) => string;
+export declare const resolveFileViewerOperationFilename: ({ filename, source, fallback, }: ResolveFileViewerOperationFilenameInput) => string;
+export declare const resolveFileViewerOperationActionErrorMessage: ({ context, formatErrorMessage, prefixes, }: ResolveFileViewerOperationActionErrorMessageInput) => string;
+export declare const hasFileViewerOriginalSource: (source: FileViewerOriginalSourceState) => boolean;
+export declare const executeFileViewerDownloadOperation: ({ source, filename, beforeOperation, throwOnMissingSource, }: ExecuteFileViewerDownloadOperationInput) => Promise<boolean>;
+export declare const executeFileViewerExportHtmlOperation: ({ download, filename, beforeOperation, ...input }: ExecuteFileViewerExportHtmlOperationInput) => Promise<string>;
+export declare const executeFileViewerPrintOperation: ({ autoPrint, beforeOperation, openWindow, printAvailable, printWindow, ...input }: ExecuteFileViewerPrintOperationInput) => Promise<boolean>;
+export declare const createFileViewerOperationActionHandlers: ({ getBuffer, getFile, getUrl, getFilename, getMimeType, getRenderedSource, getAdapter, getWatermarkInlineStyle, getPrintAvailable, beforeOperation, errorPrefixes, formatErrorMessage, onError, onErrorMessage, }: CreateFileViewerOperationActionHandlersInput) => FileViewerOperationActionHandlers;
+export declare const createFileViewerPublicOperationActionHandlers: (input: CreateFileViewerOperationActionHandlersInput) => FileViewerPublicOperationActionHandlers;

package/dist/viewerOperations.js

@@ -0,0 +1,242 @@
+import { buildFileViewerRenderedHtmlDocument, triggerFileViewerBlobDownload, triggerFileViewerUrlDownload, waitForFileViewerPrintWindowReady, } from './export.js';
+import { DEFAULT_FILE_VIEWER_SOURCE_FILENAME } from './source.js';
+export const DEFAULT_FILE_VIEWER_PREVIEW_TITLE = 'file-viewer-preview';
+export const DEFAULT_FILE_VIEWER_EXPORT_FILENAME = 'preview';
+export const DEFAULT_FILE_VIEWER_DOWNLOAD_FILENAME = DEFAULT_FILE_VIEWER_SOURCE_FILENAME;
+export const FILE_VIEWER_OPERATION_ACTION_ERROR_PREFIXES = {
+    download: '下载失败',
+    print: '打印失败',
+    'export-html': '导出 HTML 失败',
+};
+const getBlobFilename = (file) => {
+    return file && 'name' in file && typeof file.name === 'string' ? file.name : '';
+};
+const getBlobMimeType = (file) => {
+    return file && typeof file.type === 'string' ? file.type : '';
+};
+export const createFileViewerOriginalSourceState = ({ buffer = null, file = null, url = null, filename = null, mimeType = null, } = {}) => {
+    return {
+        buffer,
+        file,
+        url,
+        filename,
+        mimeType: mimeType || getBlobMimeType(file) || null,
+    };
+};
+export const resolveFileViewerDisplayFilename = (source, fallback = DEFAULT_FILE_VIEWER_EXPORT_FILENAME) => {
+    return (source === null || source === void 0 ? void 0 : source.filename) || fallback;
+};
+export const createFileViewerOriginalSourceStateFromNormalizedSource = (source, fallbackFilename = DEFAULT_FILE_VIEWER_EXPORT_FILENAME) => {
+    var _a;
+    return createFileViewerOriginalSourceState({
+        buffer: source === null || source === void 0 ? void 0 : source.buffer,
+        file: source === null || source === void 0 ? void 0 : source.file,
+        url: source === null || source === void 0 ? void 0 : source.url,
+        filename: resolveFileViewerDisplayFilename(source, fallbackFilename),
+        mimeType: (_a = source === null || source === void 0 ? void 0 : source.file) === null || _a === void 0 ? void 0 : _a.type,
+    });
+};
+export const resolveFileViewerOriginalFilename = (source, fallback = 'preview') => {
+    return source.filename || getBlobFilename(source.file) || fallback;
+};
+export const resolveFileViewerOperationFilename = ({ filename, source, fallback = DEFAULT_FILE_VIEWER_PREVIEW_TITLE, }) => {
+    return filename || (source ? resolveFileViewerOriginalFilename(source, '') : '') || fallback;
+};
+export const resolveFileViewerOperationActionErrorMessage = ({ context, formatErrorMessage, prefixes, }) => {
+    var _a;
+    return formatErrorMessage((_a = prefixes === null || prefixes === void 0 ? void 0 : prefixes[context.operation]) !== null && _a !== void 0 ? _a : FILE_VIEWER_OPERATION_ACTION_ERROR_PREFIXES[context.operation], context.error);
+};
+export const hasFileViewerOriginalSource = (source) => {
+    return !!source.buffer || !!source.file || !!source.url;
+};
+const runBeforeOperation = async (beforeOperation, operation) => {
+    if (!beforeOperation) {
+        return true;
+    }
+    return await beforeOperation(operation);
+};
+const buildRenderedHtmlDocumentFromOperation = async (mode, { source, title, filename, adapter = null, watermarkInlineStyle, }) => {
+    if (!source) {
+        throw new Error('当前没有可导出的预览内容');
+    }
+    return buildFileViewerRenderedHtmlDocument({
+        source,
+        mode,
+        title: resolveFileViewerOperationFilename({
+            filename: title || filename,
+            fallback: DEFAULT_FILE_VIEWER_PREVIEW_TITLE,
+        }),
+        adapter,
+        watermarkInlineStyle,
+    });
+};
+export const executeFileViewerDownloadOperation = async ({ source, filename, beforeOperation, throwOnMissingSource = true, }) => {
+    var _a;
+    if (!hasFileViewerOriginalSource(source)) {
+        if (throwOnMissingSource) {
+            throw new Error('当前没有可下载的源文件');
+        }
+        return false;
+    }
+    if (!await runBeforeOperation(beforeOperation, 'download')) {
+        return false;
+    }
+    const resolvedFilename = resolveFileViewerOperationFilename({
+        filename,
+        source,
+        fallback: DEFAULT_FILE_VIEWER_DOWNLOAD_FILENAME,
+    });
+    if (source.buffer) {
+        triggerFileViewerBlobDownload(new Blob([source.buffer], { type: source.mimeType || ((_a = source.file) === null || _a === void 0 ? void 0 : _a.type) || 'application/octet-stream' }), resolvedFilename);
+        return true;
+    }
+    if (source.file) {
+        triggerFileViewerBlobDownload(source.file, resolvedFilename);
+        return true;
+    }
+    triggerFileViewerUrlDownload(source.url, resolvedFilename);
+    return true;
+};
+export const executeFileViewerExportHtmlOperation = async ({ download = true, filename, beforeOperation, ...input }) => {
+    if (!await runBeforeOperation(beforeOperation, 'export-html')) {
+        return '';
+    }
+    const html = await buildRenderedHtmlDocumentFromOperation('export', {
+        ...input,
+        filename,
+    });
+    if (download !== false) {
+        const baseName = resolveFileViewerOperationFilename({
+            filename: filename || input.title,
+            fallback: DEFAULT_FILE_VIEWER_EXPORT_FILENAME,
+        });
+        triggerFileViewerBlobDownload(new Blob([html], { type: 'text/html;charset=utf-8' }), `${baseName}.rendered.html`);
+    }
+    return html;
+};
+export const executeFileViewerPrintOperation = async ({ autoPrint = true, beforeOperation, openWindow, printAvailable = true, printWindow, ...input }) => {
+    if (!printAvailable) {
+        throw new Error('当前文件类型不支持完整打印，请下载原文件后在本地应用中打印');
+    }
+    if (!await runBeforeOperation(beforeOperation, 'print')) {
+        return false;
+    }
+    const html = await buildRenderedHtmlDocumentFromOperation('print', input);
+    const targetWindow = printWindow ||
+        (openWindow === null || openWindow === void 0 ? void 0 : openWindow()) ||
+        (typeof window !== 'undefined' ? window.open('', '_blank') : null);
+    if (!targetWindow) {
+        throw new Error('浏览器拦截了打印窗口');
+    }
+    targetWindow.document.open();
+    targetWindow.document.write(html);
+    targetWindow.document.close();
+    targetWindow.focus();
+    await waitForFileViewerPrintWindowReady(targetWindow);
+    if (autoPrint !== false) {
+        targetWindow.print();
+    }
+    return true;
+};
+const handleFileViewerOperationActionError = (operation, error, { errorPrefixes, formatErrorMessage, onError, onErrorMessage, }) => {
+    const context = { operation, error };
+    onError === null || onError === void 0 ? void 0 : onError(context);
+    if (formatErrorMessage && onErrorMessage) {
+        onErrorMessage(resolveFileViewerOperationActionErrorMessage({
+            context,
+            formatErrorMessage,
+            prefixes: errorPrefixes,
+        }), context);
+    }
+};
+export const createFileViewerOperationActionHandlers = ({ getBuffer, getFile, getUrl, getFilename, getMimeType, getRenderedSource, getAdapter, getWatermarkInlineStyle, getPrintAvailable, beforeOperation, errorPrefixes, formatErrorMessage, onError, onErrorMessage, }) => {
+    const getOriginalSource = () => {
+        var _a, _b, _c, _d;
+        const file = (_a = getFile === null || getFile === void 0 ? void 0 : getFile()) !== null && _a !== void 0 ? _a : null;
+        return createFileViewerOriginalSourceState({
+            buffer: (_b = getBuffer === null || getBuffer === void 0 ? void 0 : getBuffer()) !== null && _b !== void 0 ? _b : null,
+            file,
+            url: (_c = getUrl === null || getUrl === void 0 ? void 0 : getUrl()) !== null && _c !== void 0 ? _c : null,
+            filename: getFilename(),
+            mimeType: (_d = getMimeType === null || getMimeType === void 0 ? void 0 : getMimeType()) !== null && _d !== void 0 ? _d : getBlobMimeType(file),
+        });
+    };
+    const getRenderedOperationInput = () => {
+        var _a, _b;
+        const filename = getFilename() || undefined;
+        return {
+            source: getRenderedSource(),
+            adapter: (_a = getAdapter === null || getAdapter === void 0 ? void 0 : getAdapter()) !== null && _a !== void 0 ? _a : null,
+            title: filename,
+            filename,
+            watermarkInlineStyle: (_b = getWatermarkInlineStyle === null || getWatermarkInlineStyle === void 0 ? void 0 : getWatermarkInlineStyle()) !== null && _b !== void 0 ? _b : undefined,
+            beforeOperation,
+        };
+    };
+    return {
+        async downloadOriginalFile() {
+            try {
+                return await executeFileViewerDownloadOperation({
+                    source: getOriginalSource(),
+                    beforeOperation,
+                    throwOnMissingSource: false,
+                });
+            }
+            catch (error) {
+                handleFileViewerOperationActionError('download', error, {
+                    errorPrefixes,
+                    formatErrorMessage,
+                    onError,
+                    onErrorMessage,
+                });
+                return undefined;
+            }
+        },
+        async exportRenderedHtml() {
+            try {
+                return await executeFileViewerExportHtmlOperation(getRenderedOperationInput());
+            }
+            catch (error) {
+                handleFileViewerOperationActionError('export-html', error, {
+                    errorPrefixes,
+                    formatErrorMessage,
+                    onError,
+                    onErrorMessage,
+                });
+                return undefined;
+            }
+        },
+        async printRenderedHtml() {
+            var _a;
+            try {
+                return await executeFileViewerPrintOperation({
+                    ...getRenderedOperationInput(),
+                    printAvailable: (_a = getPrintAvailable === null || getPrintAvailable === void 0 ? void 0 : getPrintAvailable()) !== null && _a !== void 0 ? _a : true,
+                });
+            }
+            catch (error) {
+                handleFileViewerOperationActionError('print', error, {
+                    errorPrefixes,
+                    formatErrorMessage,
+                    onError,
+                    onErrorMessage,
+                });
+                return undefined;
+            }
+        },
+    };
+};
+export const createFileViewerPublicOperationActionHandlers = (input) => {
+    const actions = createFileViewerOperationActionHandlers(input);
+    return {
+        async downloadOriginalFile() {
+            await actions.downloadOriginalFile();
+        },
+        async exportRenderedHtml() {
+            await actions.exportRenderedHtml();
+        },
+        async printRenderedHtml() {
+            await actions.printRenderedHtml();
+        },
+    };
+};

package/dist/watermark.d.ts

@@ -0,0 +1,15 @@
+import type { FileViewerWatermarkOptions } from './types';
+export type FileViewerWatermarkStyle = Record<string, string> & {
+    backgroundImage: string;
+};
+export interface FileViewerWatermarkPresentationState {
+    normalizedWatermark: FileViewerWatermarkOptions | null;
+    watermarkStyle: FileViewerWatermarkStyle | undefined;
+    watermarkInlineStyle: string;
+}
+export declare const normalizeFileViewerWatermark: (watermark?: boolean | FileViewerWatermarkOptions) => FileViewerWatermarkOptions | null;
+export declare const buildFileViewerWatermarkSvg: (watermark: FileViewerWatermarkOptions) => string;
+export declare const buildFileViewerWatermarkBackgroundImage: (watermark?: boolean | FileViewerWatermarkOptions) => string;
+export declare const buildFileViewerWatermarkStyle: (watermark?: boolean | FileViewerWatermarkOptions) => FileViewerWatermarkStyle | undefined;
+export declare const buildFileViewerWatermarkInlineStyle: (watermark?: boolean | FileViewerWatermarkOptions) => string;
+export declare const resolveFileViewerWatermarkPresentationState: (watermark?: boolean | FileViewerWatermarkOptions) => FileViewerWatermarkPresentationState;