@file-viewer/core 2.0.0

package/dist/operations.js

@@ -0,0 +1,485 @@
+import { resolvePrintAvailability } from './capabilities.js';
+import { getExtension, normalizeFilename } from './source.js';
+import { createFileViewerOriginalSourceState, hasFileViewerOriginalSource, } from './viewerOperations.js';
+export const FILE_VIEWER_LIFECYCLE_HOOKS = {
+    'load-start': 'onLoadStart',
+    'load-complete': 'onLoadComplete',
+    'unload-start': 'onUnloadStart',
+    'unload-complete': 'onUnloadComplete',
+};
+export const FILE_VIEWER_OPERATION_LABELS = {
+    download: '下载原始文件',
+    print: '打印完整渲染内容',
+    'export-html': '导出渲染 HTML',
+    'zoom-in': '放大预览',
+    'zoom-out': '缩小预览',
+    'zoom-reset': '还原预览比例',
+};
+export const FILE_VIEWER_BEFORE_OPERATION_ERROR_PREFIX = '操作前置校验失败';
+export const FILE_VIEWER_LIFECYCLE_HOOK_ERROR_MESSAGE_PREFIX = 'FileViewer';
+export const buildFileViewerLifecycleContext = ({ phase, version, source, filename, file, url, size, bufferSize, startedAt, duration, timestamp, reason, }) => {
+    var _a;
+    const resolvedFilename = normalizeFilename((file === null || file === void 0 ? void 0 : file.name) || filename || url || '');
+    const now = timestamp !== null && timestamp !== void 0 ? timestamp : Date.now();
+    return {
+        phase,
+        type: getExtension(resolvedFilename),
+        filename: resolvedFilename,
+        source,
+        url,
+        file: file || undefined,
+        size: (_a = size !== null && size !== void 0 ? size : file === null || file === void 0 ? void 0 : file.size) !== null && _a !== void 0 ? _a : bufferSize,
+        version,
+        timestamp: now,
+        duration: duration !== null && duration !== void 0 ? duration : (phase === 'load-complete' && typeof startedAt === 'number' ? now - startedAt : undefined),
+        reason,
+    };
+};
+export const buildFileViewerLifecycleContextFromNormalizedSource = ({ phase, source, version, startedAt, timestamp, reason, }) => {
+    const now = timestamp !== null && timestamp !== void 0 ? timestamp : Date.now();
+    return buildFileViewerLifecycleContext({
+        phase,
+        filename: source.filename,
+        source: source.kind,
+        url: source.url,
+        file: typeof File !== 'undefined' && source.file instanceof File ? source.file : undefined,
+        size: source.size,
+        version,
+        timestamp: now,
+        duration: phase.endsWith('complete') && typeof startedAt === 'number' ? now - startedAt : undefined,
+        reason,
+    });
+};
+export const resolveFileViewerLifecycleFallbackSource = ({ file, url, } = {}) => {
+    if (file) {
+        return { source: 'file' };
+    }
+    if (url) {
+        return { source: 'url', sourceUrl: url };
+    }
+    return { source: 'empty' };
+};
+export const createFileViewerLifecycleStateController = () => {
+    let activeDocumentContext = null;
+    const loadStartedAt = new Map();
+    return {
+        markLoadStarted(version, timestamp = Date.now()) {
+            loadStartedAt.set(version, timestamp);
+        },
+        clearLoadStarted(version) {
+            loadStartedAt.delete(version);
+        },
+        getLoadStartedAt(version) {
+            return loadStartedAt.get(version);
+        },
+        getActiveDocumentContext() {
+            return activeDocumentContext;
+        },
+        setActiveDocumentContext(context) {
+            activeDocumentContext = context;
+        },
+        clearActiveDocumentContext() {
+            activeDocumentContext = null;
+        },
+        buildActiveUnloadContext(phase, context, reason = 'replace', timestamp = Date.now()) {
+            if (!context) {
+                return null;
+            }
+            return {
+                ...context,
+                phase,
+                timestamp,
+                reason,
+            };
+        },
+    };
+};
+export const buildFileViewerOperationContext = (operation, lifecycleContext, timestamp = Date.now()) => {
+    const { phase: _phase, ...context } = lifecycleContext;
+    return {
+        ...context,
+        operation,
+        label: FILE_VIEWER_OPERATION_LABELS[operation],
+        timestamp,
+    };
+};
+export const buildFileViewerOperationContextFromLifecycleState = ({ operation, lifecycleState, version, filename, bufferSize, currentFile, fallbackFile, fallbackUrl, timestamp, lifecycleTimestamp, }) => {
+    const activeContext = lifecycleState.getActiveDocumentContext();
+    const fallbackSource = resolveFileViewerLifecycleFallbackSource({
+        file: fallbackFile,
+        url: fallbackUrl,
+    });
+    const baseContext = activeContext || buildFileViewerLifecycleContext({
+        phase: 'load-complete',
+        version,
+        source: fallbackSource.source,
+        file: currentFile,
+        filename,
+        url: fallbackSource.sourceUrl,
+        bufferSize,
+        startedAt: lifecycleState.getLoadStartedAt(version),
+        timestamp: lifecycleTimestamp,
+    });
+    return buildFileViewerOperationContext(operation, baseContext, timestamp);
+};
+export const emitFileViewerComponentLifecycleEvent = (emit, context) => {
+    if (context.phase === 'load-start') {
+        emit('load-start', context);
+        return;
+    }
+    if (context.phase === 'load-complete') {
+        emit('load-complete', context);
+        return;
+    }
+    if (context.phase === 'unload-start') {
+        emit('unload-start', context);
+        return;
+    }
+    emit('unload-complete', context);
+};
+export const resolveFileViewerBeforeOperationErrorMessage = ({ error, formatErrorMessage, prefix = FILE_VIEWER_BEFORE_OPERATION_ERROR_PREFIX, }) => {
+    return formatErrorMessage(prefix, error);
+};
+export const resolveFileViewerLifecycleHookErrorMessage = ({ context, prefix = FILE_VIEWER_LIFECYCLE_HOOK_ERROR_MESSAGE_PREFIX, }) => {
+    return `${prefix} ${context.phase} hook failed`;
+};
+export const DEFAULT_FILE_VIEWER_LIFECYCLE_HOOK_ERROR_LOGGER = (message, error) => {
+    if (typeof console !== 'undefined' && typeof console.error === 'function') {
+        console.error(message, error);
+    }
+};
+export const reportFileViewerLifecycleHookError = ({ error, context, onLogError = DEFAULT_FILE_VIEWER_LIFECYCLE_HOOK_ERROR_LOGGER, prefix, }) => {
+    const message = resolveFileViewerLifecycleHookErrorMessage({ context, prefix });
+    onLogError === null || onLogError === void 0 ? void 0 : onLogError(message, error, context);
+    return message;
+};
+export const DEFAULT_FILE_VIEWER_OPERATION_ERROR_LOGGER = error => {
+    if (typeof console !== 'undefined' && typeof console.error === 'function') {
+        console.error(error);
+    }
+};
+export const reportFileViewerOperationError = ({ error, context, onLogError = DEFAULT_FILE_VIEWER_OPERATION_ERROR_LOGGER, }) => {
+    onLogError === null || onLogError === void 0 ? void 0 : onLogError(error, context);
+    return error;
+};
+export const runFileViewerActiveUnloadStart = ({ lifecycleState, reason = 'replace', onLifecycle, }) => {
+    const context = lifecycleState.getActiveDocumentContext();
+    const unloadContext = lifecycleState.buildActiveUnloadContext('unload-start', context, reason);
+    if (unloadContext) {
+        onLifecycle === null || onLifecycle === void 0 ? void 0 : onLifecycle(unloadContext);
+    }
+    return {
+        reason,
+        context,
+        unloadContext,
+    };
+};
+export const runFileViewerActiveUnloadComplete = ({ lifecycleState, context = null, reason = 'replace', onLifecycle, }) => {
+    const unloadContext = lifecycleState.buildActiveUnloadContext('unload-complete', context, reason);
+    if (unloadContext) {
+        onLifecycle === null || onLifecycle === void 0 ? void 0 : onLifecycle(unloadContext);
+    }
+    return {
+        reason,
+        context,
+        unloadContext,
+    };
+};
+export const getFileViewerLifecycleHookName = (phase) => {
+    return FILE_VIEWER_LIFECYCLE_HOOKS[phase];
+};
+export const runFileViewerLifecycleHook = async (context, hooks, onError) => {
+    const hook = hooks === null || hooks === void 0 ? void 0 : hooks[getFileViewerLifecycleHookName(context.phase)];
+    if (!hook) {
+        return;
+    }
+    try {
+        await hook(context);
+    }
+    catch (error) {
+        onError === null || onError === void 0 ? void 0 : onError(error, context);
+    }
+};
+export const getFileViewerBeforeOperationHooks = (options, operation) => {
+    const toolbar = options === null || options === void 0 ? void 0 : options.toolbar;
+    if (!toolbar || typeof toolbar !== 'object') {
+        return [options === null || options === void 0 ? void 0 : options.beforeOperation];
+    }
+    const specificHook = operation === 'download'
+        ? toolbar.beforeDownload
+        : operation === 'print'
+            ? toolbar.beforePrint
+            : operation === 'export-html'
+                ? toolbar.beforeExportHtml
+                : undefined;
+    return [options === null || options === void 0 ? void 0 : options.beforeOperation, toolbar.beforeOperation, specificHook];
+};
+export const runFileViewerBeforeOperation = async ({ context, options, onBefore, onCancel, onError, }) => {
+    onBefore === null || onBefore === void 0 ? void 0 : onBefore(context);
+    try {
+        for (const hook of getFileViewerBeforeOperationHooks(options, context.operation)) {
+            if (!hook) {
+                continue;
+            }
+            const result = await hook(context);
+            if (result === false) {
+                onCancel === null || onCancel === void 0 ? void 0 : onCancel(context);
+                return false;
+            }
+        }
+    }
+    catch (error) {
+        onError === null || onError === void 0 ? void 0 : onError(error, context);
+        onCancel === null || onCancel === void 0 ? void 0 : onCancel(context);
+        return false;
+    }
+    return true;
+};
+export const serializeFileViewerContext = (context) => {
+    const { file: _file, ...serializable } = context;
+    return {
+        ...serializable,
+        hasFile: !!context.file,
+    };
+};
+export const dispatchFileViewerLifecycleEvent = ({ context, hooks, onChange, onError, }) => {
+    onChange === null || onChange === void 0 ? void 0 : onChange(context.phase, context);
+    void runFileViewerLifecycleHook(context, hooks, onError);
+    return true;
+};
+export const dispatchFileViewerOperationContextEvent = ({ event, context, onChange, }) => {
+    onChange === null || onChange === void 0 ? void 0 : onChange(context);
+    return true;
+};
+export const createFileViewerLifecycleActions = ({ lifecycleState, getOptions = () => undefined, onLifecycleChange, onLifecycleError, onOperationBefore, onOperationCancel, onOperationError, }) => {
+    const notifyLifecycle = (context) => {
+        var _a;
+        return dispatchFileViewerLifecycleEvent({
+            context,
+            hooks: (_a = getOptions()) === null || _a === void 0 ? void 0 : _a.hooks,
+            onChange: onLifecycleChange,
+            onError: onLifecycleError,
+        });
+    };
+    return {
+        notifyLifecycle,
+        notifyActiveUnloadStart(reason = 'replace') {
+            return runFileViewerActiveUnloadStart({
+                lifecycleState,
+                reason,
+                onLifecycle: notifyLifecycle,
+            }).context;
+        },
+        notifyActiveUnloadComplete(context, reason = 'replace') {
+            return runFileViewerActiveUnloadComplete({
+                lifecycleState,
+                context,
+                reason,
+                onLifecycle: notifyLifecycle,
+            });
+        },
+        runBeforeOperation(context) {
+            return runFileViewerBeforeOperation({
+                context,
+                options: getOptions(),
+                onBefore: nextContext => {
+                    dispatchFileViewerOperationContextEvent({
+                        event: 'operation-before',
+                        context: nextContext,
+                        onChange: onOperationBefore,
+                    });
+                },
+                onCancel: nextContext => {
+                    dispatchFileViewerOperationContextEvent({
+                        event: 'operation-cancel',
+                        context: nextContext,
+                        onChange: onOperationCancel,
+                    });
+                },
+                onError: onOperationError,
+            });
+        },
+    };
+};
+export const dispatchFileViewerOperationAvailabilityChange = ({ availability, onChange, }) => {
+    const payload = cloneFileViewerOperationAvailability(availability);
+    onChange === null || onChange === void 0 ? void 0 : onChange(payload);
+    return true;
+};
+export const dispatchFileViewerZoomChange = ({ state, onChange, }) => {
+    onChange === null || onChange === void 0 ? void 0 : onChange(state);
+    return true;
+};
+export const createFileViewerToolbarActions = ({ getOperationAvailability, getToolbarDisabled = () => false, getZoomState, onOperationAvailabilityChange, onZoomChange, }) => {
+    return {
+        notifyOperationAvailabilityChange(availability = getOperationAvailability()) {
+            return dispatchFileViewerOperationAvailabilityChange({
+                availability,
+                onChange: onOperationAvailabilityChange,
+            });
+        },
+        notifyZoomChange(state = getZoomState()) {
+            return dispatchFileViewerZoomChange({
+                state,
+                onChange: onZoomChange,
+            });
+        },
+        isZoomButtonDisabled(action) {
+            return isFileViewerZoomButtonDisabled({
+                action,
+                availability: getOperationAvailability(),
+                toolbarDisabled: getToolbarDisabled(),
+                zoomState: getZoomState(),
+            });
+        },
+    };
+};
+export const createFileViewerPublicApi = ({ getOperationAvailability, ...api }) => {
+    return {
+        ...api,
+        getOperationAvailability: () => cloneFileViewerOperationAvailability(getOperationAvailability()),
+    };
+};
+export const createFileViewerToolbarZoomSyncSnapshot = (state) => [
+    state.scale,
+    state.label,
+    state.canZoomIn,
+    state.canZoomOut,
+    state.canReset,
+];
+export const runFileViewerToolbarAvailabilitySync = ({ toolbarActions, availability, }) => {
+    return toolbarActions.notifyOperationAvailabilityChange(availability);
+};
+export const runFileViewerToolbarZoomSync = ({ toolbarActions, state, }) => {
+    return toolbarActions.notifyZoomChange(state);
+};
+export const createFileViewerToolbarControllerActionHandlers = ({ getAdapter = () => null, getBuffer = () => null, getExtension, getFile = () => null, getHasError = () => false, getLoading = () => false, getOptions, getSourceUrl = () => null, getToolbar, getRenderedReady, getZoomState, zoomSyncState, onOperationAvailabilityChange, onZoomChange, }) => {
+    let currentToolbarState = null;
+    const resolveToolbarState = () => {
+        var _a, _b, _c, _d;
+        currentToolbarState = resolveFileViewerToolbarState({
+            extension: getExtension(),
+            source: createFileViewerOriginalSourceState({
+                buffer: (_a = getBuffer()) !== null && _a !== void 0 ? _a : null,
+                file: (_b = getFile()) !== null && _b !== void 0 ? _b : null,
+                url: (_c = getSourceUrl()) !== null && _c !== void 0 ? _c : null,
+            }),
+            renderedReady: getRenderedReady(),
+            hasError: getHasError(),
+            adapter: (_d = getAdapter()) !== null && _d !== void 0 ? _d : null,
+            zoomState: getZoomState(),
+            toolbar: getToolbar(),
+            options: getOptions === null || getOptions === void 0 ? void 0 : getOptions(),
+            loading: getLoading(),
+        });
+        return currentToolbarState;
+    };
+    const getResolvedToolbarState = () => currentToolbarState !== null && currentToolbarState !== void 0 ? currentToolbarState : resolveToolbarState();
+    const toolbarActions = createFileViewerToolbarActions({
+        getOperationAvailability: () => getResolvedToolbarState().operationAvailability,
+        getToolbarDisabled: () => getResolvedToolbarState().toolbarDisabled,
+        getZoomState,
+        onOperationAvailabilityChange,
+        onZoomChange,
+    });
+    return {
+        resolveToolbarState,
+        createZoomSyncSnapshot: () => createFileViewerToolbarZoomSyncSnapshot(zoomSyncState !== null && zoomSyncState !== void 0 ? zoomSyncState : getZoomState()),
+        syncOperationAvailability: availability => runFileViewerToolbarAvailabilitySync({
+            toolbarActions,
+            availability,
+        }),
+        syncZoomChange: state => runFileViewerToolbarZoomSync({
+            toolbarActions,
+            state,
+        }),
+        isZoomButtonDisabled: toolbarActions.isZoomButtonDisabled,
+    };
+};
+export const normalizeFileViewerToolbar = (options) => {
+    const toolbar = options === null || options === void 0 ? void 0 : options.toolbar;
+    if (toolbar === false) {
+        return {
+            download: false,
+            print: false,
+            exportHtml: false,
+            zoom: false,
+        };
+    }
+    if (toolbar && typeof toolbar === 'object') {
+        return {
+            download: toolbar.download !== false,
+            print: toolbar.print !== false,
+            exportHtml: toolbar.exportHtml !== false,
+            zoom: toolbar.zoom !== false,
+        };
+    }
+    return {
+        download: true,
+        print: true,
+        exportHtml: true,
+        zoom: true,
+    };
+};
+export const resolveFileViewerOperationAvailability = ({ extension, hasOriginalSource, renderedReady, hasError = false, adapter, source, zoomState, }) => {
+    const hasRenderableOutput = renderedReady && !hasError;
+    const hasSource = hasOriginalSource !== null && hasOriginalSource !== void 0 ? hasOriginalSource : (source ? hasFileViewerOriginalSource(source) : false);
+    const zoomEnabled = hasRenderableOutput && (zoomState.canZoomIn || zoomState.canZoomOut || zoomState.canReset);
+    return {
+        download: hasSource,
+        print: hasRenderableOutput && resolvePrintAvailability(extension, adapter !== null && adapter !== void 0 ? adapter : null, renderedReady),
+        exportHtml: hasRenderableOutput && (adapter === null || adapter === void 0 ? void 0 : adapter.exportHtml) !== false,
+        zoom: zoomEnabled,
+        zoomIn: zoomEnabled && zoomState.canZoomIn,
+        zoomOut: zoomEnabled && zoomState.canZoomOut,
+        zoomReset: zoomEnabled && zoomState.canReset,
+    };
+};
+export const cloneFileViewerOperationAvailability = (availability) => ({
+    download: availability.download,
+    print: availability.print,
+    exportHtml: availability.exportHtml,
+    zoom: availability.zoom,
+    zoomIn: availability.zoomIn,
+    zoomOut: availability.zoomOut,
+    zoomReset: availability.zoomReset,
+});
+export const resolveVisibleFileViewerToolbar = (toolbar, availability) => {
+    return {
+        download: toolbar.download && availability.download,
+        print: toolbar.print && availability.print,
+        exportHtml: toolbar.exportHtml && availability.exportHtml,
+        zoom: toolbar.zoom && availability.zoom,
+    };
+};
+export const hasVisibleFileViewerToolbarActions = (toolbar) => {
+    return !!(toolbar.download || toolbar.print || toolbar.exportHtml || toolbar.zoom);
+};
+export const isFileViewerZoomButtonDisabled = ({ toolbarDisabled = false, availability, zoomState, action, }) => {
+    return toolbarDisabled || !availability.zoom || !zoomState[action];
+};
+export const isFileViewerToolbarDisabled = ({ loading = false, hasError = false, }) => {
+    return !!(loading || hasError);
+};
+export const resolveFileViewerToolbarState = ({ toolbar, options, loading = false, ...availabilityInput }) => {
+    const operationAvailability = resolveFileViewerOperationAvailability(availabilityInput);
+    const visibleToolbar = resolveVisibleFileViewerToolbar(toolbar, operationAvailability);
+    return {
+        operationAvailability,
+        visibleToolbar,
+        showToolbar: hasVisibleFileViewerToolbarActions(visibleToolbar),
+        toolbarPosition: resolveFileViewerToolbarPosition(options, availabilityInput.extension),
+        toolbarDisabled: isFileViewerToolbarDisabled({
+            loading,
+            hasError: availabilityInput.hasError,
+        }),
+    };
+};
+export const resolveFileViewerToolbarPosition = (options, extension) => {
+    const toolbar = options === null || options === void 0 ? void 0 : options.toolbar;
+    const position = toolbar && typeof toolbar === 'object' ? toolbar.position : 'auto';
+    if (position === 'top' || position === 'bottom-right') {
+        return position;
+    }
+    return extension === 'pdf' ? 'bottom-right' : 'top';
+};

