@file-viewer/core 2.0.0

package/dist/printLayout.js

@@ -0,0 +1,83 @@
+const CSS_PIXELS_PER_INCH = 96;
+const normalizeCssPixels = (value) => {
+    if (!Number.isFinite(value) || value <= 0) {
+        return 0;
+    }
+    return Number(value.toFixed(3));
+};
+export const formatCssPixels = (value) => `${normalizeCssPixels(value)}px`;
+const formatCssInches = (value) => `${Number((normalizeCssPixels(value) / CSS_PIXELS_PER_INCH).toFixed(4))}in`;
+const readPositiveCssNumber = (value) => {
+    const parsed = Number.parseFloat(value);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+};
+/**
+ * Browser print helper. DOM measurement belongs in the core browser layer
+ * because it depends on CSS layout and HTMLElement.
+ */
+export const getElementPrintPageSize = (element, fallback = {}) => {
+    const style = window.getComputedStyle(element);
+    const width = readPositiveCssNumber(style.width) ||
+        element.offsetWidth ||
+        fallback.width ||
+        element.getBoundingClientRect().width;
+    const height = readPositiveCssNumber(style.height) ||
+        readPositiveCssNumber(style.minHeight) ||
+        element.offsetHeight ||
+        fallback.height ||
+        element.getBoundingClientRect().height;
+    return {
+        width: normalizeCssPixels(width),
+        height: normalizeCssPixels(height),
+    };
+};
+export const applyPrintPageSize = (element, size, options = {}) => {
+    const width = formatCssPixels(size.width);
+    const height = formatCssPixels(size.height);
+    const heightMode = options.heightMode || 'fixed';
+    element.classList.add('viewer-print-page');
+    element.style.setProperty('--viewer-print-page-width', width);
+    element.style.setProperty('--viewer-print-page-height', height);
+    element.style.width = width;
+    element.style.maxWidth = 'none';
+    element.style.minHeight = height;
+    if (heightMode === 'fixed') {
+        element.style.height = height;
+        element.style.overflow = 'hidden';
+    }
+    else {
+        element.style.height = 'auto';
+        element.style.overflow = 'visible';
+    }
+};
+export const buildPrintPageStyle = ({ selector, width, height, heightMode = 'fixed', }) => {
+    const pageWidth = formatCssPixels(width);
+    const pageHeight = formatCssPixels(height);
+    const heightRule = heightMode === 'fixed'
+        ? `height:${pageHeight}!important;min-height:${pageHeight}!important;overflow:hidden!important;`
+        : `height:auto!important;min-height:${pageHeight}!important;overflow:visible!important;`;
+    return `
+    @page { size: ${formatCssInches(width)} ${formatCssInches(height)}; margin: 0; }
+    @media print {
+      html, body {
+        width: ${pageWidth};
+        min-width: ${pageWidth};
+        background: #ffffff !important;
+      }
+      ${selector} {
+        width: ${pageWidth}!important;
+        max-width: none!important;
+        ${heightRule}
+        margin: 0!important;
+        box-shadow: none!important;
+        border: 0!important;
+        break-after: page;
+        page-break-after: always;
+      }
+      ${selector}:last-child {
+        break-after: auto;
+        page-break-after: auto;
+      }
+    }
+  `;
+};

package/dist/registry.d.ts

@@ -0,0 +1,2 @@
+import type { RendererDefinition, RendererRegistry } from './types';
+export declare const createRendererRegistry: (initialDefinitions?: readonly RendererDefinition[]) => RendererRegistry;

package/dist/registry.js

@@ -0,0 +1,63 @@
+import { DEFAULT_RENDERER_DEFINITIONS } from './formats.js';
+import { normalizeFileExtension } from './source.js';
+const normalizeDefinition = (definition) => ({
+    ...definition,
+    extensions: definition.extensions.map(normalizeFileExtension),
+});
+export const createRendererRegistry = (initialDefinitions = DEFAULT_RENDERER_DEFINITIONS) => {
+    const byId = new Map();
+    const byExtension = new Map();
+    const register = (definition) => {
+        const normalized = normalizeDefinition(definition);
+        const existing = byId.get(normalized.id);
+        if (existing) {
+            existing.extensions.forEach(extension => {
+                var _a;
+                if (((_a = byExtension.get(extension)) === null || _a === void 0 ? void 0 : _a.id) === existing.id) {
+                    byExtension.delete(extension);
+                }
+            });
+        }
+        byId.set(normalized.id, normalized);
+        normalized.extensions.forEach(extension => {
+            const owner = byExtension.get(extension);
+            if (owner && owner.id !== normalized.id) {
+                throw new Error(`File extension "${extension}" is already registered by renderer "${owner.id}".`);
+            }
+            byExtension.set(extension, normalized);
+        });
+    };
+    initialDefinitions.forEach(register);
+    return {
+        register,
+        unregister(id) {
+            const existing = byId.get(id);
+            if (!existing) {
+                return false;
+            }
+            existing.extensions.forEach(extension => {
+                var _a;
+                if (((_a = byExtension.get(extension)) === null || _a === void 0 ? void 0 : _a.id) === id) {
+                    byExtension.delete(extension);
+                }
+            });
+            byId.delete(id);
+            return true;
+        },
+        getById(id) {
+            return byId.get(id);
+        },
+        getByExtension(extension) {
+            return byExtension.get(normalizeFileExtension(extension));
+        },
+        hasExtension(extension) {
+            return byExtension.has(normalizeFileExtension(extension));
+        },
+        list() {
+            return Array.from(byId.values());
+        },
+        listExtensions() {
+            return Array.from(byExtension.keys()).sort();
+        },
+    };
+};

