@file-viewer/core 2.0.11 → 2.1.1

package/dist/renderers/index.d.ts

@@ -1,11 +1,329 @@
-import type { FileRenderHandler, FileViewerRenderedInstance } from '../contracts/types';
+import type { FileViewerBuiltinRendererPreset, FileRenderHandler, FileViewerRenderedInstance } from '../contracts/types';
 type CoreBrowserRendererHandler = FileRenderHandler<FileViewerRenderedInstance, HTMLDivElement>;
 interface CoreBrowserRendererHandlerEntry {
     rendererId: string;
     handler: CoreBrowserRendererHandler;
 }
 export declare const coreBrowserRendererHandlers: readonly CoreBrowserRendererHandlerEntry[];
-export declare const createFileViewerCoreRendererRegistry: () => {
+export declare const CORE_LITE_RENDERER_IDS: readonly ["image"];
+export declare const coreLiteBrowserRendererHandlers: CoreBrowserRendererHandlerEntry[];
+export declare const coreLiteRendererDefinitions: ({
+    readonly id: "office-word-openxml";
+    readonly label: "Word OpenXML";
+    readonly category: "office";
+    readonly extensions: readonly ["docx", "docm", "dotx", "dotm"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: "adapter";
+        readonly exportHtml: "adapter";
+        readonly zoom: "provider";
+        readonly search: true;
+    };
+} | {
+    readonly id: "office-word-binary";
+    readonly label: "Word Binary";
+    readonly category: "office";
+    readonly extensions: readonly ["doc", "dot"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: "adapter";
+        readonly exportHtml: "adapter";
+        readonly zoom: "provider";
+        readonly search: true;
+    };
+} | {
+    readonly id: "office-presentation";
+    readonly label: "PowerPoint";
+    readonly category: "office";
+    readonly extensions: readonly ["pptx", "pptm", "potx", "potm", "ppsx", "ppsm"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: true;
+        readonly exportHtml: true;
+        readonly zoom: "provider";
+        readonly search: true;
+    };
+} | {
+    readonly id: "open-document";
+    readonly label: "Open Document";
+    readonly category: "office";
+    readonly extensions: readonly ["rtf", "odt", "odp"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: true;
+        readonly exportHtml: true;
+        readonly zoom: "provider";
+        readonly search: true;
+    };
+} | {
+    readonly id: "spreadsheet-openxml";
+    readonly label: "Spreadsheet";
+    readonly category: "office";
+    readonly extensions: readonly ["xlsx", "xltx", "xlsm", "xlsb", "xls", "xlt", "xltm", "csv", "ods", "fods", "numbers"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: false;
+        readonly exportHtml: false;
+        readonly zoom: "provider";
+        readonly search: true;
+    };
+} | {
+    readonly id: "pdf";
+    readonly label: "PDF";
+    readonly category: "document";
+    readonly extensions: readonly ["pdf"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: "adapter";
+        readonly exportHtml: "adapter";
+        readonly zoom: "provider";
+        readonly search: "provider";
+    };
+} | {
+    readonly id: "ofd";
+    readonly label: "OFD";
+    readonly category: "document";
+    readonly extensions: readonly ["ofd"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: true;
+        readonly exportHtml: true;
+        readonly zoom: "provider";
+        readonly search: true;
+    };
+} | {
+    readonly id: "typst";
+    readonly label: "Typst";
+    readonly category: "document";
+    readonly extensions: readonly ["typ", "typst"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: "adapter";
+        readonly exportHtml: "adapter";
+        readonly zoom: "provider";
+        readonly search: true;
+    };
+} | {
+    readonly id: "archive";
+    readonly label: "Archive";
+    readonly category: "archive";
+    readonly extensions: readonly ["zip", "zipx", "7z", "rar", "tar", "gz", "gzip", "tgz", "bz2", "bzip2", "tbz", "tbz2", "xz", "txz", "lzma", "zst", "tzst", "cab", "ar", "cpio", "iso", "xar", "lha", "lzh", "jar", "war", "ear", "apk", "cbz", "cbr"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: false;
+        readonly exportHtml: false;
+        readonly zoom: false;
+        readonly search: true;
+    };
+} | {
+    readonly id: "email";
+    readonly label: "Email";
+    readonly category: "email";
+    readonly extensions: readonly ["eml", "msg", "mbox"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: false;
+        readonly exportHtml: true;
+        readonly zoom: false;
+        readonly search: true;
+    };
+} | {
+    readonly id: "eda";
+    readonly label: "EDA";
+    readonly category: "eda";
+    readonly extensions: readonly ["olb", "dra", "gds", "oas", "oasis"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: true;
+        readonly exportHtml: true;
+        readonly zoom: false;
+        readonly search: true;
+    };
+} | {
+    readonly id: "cad";
+    readonly label: "CAD";
+    readonly category: "cad";
+    readonly extensions: readonly ["dxf", "dwg", "dwf", "dwfx", "xps"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: true;
+        readonly exportHtml: true;
+        readonly zoom: "provider";
+        readonly search: false;
+    };
+} | {
+    readonly id: "model";
+    readonly label: "3D Model";
+    readonly category: "model";
+    readonly extensions: readonly ["glb", "gltf", "obj", "stl", "ply", "fbx", "dae", "3ds", "3mf", "amf", "usd", "usda", "usdc", "usdz", "kmz", "step", "stp", "iges", "igs", "ifc", "3dm", "brep", "pcd", "wrl", "vrml", "xyz", "vtk", "vtp"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: false;
+        readonly exportHtml: false;
+        readonly zoom: "provider";
+        readonly search: false;
+    };
+} | {
+    readonly id: "geo";
+    readonly label: "Geospatial";
+    readonly category: "geo";
+    readonly extensions: readonly ["geojson", "kml", "gpx", "shp"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: true;
+        readonly exportHtml: true;
+        readonly zoom: "provider";
+        readonly search: true;
+    };
+} | {
+    readonly id: "drawing";
+    readonly label: "Drawing";
+    readonly category: "drawing";
+    readonly extensions: readonly ["excalidraw", "drawio", "dio", "mermaid", "mmd", "plantuml", "puml"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: true;
+        readonly exportHtml: true;
+        readonly zoom: "provider";
+        readonly search: true;
+    };
+} | {
+    readonly id: "mindmap";
+    readonly label: "Mind Map";
+    readonly category: "mindmap";
+    readonly extensions: readonly ["xmind"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: true;
+        readonly exportHtml: true;
+        readonly zoom: "provider";
+        readonly search: true;
+    };
+} | {
+    readonly id: "epub";
+    readonly label: "EPUB";
+    readonly category: "ebook";
+    readonly extensions: readonly ["epub"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: false;
+        readonly exportHtml: true;
+        readonly zoom: false;
+        readonly search: "provider";
+    };
+} | {
+    readonly id: "umd";
+    readonly label: "UMD";
+    readonly category: "ebook";
+    readonly extensions: readonly ["umd"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: true;
+        readonly exportHtml: true;
+        readonly zoom: "provider";
+        readonly search: true;
+    };
+} | {
+    readonly id: "image";
+    readonly label: "Image";
+    readonly category: "image";
+    readonly extensions: readonly ["gif", "jpg", "jpeg", "bmp", "tiff", "tif", "png", "svg", "webp", "avif", "ico", "heic", "heif", "jxl"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: true;
+        readonly exportHtml: true;
+        readonly zoom: "provider";
+        readonly search: false;
+    };
+} | {
+    readonly id: "markdown";
+    readonly label: "Markdown";
+    readonly category: "markdown";
+    readonly extensions: readonly ["md", "markdown"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: true;
+        readonly exportHtml: true;
+        readonly zoom: false;
+        readonly search: true;
+    };
+} | {
+    readonly id: "code";
+    readonly label: "Code and Text";
+    readonly category: "code";
+    readonly extensions: readonly ["txt", "json", "js", "mjs", "cjs", "css", "java", "py", "html", "htm", "jsx", "ts", "tsx", "xml", "log", "vue", "yaml", "yml", "ini", "sh", "bash", "sql", "go", "rs", "php", "c", "cpp", "cc", "h", "hpp", "cs", "diff", "patch", "bundle", "bdl", "jsonc", "json5", "ipynb", "toml", "proto", "hcl", "tex", "gv", "http", "react", "rb", "swift", "kt"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: true;
+        readonly exportHtml: true;
+        readonly zoom: false;
+        readonly search: true;
+    };
+} | {
+    readonly id: "video";
+    readonly label: "Video";
+    readonly category: "media";
+    readonly extensions: readonly ["mp4", "webm", "m3u8"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: false;
+        readonly exportHtml: false;
+        readonly zoom: false;
+        readonly search: false;
+    };
+} | {
+    readonly id: "audio";
+    readonly label: "Audio";
+    readonly category: "media";
+    readonly extensions: readonly ["mp3", "mpeg", "wav", "ogg", "oga", "opus", "m4a", "aac", "flac", "weba", "midi", "mid"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: false;
+        readonly exportHtml: false;
+        readonly zoom: false;
+        readonly search: false;
+    };
+} | {
+    readonly id: "data-asset";
+    readonly label: "Data Asset";
+    readonly category: "asset";
+    readonly extensions: readonly ["ttf", "otf", "woff", "woff2", "psd", "ai", "eps", "sqlite", "wasm", "parquet", "avro", "webarchive"];
+    readonly async: true;
+    readonly capabilities: {
+        readonly download: true;
+        readonly print: false;
+        readonly exportHtml: true;
+        readonly zoom: false;
+        readonly search: true;
+    };
+})[];
+export interface CreateFileViewerCoreRendererRegistryOptions {
+    builtinRenderers?: FileViewerBuiltinRendererPreset;
+}
+export declare const createFileViewerCoreRendererRegistry: (options?: CreateFileViewerCoreRendererRegistryOptions) => {
     dispatcher: import("..").FileViewerRendererDispatcher<CoreBrowserRendererHandler>;
     registry: import("..").RendererRegistry;
     missingRendererIds: string[];

package/dist/renderers/index.js

@@ -14,34 +14,6 @@ const createWrapper = (el) => ({
     },
 });
 export const coreBrowserRendererHandlers = [
-    {
-        rendererId: 'code',
-        handler: async (buffer, target, type) => {
-            const { default: renderCode } = await import('./code.js');
-            return renderCode(buffer, target, type);
-        },
-    },
-    {
-        rendererId: 'markdown',
-        handler: async (buffer, target) => {
-            const { default: renderMarkdown } = await import('./markdown.js');
-            return renderMarkdown(buffer, target);
-        },
-    },
-    {
-        rendererId: 'video',
-        handler: async (buffer, target, type, context) => {
-            const { default: renderVideo } = await import('./video.js');
-            return renderVideo(buffer, target, type, context);
-        },
-    },
-    {
-        rendererId: 'audio',
-        handler: async (buffer, target, type) => {
-            const { default: renderAudio } = await import('./audio.js');
-            return renderAudio(buffer, target, type);
-        },
-    },
     {
         rendererId: 'image',
         handler: async (buffer, target, type) => {
@@ -49,133 +21,30 @@ export const coreBrowserRendererHandlers = [
             return renderImage(buffer, target, type);
         },
     },
-    {
-        rendererId: 'umd',
-        handler: async (buffer, target) => {
-            const { default: renderUmd } = await import('./umd.js');
-            return renderUmd(buffer, target);
-        },
-    },
-    {
-        rendererId: 'geo',
-        handler: async (buffer, target, type) => {
-            const { default: renderGeo } = await import('./geo.js');
-            return renderGeo(buffer, target, type);
-        },
-    },
-    {
-        rendererId: 'open-document',
-        handler: async (buffer, target, type) => {
-            const { default: renderOpenDocument } = await import('./openDocument.js');
-            return renderOpenDocument(buffer, target, type);
-        },
-    },
-    {
-        rendererId: 'ofd',
-        handler: async (buffer, target, _type, context) => {
-            const { default: renderOfd } = await import('./ofd.js');
-            return renderOfd(buffer, target, context);
-        },
-    },
-    {
-        rendererId: 'pdf',
-        handler: async (buffer, target, _type, context) => {
-            const { default: renderPdf } = await import('./pdf.js');
-            return renderPdf(buffer, target, context);
-        },
-    },
-    {
-        rendererId: 'office-word-openxml',
-        handler: async (buffer, target, _type, context) => {
-            const { default: renderWordDocx } = await import('./wordDocx.js');
-            return renderWordDocx(buffer, target, context);
-        },
-    },
-    {
-        rendererId: 'office-word-binary',
-        handler: async (buffer, target, _type, context) => {
-            const { default: renderWordDoc } = await import('./wordDoc.js');
-            return renderWordDoc(buffer, target, context);
-        },
-    },
-    {
-        rendererId: 'spreadsheet-openxml',
-        handler: async (buffer, target, type, context) => {
-            const { default: renderSpreadsheet } = await import('./spreadsheet.js');
-            return renderSpreadsheet(buffer, target, type, context);
-        },
-    },
-    {
-        rendererId: 'email',
-        handler: async (buffer, target, type, context) => {
-            const { default: renderEmail } = await import('./email.js');
-            return renderEmail(buffer, target, type, context);
-        },
-    },
-    {
-        rendererId: 'eda',
-        handler: async (buffer, target, type, context) => {
-            const { default: renderEda } = await import('./eda.js');
-            return renderEda(buffer, target, type, context);
-        },
-    },
-    {
-        rendererId: 'cad',
-        handler: async (buffer, target, type, context) => {
-            const { default: renderCad } = await import('./cad.js');
-            return renderCad(buffer, target, type, context);
-        },
-    },
-    {
-        rendererId: 'typst',
-        handler: async (buffer, target, type, context) => {
-            const { default: renderTypst } = await import('./typst.js');
-            return renderTypst(buffer, target, type, context);
-        },
-    },
-    {
-        rendererId: 'office-presentation',
-        handler: async (buffer, target, type, context) => {
-            const { default: renderPptx } = await import('./pptx.js');
-            return renderPptx(buffer, target, type, context);
-        },
-    },
-    {
-        rendererId: 'epub',
-        handler: async (buffer, target) => {
-            const { default: renderEpub } = await import('./epub.js');
-            return renderEpub(buffer, target);
-        },
-    },
-    {
-        rendererId: 'model',
-        handler: async (buffer, target, type, context) => {
-            const { default: renderModel } = await import('./model.js');
-            return renderModel(buffer, target, type, context);
-        },
-    },
-    {
-        rendererId: 'drawing',
-        handler: async (buffer, target, type, context) => {
-            const { default: renderDrawing } = await import('./drawing.js');
-            return renderDrawing(buffer, target, type, context);
-        },
-    },
-    {
-        rendererId: 'data-asset',
-        handler: async (buffer, target, type, context) => {
-            const { default: renderDataAsset } = await import('./data.js');
-            return renderDataAsset(buffer, target, type, context);
-        },
-    },
-    {
-        rendererId: 'archive',
-        handler: async (buffer, target, type, context) => {
-            const { default: renderArchive } = await import('./archive.js');
-            return renderArchive(buffer, target, type, context);
-        },
-    },
 ];
+export const CORE_LITE_RENDERER_IDS = [
+    'image',
+];
+export const coreLiteBrowserRendererHandlers = coreBrowserRendererHandlers.filter(handler => CORE_LITE_RENDERER_IDS.includes(handler.rendererId));
+export const coreLiteRendererDefinitions = DEFAULT_RENDERER_DEFINITIONS.filter(definition => CORE_LITE_RENDERER_IDS.includes(definition.id));
+const resolveCoreRendererDefinitions = (preset) => {
+    if (preset === 'none') {
+        return [];
+    }
+    if (preset === 'lite') {
+        return coreLiteRendererDefinitions;
+    }
+    return DEFAULT_RENDERER_DEFINITIONS;
+};
+const resolveCoreRendererHandlers = (preset) => {
+    if (preset === 'none') {
+        return [];
+    }
+    if (preset === 'lite') {
+        return coreLiteBrowserRendererHandlers;
+    }
+    return coreBrowserRendererHandlers;
+};
 const renderUnsupported = async (_buffer, target, type) => {
     const state = createFileViewerUnsupportedState(type);
     const wrapper = document.createElement('div');
@@ -192,10 +61,11 @@ const renderUnsupported = async (_buffer, target, type) => {
     target.replaceChildren(wrapper);
     return createWrapper(target);
 };
-export const createFileViewerCoreRendererRegistry = () => {
+export const createFileViewerCoreRendererRegistry = (options = {}) => {
+    const preset = options.builtinRenderers || 'all';
     const bridge = createFileRenderHandlerRegistry({
-        definitions: DEFAULT_RENDERER_DEFINITIONS,
-        handlers: coreBrowserRendererHandlers,
+        definitions: resolveCoreRendererDefinitions(preset),
+        handlers: resolveCoreRendererHandlers(preset),
     });
     return {
         ...bridge,

package/dist/viewer/createViewer.js

@@ -10,11 +10,13 @@ import { createFileViewerZoomController } from '../features/document/zoom.js';
 import { DEFAULT_FILE_VIEWER_DOWNLOAD_FILENAME, DEFAULT_FILE_VIEWER_EXPORT_FILENAME, DEFAULT_FILE_VIEWER_PREVIEW_TITLE, createFileViewerOriginalSourceStateFromNormalizedSource, executeFileViewerDownloadOperation, executeFileViewerExportHtmlOperation, executeFileViewerPrintOperation, resolveFileViewerDisplayFilename, resolveFileViewerOperationFilename, } from './operations.js';
 import { getRendererAvailability, createUnsupportedAvailability } from '../registry/capabilities.js';
 import { buildFileViewerLifecycleContextFromNormalizedSource, buildFileViewerOperationContext, runFileViewerBeforeOperation, runFileViewerLifecycleHook, } from '../lifecycle/operations.js';
-import { createRendererRegistry } from '../registry/registry.js';
-import { applyFileViewerRenderSurfaceState, createFileViewerRenderSurfaceState, } from '../rendering/handler.js';
+import { collectFileViewerRendererPlugins, createRendererRegistry, installFileViewerRendererPlugins, } from '../registry/registry.js';
+import { createFileRenderHandlerLoader, applyFileViewerRenderSurfaceState, createFileViewerRenderSurfaceState, } from '../rendering/handler.js';
+import { createFileViewerCoreRendererRegistry } from '../renderers/index.js';
 import { createFileViewerRequestScope } from '../source/loading.js';
 import { normalizeSource } from '../source/index.js';
 import { buildFileViewerWatermarkInlineStyle } from '../features/watermark.js';
+import { createFileViewerUnsupportedState } from './state.js';
 const emitLifecycle = async (options, onEvent, phase, source, version, startedAt, reason) => {
     const now = Date.now();
     const context = buildFileViewerLifecycleContextFromNormalizedSource({
@@ -30,9 +32,52 @@ const emitLifecycle = async (options, onEvent, phase, source, version, startedAt
     });
     onEvent === null || onEvent === void 0 ? void 0 : onEvent({ type: phase, payload: context });
 };
+const createBaseRendererRegistry = (createOptions, options) => {
+    if (options.rendererMode === 'replace') {
+        return createRendererRegistry([]);
+    }
+    if (createOptions.registry) {
+        return createOptions.registry;
+    }
+    return createFileViewerCoreRendererRegistry({
+        builtinRenderers: options.builtinRenderers,
+    }).registry;
+};
+const renderMissingRendererState = (container, type) => {
+    const documentRef = container.ownerDocument;
+    const state = createFileViewerUnsupportedState(type);
+    const wrapper = documentRef.createElement('div');
+    wrapper.className = 'file-viewer-missing-renderer';
+    wrapper.style.cssText = [
+        'display:flex',
+        'min-height:260px',
+        'height:100%',
+        'align-items:center',
+        'justify-content:center',
+        'padding:32px',
+        'box-sizing:border-box',
+        'text-align:center',
+        'color:#64748b',
+        'font:14px/1.6 system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif',
+    ].join(';');
+    const content = documentRef.createElement('div');
+    const title = documentRef.createElement('strong');
+    title.textContent = state.message;
+    title.style.cssText = 'display:block;margin-bottom:8px;color:#172033;font-size:16px;';
+    const description = documentRef.createElement('p');
+    description.textContent = state.description ||
+        '当前内置 renderer 配置没有加载该格式。请安装并传入对应 @file-viewer/renderer-* 包，或使用 @file-viewer/preset-all。';
+    description.style.cssText = 'max-width:520px;margin:0;';
+    content.append(title, description);
+    wrapper.append(content);
+    container.replaceChildren(wrapper);
+};
 export const createViewer = (container, createOptions = {}) => {
-    const registry = createOptions.registry || createRendererRegistry();
     let options = createOptions.options || {};
+    let registry = createBaseRendererRegistry(createOptions, options);
+    let installedRendererInput = undefined;
+    let installedRendererMode = options.rendererMode || 'extend';
+    let installedBuiltinRenderers = options.builtinRenderers || 'all';
     let currentSource = null;
     const renderSurfaceState = createFileViewerRenderSurfaceState();
     const requestScope = createFileViewerRequestScope();
@@ -40,6 +85,42 @@ export const createViewer = (container, createOptions = {}) => {
         anchors: { value: [] },
         state: createEmptyFileViewerSearchState(),
     };
+    const ensureRendererPluginsInstalled = async () => {
+        const nextMode = options.rendererMode || 'extend';
+        const nextRendererInput = options.renderers;
+        const nextBuiltinRenderers = options.builtinRenderers || 'all';
+        if (nextMode === installedRendererMode &&
+            nextRendererInput === installedRendererInput &&
+            nextBuiltinRenderers === installedBuiltinRenderers) {
+            return;
+        }
+        registry = createBaseRendererRegistry(createOptions, options);
+        installedRendererMode = nextMode;
+        installedRendererInput = nextRendererInput;
+        installedBuiltinRenderers = nextBuiltinRenderers;
+        const plugins = collectFileViewerRendererPlugins(nextRendererInput);
+        if (!plugins.length) {
+            return;
+        }
+        const registerHandler = (registration) => {
+            const definition = registry.getById(registration.rendererId);
+            if (!definition) {
+                return;
+            }
+            registry.register({
+                ...definition,
+                load: createFileRenderHandlerLoader({
+                    handler: registration.handler,
+                    getTarget: context => context.surface.container,
+                }),
+            });
+        };
+        await installFileViewerRendererPlugins({
+            registry,
+            plugins,
+            registerHandler,
+        });
+    };
     const buildCurrentLifecycleContext = () => {
         const source = currentSource || normalizeSource({});
         return buildFileViewerLifecycleContextFromNormalizedSource({
@@ -139,6 +220,7 @@ export const createViewer = (container, createOptions = {}) => {
         container,
         async load(source) {
             await destroyCurrent('replace');
+            await ensureRendererPluginsInstalled();
             const normalized = normalizeSource(source);
             currentSource = normalized;
             const version = requestScope.requestController.createVersion();
@@ -146,6 +228,7 @@ export const createViewer = (container, createOptions = {}) => {
             const startedAt = Date.now();
             await emitLifecycle(options, createOptions.onEvent, 'load-start', normalized, version, startedAt);
             if (!(renderer === null || renderer === void 0 ? void 0 : renderer.load)) {
+                renderMissingRendererState(container, normalized.extension);
                 applyFileViewerRenderSurfaceState(renderSurfaceState, { session: null });
                 emitOperationAvailabilityChange();
                 emitZoomChange();