package/dist/options.d.ts

@@ -0,0 +1,16 @@
+import type { FileViewerArchiveOptions, FileViewerCadOptions, FileViewerOptions, FileViewerThemeMode, FileViewerToolbarOptions } from './types';
+export type FileViewerSerializableToolbarOptions = Omit<FileViewerToolbarOptions, 'beforeOperation' | 'beforeDownload' | 'beforePrint' | 'beforeExportHtml'>;
+export type FileViewerSerializableCadOptions = Omit<FileViewerCadOptions, 'workerUrl'> & {
+    workerUrl?: string;
+};
+export interface FileViewerSerializableOptions extends Omit<FileViewerOptions, 'toolbar' | 'cad' | 'hooks' | 'beforeOperation'> {
+    toolbar?: boolean | FileViewerSerializableToolbarOptions;
+    archive?: FileViewerArchiveOptions;
+    cad?: FileViewerSerializableCadOptions;
+}
+export declare const normalizeFileViewerTheme: (theme: FileViewerThemeMode | undefined) => FileViewerThemeMode;
+export declare const sanitizeFileViewerOptions: (options?: FileViewerOptions | FileViewerSerializableOptions | null) => FileViewerSerializableOptions | undefined;
+export declare const serializeFileViewerOptions: (options?: FileViewerOptions | FileViewerSerializableOptions | null) => string | undefined;
+export declare const parseFileViewerOptions: (value: unknown) => FileViewerSerializableOptions | undefined;
+export declare const setFileViewerOptionsSearchParam: (searchParams: URLSearchParams, options?: FileViewerOptions | FileViewerSerializableOptions | null, key?: string) => void;
+export declare const getFileViewerOptionsSearchParam: (searchParams: URLSearchParams, key?: string) => FileViewerSerializableOptions | undefined;

