@file-viewer/core 2.0.0

package/dist/rendererHandler.js

@@ -0,0 +1,354 @@
+import { DEFAULT_RENDERER_DEFINITIONS } from './formats.js';
+import { waitForFileViewerNextPaint } from './export.js';
+import { createFileViewerRendererDispatcher } from './rendererDispatcher.js';
+import { createRendererRegistry } from './registry.js';
+import { getExtension, normalizeFileExtension } from './source.js';
+import { applyFileViewerRenderReadinessState, } from './sourceLoading.js';
+export const FILE_VIEWER_RENDER_SESSION_DISPOSE_ERROR_MESSAGE = '预览内容卸载失败';
+export const DEFAULT_FILE_VIEWER_RENDER_TARGET_CLASS = 'file-render';
+const isPromiseLike = (value) => {
+    return !!value &&
+        (typeof value === 'object' || typeof value === 'function') &&
+        typeof value.then === 'function';
+};
+export const clearFileViewerRenderSurface = (container) => {
+    if (!container) {
+        return;
+    }
+    while (container.firstChild) {
+        container.removeChild(container.firstChild);
+    }
+};
+export const createFileViewerRenderTarget = (container, options = {}) => {
+    const target = container.ownerDocument.createElement('div');
+    target.className = options.className || DEFAULT_FILE_VIEWER_RENDER_TARGET_CLASS;
+    container.appendChild(target);
+    return target;
+};
+export const removeFileViewerRenderTarget = (container, target) => {
+    if (target.parentNode !== container) {
+        return false;
+    }
+    container.removeChild(target);
+    return true;
+};
+export const createFileViewerRenderSurfaceState = () => ({
+    session: null,
+    exportAdapter: null,
+});
+export const createFileViewerRenderReadinessTarget = ({ renderedReady, progressiveReady, }) => {
+    return {
+        get renderedReady() {
+            return renderedReady.get();
+        },
+        set renderedReady(value) {
+            renderedReady.set(value);
+        },
+        get progressiveReady() {
+            return progressiveReady.get();
+        },
+        set progressiveReady(value) {
+            progressiveReady.set(value);
+        },
+    };
+};
+export const createFileViewerRenderSurfaceStateTarget = ({ session, exportAdapter, }) => {
+    return {
+        get session() {
+            return session.get();
+        },
+        set session(value) {
+            session.set(value);
+        },
+        get exportAdapter() {
+            return exportAdapter.get();
+        },
+        set exportAdapter(value) {
+            exportAdapter.set(value);
+        },
+    };
+};
+export const applyFileViewerRenderSurfaceState = (target, state) => {
+    var _a, _b;
+    if ('session' in state) {
+        target.session = (_a = state.session) !== null && _a !== void 0 ? _a : null;
+    }
+    if ('exportAdapter' in state) {
+        target.exportAdapter = (_b = state.exportAdapter) !== null && _b !== void 0 ? _b : null;
+    }
+    return target;
+};
+export const createFileRenderHandlerRendererSession = (rendered, destroy) => ({
+    rendered,
+    destroy: () => {
+        if (destroy) {
+            return destroy();
+        }
+        return disposeFileViewerRendered(rendered);
+    },
+});
+export const disposeFileViewerRendered = (rendered) => {
+    if (!rendered || typeof rendered !== 'object') {
+        return;
+    }
+    const disposable = rendered;
+    if (typeof disposable.unmount === 'function') {
+        return disposable.unmount();
+    }
+    if (typeof disposable.$destroy === 'function') {
+        return disposable.$destroy();
+    }
+    if (typeof disposable.destroy === 'function') {
+        return disposable.destroy();
+    }
+};
+export const resolveFileViewerRenderSessionDisposeErrorMessage = ({ message = FILE_VIEWER_RENDER_SESSION_DISPOSE_ERROR_MESSAGE, } = {}) => message;
+export const DEFAULT_FILE_VIEWER_RENDER_SESSION_DISPOSE_ERROR_LOGGER = (message, error) => {
+    if (typeof console !== 'undefined' && typeof console.warn === 'function') {
+        console.warn(message, error);
+    }
+};
+export const reportFileViewerRenderSessionDisposeError = ({ error, onLogError = DEFAULT_FILE_VIEWER_RENDER_SESSION_DISPOSE_ERROR_LOGGER, ...messageInput }) => {
+    const message = resolveFileViewerRenderSessionDisposeErrorMessage(messageInput);
+    onLogError === null || onLogError === void 0 ? void 0 : onLogError(message, error);
+    return message;
+};
+export const disposeFileViewerRendererSession = (session, options = {}) => {
+    if (!(session === null || session === void 0 ? void 0 : session.destroy)) {
+        return;
+    }
+    const handleError = (error) => {
+        var _a;
+        (_a = options.onError) === null || _a === void 0 ? void 0 : _a.call(options, error);
+    };
+    try {
+        const result = session.destroy();
+        if (isPromiseLike(result)) {
+            void Promise.resolve(result).catch(handleError);
+        }
+    }
+    catch (error) {
+        handleError(error);
+    }
+};
+export const disposeActiveFileViewerRendererSession = (target, options = {}) => {
+    const session = target.session;
+    try {
+        disposeFileViewerRendererSession(session, options);
+    }
+    finally {
+        target.session = null;
+    }
+    return session;
+};
+export const resetFileViewerRenderSurface = ({ surfaceState, readinessState, container, disposeOptions, }) => {
+    const session = disposeActiveFileViewerRendererSession(surfaceState, disposeOptions);
+    applyFileViewerRenderSurfaceState(surfaceState, { exportAdapter: null });
+    applyFileViewerRenderReadinessState(readinessState, {
+        renderedReady: false,
+        progressiveReady: false,
+    });
+    clearFileViewerRenderSurface(container);
+    return session;
+};
+export const runFileViewerRenderSurfaceClear = ({ reason = 'replace', surfaceState, readinessState, container, disposeOptions, onUnloadStart, onUnloadComplete, onClearActiveDocumentContext, onClearDocumentState, onStopZoomObserver, onClearZoomProvider, }) => {
+    const unloadContext = onUnloadStart === null || onUnloadStart === void 0 ? void 0 : onUnloadStart(reason);
+    let session;
+    try {
+        session = resetFileViewerRenderSurface({
+            surfaceState,
+            readinessState,
+            container,
+            disposeOptions,
+        });
+    }
+    finally {
+        onClearActiveDocumentContext === null || onClearActiveDocumentContext === void 0 ? void 0 : onClearActiveDocumentContext();
+        onClearDocumentState === null || onClearDocumentState === void 0 ? void 0 : onClearDocumentState();
+        onStopZoomObserver === null || onStopZoomObserver === void 0 ? void 0 : onStopZoomObserver();
+        onClearZoomProvider === null || onClearZoomProvider === void 0 ? void 0 : onClearZoomProvider();
+    }
+    onUnloadComplete === null || onUnloadComplete === void 0 ? void 0 : onUnloadComplete(unloadContext, reason);
+    return {
+        reason,
+        unloadContext,
+        session,
+    };
+};
+export const runFileViewerRenderSurfaceMount = async ({ buffer, file, version, sourceUrl, streamUrl, getContainer, surfaceState, readinessState, isCurrent, clearRenderedContent, render, waitForContainer, waitForPaint = waitForFileViewerNextPaint, disposeSession = disposeFileViewerRendererSession, onStartZoomObserver, onRefreshDocumentIndex, onRefreshZoomProvider, }) => {
+    if (!getContainer()) {
+        await (waitForContainer === null || waitForContainer === void 0 ? void 0 : waitForContainer());
+    }
+    const container = getContainer();
+    if (!container || !isCurrent(version)) {
+        return undefined;
+    }
+    clearRenderedContent('replace');
+    const target = createFileViewerRenderTarget(container);
+    onStartZoomObserver === null || onStartZoomObserver === void 0 ? void 0 : onStartZoomObserver();
+    await (waitForContainer === null || waitForContainer === void 0 ? void 0 : waitForContainer());
+    await waitForPaint();
+    if (!isCurrent(version)) {
+        removeFileViewerRenderTarget(container, target);
+        return undefined;
+    }
+    const registerExportAdapter = (adapter) => {
+        applyFileViewerRenderSurfaceState(surfaceState, { exportAdapter: adapter });
+    };
+    const onProgressiveRender = () => {
+        if (isCurrent(version)) {
+            applyFileViewerRenderReadinessState(readinessState, { progressiveReady: true });
+        }
+    };
+    try {
+        const session = await render({
+            buffer,
+            file,
+            version,
+            type: getExtension(file.name),
+            target,
+            filename: file.name,
+            sourceUrl,
+            streamUrl,
+            onProgressiveRender,
+            registerExportAdapter,
+            surfaceState,
+            readinessState,
+        });
+        if (!isCurrent(version)) {
+            disposeSession(session);
+            removeFileViewerRenderTarget(container, target);
+            return undefined;
+        }
+        void (onRefreshDocumentIndex === null || onRefreshDocumentIndex === void 0 ? void 0 : onRefreshDocumentIndex());
+        onRefreshZoomProvider === null || onRefreshZoomProvider === void 0 ? void 0 : onRefreshZoomProvider();
+        return session;
+    }
+    catch (error) {
+        removeFileViewerRenderTarget(container, target);
+        throw error;
+    }
+};
+export const createFileViewerRenderSurfaceActionHandlers = ({ getContainer, surfaceState, readinessState, isCurrent, render, waitForContainer, waitForPaint, disposeOptions, onUnloadStart, onUnloadComplete, onClearActiveDocumentContext, onClearDocumentState, onStartZoomObserver, onStopZoomObserver, onClearZoomProvider, onRefreshDocumentIndex, onRefreshZoomProvider, }) => {
+    const handleDisposeError = (error) => {
+        if (disposeOptions === null || disposeOptions === void 0 ? void 0 : disposeOptions.onError) {
+            disposeOptions.onError(error);
+            return;
+        }
+        reportFileViewerRenderSessionDisposeError({ error });
+    };
+    const mergedDisposeOptions = {
+        ...disposeOptions,
+        onError: handleDisposeError,
+    };
+    const destroyRenderSession = (session) => {
+        disposeFileViewerRendererSession(session, mergedDisposeOptions);
+    };
+    const setActiveRenderSession = (session) => {
+        return applyFileViewerRenderSurfaceState(surfaceState, { session });
+    };
+    const clearRenderedContent = (reason = 'replace') => {
+        return runFileViewerRenderSurfaceClear({
+            reason,
+            surfaceState,
+            readinessState,
+            container: getContainer(),
+            disposeOptions: mergedDisposeOptions,
+            onUnloadStart,
+            onUnloadComplete,
+            onClearActiveDocumentContext,
+            onClearDocumentState,
+            onStopZoomObserver,
+            onClearZoomProvider,
+        });
+    };
+    const mountRenderedContent = async (buffer, file, version, sourceUrl, streamUrl) => {
+        return await runFileViewerRenderSurfaceMount({
+            buffer,
+            file,
+            version,
+            sourceUrl,
+            streamUrl,
+            getContainer,
+            surfaceState,
+            readinessState,
+            isCurrent,
+            clearRenderedContent,
+            render,
+            waitForContainer,
+            waitForPaint,
+            disposeSession: destroyRenderSession,
+            onStartZoomObserver,
+            onRefreshDocumentIndex,
+            onRefreshZoomProvider,
+        });
+    };
+    return {
+        destroyRenderSession,
+        setActiveRenderSession,
+        clearRenderedContent,
+        mountRenderedContent,
+    };
+};
+export const buildFileRenderContextFromLoadContext = ({ source, options, registerExportAdapter, renderContext, }) => ({
+    filename: source.filename,
+    url: source.url,
+    streamUrl: source.url,
+    options,
+    registerExportAdapter,
+    ...renderContext,
+});
+export const renderFileViewerHandler = async ({ dispatcher, buffer, target, type = '', context, throwOnMissingHandler = false, }) => {
+    const normalizedType = normalizeFileExtension(type);
+    const handler = dispatcher.resolve(normalizedType);
+    if (!handler) {
+        if (throwOnMissingHandler) {
+            throw new Error(`No file viewer renderer is registered for "${normalizedType}".`);
+        }
+        return undefined;
+    }
+    return handler(buffer, target, normalizedType, context);
+};
+export const createFileRenderHandlerLoader = ({ handler, getTarget = context => context.surface.container, createContext = buildFileRenderContextFromLoadContext, destroy, }) => {
+    return async (context) => {
+        const { source } = context;
+        if (!source.buffer) {
+            throw new Error('FileRenderHandler renderer requires an ArrayBuffer source.');
+        }
+        const target = getTarget(context);
+        const rendered = await handler(source.buffer, target, source.extension, createContext(context));
+        return createFileRenderHandlerRendererSession(rendered, () => {
+            if (destroy) {
+                return destroy(rendered, context);
+            }
+            return disposeFileViewerRendered(rendered);
+        });
+    };
+};
+export const createFileRenderHandlerRegistry = ({ definitions = DEFAULT_RENDERER_DEFINITIONS, handlers, getTarget, createContext, destroy, }) => {
+    const baseRegistry = createRendererRegistry(definitions);
+    const dispatcher = createFileViewerRendererDispatcher({
+        registry: baseRegistry,
+        handlers,
+    });
+    const definitionsWithLoaders = baseRegistry.list().map(definition => {
+        const handler = dispatcher.handlersByRendererId.get(definition.id);
+        if (!handler) {
+            return definition;
+        }
+        return {
+            ...definition,
+            load: createFileRenderHandlerLoader({
+                handler,
+                getTarget,
+                createContext,
+                destroy,
+            }),
+        };
+    });
+    return {
+        registry: createRendererRegistry(definitionsWithLoaders),
+        dispatcher,
+        missingRendererIds: dispatcher.missingRendererIds,
+    };
+};

package/dist/renderers/archive.d.ts

@@ -0,0 +1,2 @@
+import type { FileRenderContext, FileViewerRenderedInstance } from '../types';
+export default function renderArchive(buffer: ArrayBuffer, target: HTMLDivElement, _type?: string, context?: FileRenderContext): Promise<FileViewerRenderedInstance>;