package/dist/rendererDispatcher.d.ts

@@ -0,0 +1,21 @@
+import type { RendererRegistry } from './types';
+export interface FileViewerRendererHandlerEntry<Handler> {
+    rendererId: string;
+    handler: Handler;
+}
+export interface CreateFileViewerRendererDispatcherOptions<Handler> {
+    registry?: RendererRegistry;
+    handlers: Iterable<FileViewerRendererHandlerEntry<Handler>>;
+    fallbackHandler?: Handler;
+    fallbackKey?: string;
+}
+export interface FileViewerRendererDispatcher<Handler> {
+    handlersByRendererId: Map<string, Handler>;
+    handlersByExtension: Map<string, Handler>;
+    missingRendererIds: string[];
+    get(extension: string): Handler | undefined;
+    resolve(extension: string): Handler | undefined;
+    has(extension: string): boolean;
+    listExtensions(): string[];
+}
+export declare const createFileViewerRendererDispatcher: <Handler>({ registry, handlers, fallbackHandler, fallbackKey, }: CreateFileViewerRendererDispatcherOptions<Handler>) => FileViewerRendererDispatcher<Handler>;

package/dist/rendererDispatcher.js

@@ -0,0 +1,42 @@
+import { DEFAULT_RENDERER_DEFINITIONS } from './formats.js';
+import { createRendererRegistry } from './registry.js';
+import { normalizeFileExtension } from './source.js';
+export const createFileViewerRendererDispatcher = ({ registry = createRendererRegistry(DEFAULT_RENDERER_DEFINITIONS), handlers, fallbackHandler, fallbackKey = 'error', }) => {
+    const handlersByRendererId = Array.from(handlers).reduce((result, entry) => {
+        result.set(entry.rendererId, entry.handler);
+        return result;
+    }, new Map());
+    const handlersByExtension = new Map();
+    const missingRendererIds = [];
+    registry.list().forEach(definition => {
+        const handler = handlersByRendererId.get(definition.id);
+        if (!handler) {
+            missingRendererIds.push(definition.id);
+            return;
+        }
+        definition.extensions.forEach(extension => {
+            handlersByExtension.set(normalizeFileExtension(extension), handler);
+        });
+    });
+    if (fallbackHandler && fallbackKey) {
+        handlersByExtension.set(normalizeFileExtension(fallbackKey), fallbackHandler);
+    }
+    const get = (extension) => {
+        return handlersByExtension.get(normalizeFileExtension(extension));
+    };
+    return {
+        handlersByRendererId,
+        handlersByExtension,
+        missingRendererIds,
+        get,
+        resolve(extension) {
+            return get(extension) || (fallbackKey ? get(fallbackKey) : undefined);
+        },
+        has(extension) {
+            return handlersByExtension.has(normalizeFileExtension(extension));
+        },
+        listExtensions() {
+            return Array.from(handlersByExtension.keys()).sort();
+        },
+    };
+};

package/dist/rendererHandler.d.ts