package/dist/options.js

@@ -0,0 +1,92 @@
+const isRecord = (value) => {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+};
+const isUrlLike = (value) => {
+    return typeof URL !== 'undefined' && value instanceof URL;
+};
+const sanitizeJsonValue = (value) => {
+    if (value === undefined || typeof value === 'function' || typeof value === 'symbol') {
+        return undefined;
+    }
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : undefined;
+    }
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (isUrlLike(value)) {
+        return value.toString();
+    }
+    if (Array.isArray(value)) {
+        return value
+            .map(item => sanitizeJsonValue(item))
+            .filter((item) => item !== undefined);
+    }
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const output = {};
+    Object.entries(value).forEach(([key, nextValue]) => {
+        const sanitized = sanitizeJsonValue(nextValue);
+        if (sanitized !== undefined) {
+            output[key] = sanitized;
+        }
+    });
+    return Object.keys(output).length ? output : undefined;
+};
+const stripExecutionOnlyOptions = (value) => {
+    const { beforeOperation: _beforeOperation, hooks: _hooks, ...rest } = value;
+    if (isRecord(rest.toolbar)) {
+        const { beforeOperation: _toolbarBeforeOperation, beforeDownload: _beforeDownload, beforePrint: _beforePrint, beforeExportHtml: _beforeExportHtml, ...toolbar } = rest.toolbar;
+        rest.toolbar = toolbar;
+    }
+    return rest;
+};
+export const normalizeFileViewerTheme = (theme) => {
+    return theme === 'light' || theme === 'dark' || theme === 'system' ? theme : 'system';
+};
+export const sanitizeFileViewerOptions = (options) => {
+    if (!isRecord(options)) {
+        return undefined;
+    }
+    const sanitized = sanitizeJsonValue(stripExecutionOnlyOptions(options));
+    if (!isRecord(sanitized)) {
+        return undefined;
+    }
+    return sanitized;
+};
+export const serializeFileViewerOptions = (options) => {
+    const sanitized = sanitizeFileViewerOptions(options);
+    return sanitized ? JSON.stringify(sanitized) : undefined;
+};
+export const parseFileViewerOptions = (value) => {
+    if (!value) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        try {
+            return sanitizeFileViewerOptions(JSON.parse(value));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return sanitizeFileViewerOptions(value);
+};
+export const setFileViewerOptionsSearchParam = (searchParams, options, key = 'options') => {
+    const serialized = serializeFileViewerOptions(options);
+    if (!serialized) {
+        searchParams.delete(key);
+        return;
+    }
+    searchParams.set(key, serialized);
+};
+export const getFileViewerOptionsSearchParam = (searchParams, key = 'options') => {
+    return parseFileViewerOptions(searchParams.get(key));
+};

package/dist/presentation.d.ts

@@ -0,0 +1,14 @@
+import type { FileViewerFileRef, FileViewerOptions, FileViewerThemeMode, FileViewerToolbarOptions } from './types';
+export interface ResolveFileViewerPresentationStateInput {
+    filename?: string;
+    file?: FileViewerFileRef;
+    url?: string;
+    options?: FileViewerOptions;
+}
+export interface FileViewerPresentationState {
+    displayFilename: string;
+    extension: string;
+    toolbar: FileViewerToolbarOptions;
+    theme: FileViewerThemeMode;
+}
+export declare const resolveFileViewerPresentationState: ({ filename, file, url, options, }: ResolveFileViewerPresentationStateInput) => FileViewerPresentationState;

package/dist/presentation.js

@@ -0,0 +1,16 @@
+import { normalizeFileViewerToolbar } from './operations.js';
+import { normalizeFileViewerTheme } from './options.js';
+import { getExtension, resolveFileViewerSourceFilename } from './source.js';
+export const resolveFileViewerPresentationState = ({ filename, file, url, options, }) => {
+    const displayFilename = resolveFileViewerSourceFilename({
+        filename,
+        file,
+        url,
+    });
+    return {
+        displayFilename,
+        extension: getExtension(displayFilename),
+        toolbar: normalizeFileViewerToolbar(options),
+        theme: normalizeFileViewerTheme(options === null || options === void 0 ? void 0 : options.theme),
+    };
+};

package/dist/printLayout.d.ts

@@ -0,0 +1,19 @@
+export interface PrintPageSize {
+    width: number;
+    height: number;
+}
+export interface ApplyPrintPageSizeOptions {
+    heightMode?: 'fixed' | 'min';
+}
+export interface BuildPrintPageStyleOptions extends PrintPageSize {
+    selector: string;
+    heightMode?: 'fixed' | 'min';
+}
+export declare const formatCssPixels: (value: number) => string;
+/**
+ * Browser print helper. DOM measurement belongs in the core browser layer
+ * because it depends on CSS layout and HTMLElement.
+ */
+export declare const getElementPrintPageSize: (element: HTMLElement, fallback?: Partial<PrintPageSize>) => PrintPageSize;
+export declare const applyPrintPageSize: (element: HTMLElement, size: PrintPageSize, options?: ApplyPrintPageSizeOptions) => void;
+export declare const buildPrintPageStyle: ({ selector, width, height, heightMode, }: BuildPrintPageStyleOptions) => string;