@@ -0,0 +1,165 @@
+import type { FileViewerRendererDispatcher } from './rendererDispatcher';
+import { type FileViewerMutableAccessor, type MutableFileViewerRenderReadinessState } from './sourceLoading';
+import type { FileRenderExportAdapter, FileRenderContext, FileRenderHandler, FileViewerLifecycleContext, RendererDefinition, RendererLoadContext, RendererLoader, RendererRegistry, RendererSession } from './types';
+export declare const FILE_VIEWER_RENDER_SESSION_DISPOSE_ERROR_MESSAGE = "\u9884\u89C8\u5185\u5BB9\u5378\u8F7D\u5931\u8D25";
+export interface ResolveFileViewerRenderSessionDisposeErrorMessageInput {
+    message?: string;
+}
+export type FileViewerRenderSessionDisposeErrorLogger = (message: string, error: unknown) => void;
+export interface ReportFileViewerRenderSessionDisposeErrorInput extends ResolveFileViewerRenderSessionDisposeErrorMessageInput {
+    error: unknown;
+    onLogError?: FileViewerRenderSessionDisposeErrorLogger | null;
+}
+export interface RenderFileViewerHandlerInput<Rendered = unknown, Target extends HTMLElement = HTMLElement> {
+    dispatcher: Pick<FileViewerRendererDispatcher<FileRenderHandler<Rendered, Target>>, 'resolve'>;
+    buffer: ArrayBuffer;
+    target: Target;
+    type?: string;
+    context?: FileRenderContext;
+    throwOnMissingHandler?: boolean;
+}
+export interface CreateFileRenderHandlerLoaderOptions<Rendered = unknown, Target extends HTMLElement = HTMLElement> {
+    handler: FileRenderHandler<Rendered, Target>;
+    getTarget?: (context: RendererLoadContext) => Target;
+    createContext?: (context: RendererLoadContext) => FileRenderContext;
+    destroy?: (rendered: Rendered, context: RendererLoadContext) => void | Promise<void>;
+}
+export interface FileRenderHandlerRendererSession<Rendered = unknown> extends RendererSession {
+    rendered: Rendered;
+}
+export interface DisposeFileViewerRendererSessionOptions {
+    onError?: (error: unknown) => void;
+}
+export interface FileViewerRenderSurfaceState<Session extends RendererSession = RendererSession> {
+    session: Session | null;
+    exportAdapter: FileRenderExportAdapter | null;
+}
+export type MutableFileViewerRenderSurfaceState<Session extends RendererSession = RendererSession> = FileViewerRenderSurfaceState<Session>;
+export interface CreateFileViewerRenderReadinessTargetInput {
+    renderedReady: FileViewerMutableAccessor<boolean>;
+    progressiveReady: FileViewerMutableAccessor<boolean>;
+}
+export interface CreateFileViewerRenderSurfaceStateTargetInput<Session extends RendererSession = RendererSession> {
+    session: FileViewerMutableAccessor<Session | null>;
+    exportAdapter: FileViewerMutableAccessor<FileRenderExportAdapter | null>;
+}
+export interface CreateFileViewerRenderTargetOptions {
+    className?: string;
+}
+export interface ResetFileViewerRenderSurfaceInput<Session extends RendererSession = RendererSession> {
+    surfaceState: MutableFileViewerRenderSurfaceState<Session>;
+    readinessState: MutableFileViewerRenderReadinessState;
+    container?: HTMLElement | null;
+    disposeOptions?: DisposeFileViewerRendererSessionOptions;
+}
+export interface FileViewerRenderSurfaceMountContext<Session extends RendererSession = RendererSession> {
+    buffer: ArrayBuffer;
+    file: File;
+    version: number;
+    type: string;
+    target: HTMLElement;
+    filename: string;
+    sourceUrl?: string;
+    streamUrl?: string;
+    onProgressiveRender: () => void;
+    registerExportAdapter: (adapter: FileRenderExportAdapter | null) => void;
+    surfaceState: MutableFileViewerRenderSurfaceState<Session>;
+    readinessState: MutableFileViewerRenderReadinessState;
+}
+export interface RunFileViewerRenderSurfaceMountInput<Session extends RendererSession = RendererSession> {
+    buffer: ArrayBuffer;
+    file: File;
+    version: number;
+    sourceUrl?: string;
+    streamUrl?: string;
+    getContainer: () => HTMLElement | null | undefined;
+    surfaceState: MutableFileViewerRenderSurfaceState<Session>;
+    readinessState: MutableFileViewerRenderReadinessState;
+    isCurrent: (version: number) => boolean;
+    clearRenderedContent: (reason?: FileViewerLifecycleContext['reason']) => void;
+    render: (context: FileViewerRenderSurfaceMountContext<Session>) => Promise<Session | undefined>;
+    waitForContainer?: () => Promise<unknown> | unknown;
+    waitForPaint?: () => Promise<unknown> | unknown;
+    disposeSession?: (session?: Session | null) => void;
+    onStartZoomObserver?: () => void;
+    onRefreshDocumentIndex?: () => Promise<unknown> | unknown;
+    onRefreshZoomProvider?: () => void;
+}
+export interface RunFileViewerRenderSurfaceClearInput<Session extends RendererSession = RendererSession, UnloadContext = FileViewerLifecycleContext | null> {
+    reason?: FileViewerLifecycleContext['reason'];
+    surfaceState: MutableFileViewerRenderSurfaceState<Session>;
+    readinessState: MutableFileViewerRenderReadinessState;
+    container?: HTMLElement | null;
+    disposeOptions?: DisposeFileViewerRendererSessionOptions;
+    onUnloadStart?: (reason: FileViewerLifecycleContext['reason']) => UnloadContext;
+    onUnloadComplete?: (context: UnloadContext | undefined, reason: FileViewerLifecycleContext['reason']) => void;
+    onClearActiveDocumentContext?: () => void;
+    onClearDocumentState?: () => void;
+    onStopZoomObserver?: () => void;
+    onClearZoomProvider?: () => void;
+}
+export interface FileViewerRenderSurfaceClearState<Session extends RendererSession = RendererSession, UnloadContext = FileViewerLifecycleContext | null> {
+    reason: FileViewerLifecycleContext['reason'];
+    unloadContext: UnloadContext | undefined;
+    session: Session | null | undefined;
+}
+export interface FileViewerRenderSurfaceActionHandlers<Session extends RendererSession = RendererSession, UnloadContext = FileViewerLifecycleContext | null> {
+    destroyRenderSession: (session?: Session | null) => void;
+    setActiveRenderSession: (session: Session | null) => MutableFileViewerRenderSurfaceState<Session>;
+    clearRenderedContent: (reason?: FileViewerLifecycleContext['reason']) => FileViewerRenderSurfaceClearState<Session, UnloadContext>;
+    mountRenderedContent: (buffer: ArrayBuffer, file: File, version: number, sourceUrl?: string, streamUrl?: string) => Promise<Session | undefined>;
+}
+export interface CreateFileViewerRenderSurfaceActionHandlersInput<Session extends RendererSession = RendererSession, UnloadContext = FileViewerLifecycleContext | null> {
+    getContainer: () => HTMLElement | null | undefined;
+    surfaceState: MutableFileViewerRenderSurfaceState<Session>;
+    readinessState: MutableFileViewerRenderReadinessState;
+    isCurrent: (version: number) => boolean;
+    render: (context: FileViewerRenderSurfaceMountContext<Session>) => Promise<Session | undefined>;
+    waitForContainer?: () => Promise<unknown> | unknown;
+    waitForPaint?: () => Promise<unknown> | unknown;
+    disposeOptions?: DisposeFileViewerRendererSessionOptions;
+    onUnloadStart?: (reason: FileViewerLifecycleContext['reason']) => UnloadContext;
+    onUnloadComplete?: (context: UnloadContext | undefined, reason: FileViewerLifecycleContext['reason']) => void;
+    onClearActiveDocumentContext?: () => void;
+    onClearDocumentState?: () => void;
+    onStartZoomObserver?: () => void;
+    onStopZoomObserver?: () => void;
+    onClearZoomProvider?: () => void;
+    onRefreshDocumentIndex?: () => Promise<unknown> | unknown;
+    onRefreshZoomProvider?: () => void;
+}
+export declare const DEFAULT_FILE_VIEWER_RENDER_TARGET_CLASS = "file-render";
+export declare const clearFileViewerRenderSurface: (container?: HTMLElement | null) => void;
+export declare const createFileViewerRenderTarget: (container: HTMLElement, options?: CreateFileViewerRenderTargetOptions) => HTMLDivElement;
+export declare const removeFileViewerRenderTarget: (container: HTMLElement, target: HTMLElement) => boolean;
+export declare const createFileViewerRenderSurfaceState: <Session extends RendererSession = RendererSession>() => FileViewerRenderSurfaceState<Session>;
+export declare const createFileViewerRenderReadinessTarget: ({ renderedReady, progressiveReady, }: CreateFileViewerRenderReadinessTargetInput) => MutableFileViewerRenderReadinessState;
+export declare const createFileViewerRenderSurfaceStateTarget: <Session extends RendererSession = RendererSession>({ session, exportAdapter, }: CreateFileViewerRenderSurfaceStateTargetInput<Session>) => MutableFileViewerRenderSurfaceState<Session>;
+export declare const applyFileViewerRenderSurfaceState: <Session extends RendererSession, Target extends MutableFileViewerRenderSurfaceState<Session>>(target: Target, state: Partial<FileViewerRenderSurfaceState<Session>>) => Target;
+export declare const createFileRenderHandlerRendererSession: <Rendered = unknown>(rendered: Rendered, destroy?: () => void | Promise<void>) => FileRenderHandlerRendererSession<Rendered>;
+export interface CreateFileRenderHandlerRegistryOptions<Rendered = unknown, Target extends HTMLElement = HTMLElement> extends Omit<CreateFileRenderHandlerLoaderOptions<Rendered, Target>, 'handler'> {
+    definitions?: readonly RendererDefinition[];
+    handlers: Iterable<{
+        rendererId: string;
+        handler: FileRenderHandler<Rendered, Target>;
+    }>;
+}
+export interface FileRenderHandlerRegistryResult<Rendered = unknown, Target extends HTMLElement = HTMLElement> {
+    registry: RendererRegistry;
+    dispatcher: FileViewerRendererDispatcher<FileRenderHandler<Rendered, Target>>;
+    missingRendererIds: string[];
+}
+export declare const disposeFileViewerRendered: (rendered?: unknown) => void | Promise<void>;
+export declare const resolveFileViewerRenderSessionDisposeErrorMessage: ({ message, }?: ResolveFileViewerRenderSessionDisposeErrorMessageInput) => string;
+export declare const DEFAULT_FILE_VIEWER_RENDER_SESSION_DISPOSE_ERROR_LOGGER: FileViewerRenderSessionDisposeErrorLogger;
+export declare const reportFileViewerRenderSessionDisposeError: ({ error, onLogError, ...messageInput }: ReportFileViewerRenderSessionDisposeErrorInput) => string;
+export declare const disposeFileViewerRendererSession: (session?: RendererSession | null, options?: DisposeFileViewerRendererSessionOptions) => void;
+export declare const disposeActiveFileViewerRendererSession: <Session extends RendererSession, Target extends MutableFileViewerRenderSurfaceState<Session>>(target: Target, options?: DisposeFileViewerRendererSessionOptions) => Session | null;
+export declare const resetFileViewerRenderSurface: <Session extends RendererSession>({ surfaceState, readinessState, container, disposeOptions, }: ResetFileViewerRenderSurfaceInput<Session>) => Session | null;
+export declare const runFileViewerRenderSurfaceClear: <Session extends RendererSession, UnloadContext = FileViewerLifecycleContext | null>({ reason, surfaceState, readinessState, container, disposeOptions, onUnloadStart, onUnloadComplete, onClearActiveDocumentContext, onClearDocumentState, onStopZoomObserver, onClearZoomProvider, }: RunFileViewerRenderSurfaceClearInput<Session, UnloadContext>) => FileViewerRenderSurfaceClearState<Session, UnloadContext>;
+export declare const runFileViewerRenderSurfaceMount: <Session extends RendererSession>({ buffer, file, version, sourceUrl, streamUrl, getContainer, surfaceState, readinessState, isCurrent, clearRenderedContent, render, waitForContainer, waitForPaint, disposeSession, onStartZoomObserver, onRefreshDocumentIndex, onRefreshZoomProvider, }: RunFileViewerRenderSurfaceMountInput<Session>) => Promise<Session | undefined>;
+export declare const createFileViewerRenderSurfaceActionHandlers: <Session extends RendererSession, UnloadContext = FileViewerLifecycleContext | null>({ getContainer, surfaceState, readinessState, isCurrent, render, waitForContainer, waitForPaint, disposeOptions, onUnloadStart, onUnloadComplete, onClearActiveDocumentContext, onClearDocumentState, onStartZoomObserver, onStopZoomObserver, onClearZoomProvider, onRefreshDocumentIndex, onRefreshZoomProvider, }: CreateFileViewerRenderSurfaceActionHandlersInput<Session, UnloadContext>) => FileViewerRenderSurfaceActionHandlers<Session, UnloadContext>;
+export declare const buildFileRenderContextFromLoadContext: ({ source, options, registerExportAdapter, renderContext, }: RendererLoadContext) => FileRenderContext;
+export declare const renderFileViewerHandler: <Rendered = unknown, Target extends HTMLElement = HTMLElement>({ dispatcher, buffer, target, type, context, throwOnMissingHandler, }: RenderFileViewerHandlerInput<Rendered, Target>) => Promise<Rendered | undefined>;
+export declare const createFileRenderHandlerLoader: <Rendered = unknown, Target extends HTMLElement = HTMLElement>({ handler, getTarget, createContext, destroy, }: CreateFileRenderHandlerLoaderOptions<Rendered, Target>) => RendererLoader;
+export declare const createFileRenderHandlerRegistry: <Rendered = unknown, Target extends HTMLElement = HTMLElement>({ definitions, handlers, getTarget, createContext, destroy, }: CreateFileRenderHandlerRegistryOptions<Rendered, Target>) => FileRenderHandlerRegistryResult<Rendered, Target>;