@univerjs-pro/pdfs-ui 1.0.0-alpha.8

package/lib/types/locale/zh-HK.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/zh-TW.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/menu/pdf-canvas-contextmenu.menu.d.ts

@@ -0,0 +1,9 @@
+import type { IMenuButtonItem } from '@univerjs/ui';
+import type { LocaleKey } from '../locale/types';
+export declare function PdfCanvasAddTextMenuFactory(): IMenuButtonItem<LocaleKey>;
+export declare function PdfCanvasEditTextMenuFactory(): IMenuButtonItem<LocaleKey>;
+export declare function PdfCanvasFlipHorizontalMenuFactory(): IMenuButtonItem<LocaleKey>;
+export declare function PdfCanvasFlipVerticalMenuFactory(): IMenuButtonItem<LocaleKey>;
+export declare function PdfCanvasBringForwardMenuFactory(): IMenuButtonItem<LocaleKey>;
+export declare function PdfCanvasSendBackwardMenuFactory(): IMenuButtonItem<LocaleKey>;
+export declare function PdfCanvasDeleteMenuFactory(): IMenuButtonItem<LocaleKey>;

package/lib/types/menu/pdf-page-thumbnail.menu.d.ts

@@ -0,0 +1,7 @@
+import type { IAccessor } from '@univerjs/core';
+import type { IMenuButtonItem } from '@univerjs/ui';
+export declare const PdfMovePageUpMenuFactory: (accessor: IAccessor) => IMenuButtonItem<string>;
+export declare const PdfMovePageDownMenuFactory: (accessor: IAccessor) => IMenuButtonItem<string>;
+export declare const PdfCopyPageMenuFactory: (accessor: IAccessor) => IMenuButtonItem<string>;
+export declare const PdfRotatePageClockwiseMenuFactory: (accessor: IAccessor) => IMenuButtonItem<string>;
+export declare const PdfDeletePageMenuFactory: (accessor: IAccessor) => IMenuButtonItem<string>;

package/lib/types/menu/pdf-ribbon.menu.d.ts

@@ -0,0 +1,27 @@
+import type { IAccessor } from '@univerjs/core';
+import type { IMenuButtonItem, IMenuSelectorItem } from '@univerjs/ui';
+import type { LocaleKey } from '../locale/types';
+import { PdfListPresetId } from '@univerjs-pro/pdfs';
+export declare const PDF_INSERT_TEXT_BOX_MENU_ID = "pdf.menu.insert.text-box";
+export declare const PDF_INSERT_PARAGRAPH_MENU_ID = "pdf.menu.insert.paragraph";
+export declare const PDF_INSERT_IMAGE_MENU_ID = "pdf.menu.insert.image";
+export declare const PDF_INSERT_DIVIDER_MENU_ID = "pdf.menu.insert.divider";
+export declare const PDF_INSERT_TABLE_MENU_ID = "pdf.menu.insert.table";
+export declare const PDF_INSERT_LIST_MENU_ID = "pdf.menu.insert.list";
+export declare const PDF_INSERT_TABLE_MENU_COMPONENT = "pdf.insert-ribbon.table";
+export declare function PdfUndoMenuFactory(): IMenuButtonItem<LocaleKey>;
+export declare function PdfRedoMenuFactory(): IMenuButtonItem<LocaleKey>;
+export declare function PdfSelectToolMenuFactory(accessor?: IAccessor): IMenuButtonItem<LocaleKey>;
+export declare function PdfTextToolMenuFactory(accessor?: IAccessor): IMenuButtonItem<LocaleKey>;
+export declare function PdfFlipHorizontalMenuFactory(accessor?: IAccessor): IMenuButtonItem<LocaleKey>;
+export declare function PdfFlipVerticalMenuFactory(accessor?: IAccessor): IMenuButtonItem<LocaleKey>;
+export declare function PdfToggleAnnotationsMenuFactory(accessor?: IAccessor): IMenuButtonItem<LocaleKey>;
+export declare function PdfToggleBoundsMenuFactory(accessor?: IAccessor): IMenuButtonItem<LocaleKey>;
+export declare function PdfToggleRawMenuFactory(accessor?: IAccessor): IMenuButtonItem<LocaleKey>;
+export declare function PdfInsertTextBoxMenuFactory(): IMenuButtonItem<LocaleKey>;
+export declare function PdfInsertParagraphMenuFactory(): IMenuButtonItem<LocaleKey>;
+export declare function PdfInsertImageMenuFactory(): IMenuButtonItem<LocaleKey>;
+export declare function PdfInsertDividerMenuFactory(): IMenuButtonItem<LocaleKey>;
+export declare function PdfInsertTableMenuFactory(): IMenuSelectorItem<LocaleKey>;
+export declare function PdfInsertListMenuFactory(): IMenuSelectorItem<LocaleKey, PdfListPresetId, PdfListPresetId>;
+export declare function PdfInsertPageMenuFactory(): IMenuButtonItem<LocaleKey>;

package/lib/types/menu/schema.d.ts

@@ -0,0 +1,4 @@
+import type { MenuSchemaType } from '@univerjs/ui';
+export declare const pdfRibbonSchema: MenuSchemaType;
+export declare const pdfPageThumbnailContextMenuSchema: MenuSchemaType;
+export declare const pdfCanvasContextMenuSchema: MenuSchemaType;

package/lib/types/plugin.d.ts

@@ -0,0 +1,19 @@
+import type { IUniverPdfsUIConfig } from './config/config';
+import { ICommandService, IConfigService, Injector, Plugin, UniverInstanceType } from '@univerjs/core';
+/** Formal UI/runtime plugin for editable PDF Units. */
+export declare class UniverPdfsUIPlugin extends Plugin {
+    private readonly _config;
+    readonly _injector: Injector;
+    private readonly _commandService;
+    private readonly _configService;
+    static pluginName: string;
+    static packageName: string;
+    static version: string;
+    static type: UniverInstanceType;
+    constructor(_config: Partial<IUniverPdfsUIConfig> | undefined, _injector: Injector, _commandService: ICommandService, _configService: IConfigService);
+    onStarting(): void;
+    onReady(): void;
+    onRendered(): void;
+    private _isEditorEnabled;
+    private _initCommands;
+}

package/lib/types/render/canvas-backend.d.ts

@@ -0,0 +1,29 @@
+import type { IPdfGraphicsState, IPdfSourceOperationPathSegment, PdfDisplayListId, PdfRect } from '@univerjs-pro/pdfs';
+import type { IPdfRenderBackend } from '@univerjs-pro/pdfs-render';
+import type { IPdfCanvasGroupCompositor } from './canvas-group-compositor';
+import type { IPdfCanvasFactory } from './canvas-types';
+import type { IPdfFontFamilyResolver } from './decode-manifest';
+import type { IPdfFontOutlineResolver } from './font-outline';
+import type { IPdfImageResolver } from './image-resolver';
+import type { IPdfCanvasSourceSuppressionMatcher } from './source-suppression';
+import type { IPdfCanvasViewport } from './viewport';
+export interface IPdfCanvasBackendOptions {
+    imageResolver?: IPdfImageResolver;
+    fontFamilyResolver?: IPdfFontFamilyResolver;
+    fontOutlineResolver?: IPdfFontOutlineResolver;
+    canvasFactory?: IPdfCanvasFactory;
+    groupCompositor?: IPdfCanvasGroupCompositor | null;
+    enableTransparencyGroups?: boolean;
+    sourceSuppressionMatcher?: IPdfCanvasSourceSuppressionMatcher;
+    operationPath?: IPdfSourceOperationPathSegment[];
+    currentDisplayListId?: PdfDisplayListId;
+}
+interface ICanvasBackendGraphicsState {
+    fillAlpha: number;
+    opacityMultiplier: number;
+    strokeAlpha: number;
+    softMask?: IPdfGraphicsState['softMask'];
+}
+export declare function createCanvas2DPdfRenderBackend(context: CanvasRenderingContext2D, viewport: IPdfCanvasViewport, options?: IPdfCanvasBackendOptions, inheritedGraphicsState?: Readonly<ICanvasBackendGraphicsState>): IPdfRenderBackend;
+export declare function rectToCanvas(rect: PdfRect, viewport: IPdfCanvasViewport): [number, number, number, number];
+export {};

package/lib/types/render/canvas-group-compositor.d.ts

@@ -0,0 +1,54 @@
+import type { IPdfPage, IPdfSoftMaskState, PdfJsonValue, PdfRectPt } from '@univerjs-pro/pdfs';
+import type { IPdfBackendFormXObjectContext } from '@univerjs-pro/pdfs-render';
+import type { IPdfCanvasFactory } from './canvas-types';
+import type { IPdfCanvasViewport } from './viewport';
+export interface IPdfCanvasGroupMetadata {
+    subtype?: string;
+    isolated?: boolean;
+    knockout?: boolean;
+    raw?: Record<string, PdfJsonValue>;
+}
+export interface IPdfCanvasGroupCompositeParams {
+    context: CanvasRenderingContext2D;
+    viewport: IPdfCanvasViewport;
+    formContext: IPdfBackendFormXObjectContext;
+    formBBox: PdfRectPt;
+    blendMode: string;
+    opacity?: number;
+    group?: IPdfCanvasGroupMetadata;
+    renderGroup(context: CanvasRenderingContext2D): void;
+}
+export interface IPdfCanvasSoftMaskCompositeParams {
+    context: CanvasRenderingContext2D;
+    viewport: IPdfCanvasViewport;
+    page: IPdfPage;
+    softMask: IPdfSoftMaskState;
+    blendMode: string;
+    renderSource(context: CanvasRenderingContext2D): void;
+    renderMask(context: CanvasRenderingContext2D): void;
+}
+export interface IPdfCanvasGroupCompositor {
+    compositeFormXObject(params: IPdfCanvasGroupCompositeParams): boolean;
+    compositeSoftMask(params: IPdfCanvasSoftMaskCompositeParams): boolean;
+}
+export interface IPdfCanvasGroupCompositorOptions {
+    canvasFactory?: IPdfCanvasFactory;
+}
+export interface IPdfGroupPixelBlendOptions {
+    blendMode: string;
+    opacity?: number;
+    /**
+     * @deprecated PDF blend modes apply against any opaque backdrop color,
+     * including white. This option is kept only so older callers do not break.
+     */
+    backdropWhiteThreshold?: number;
+    sourceAlphaThreshold?: number;
+}
+export interface IPdfSoftMaskImageDataOptions {
+    subtype?: string;
+}
+export declare function createCanvasGroupCompositor(options?: IPdfCanvasGroupCompositorOptions): IPdfCanvasGroupCompositor;
+export declare function createDefaultPdfCanvasFactory(): IPdfCanvasFactory | undefined;
+export declare function createPdfCanvasGroupMetadata(raw: Record<string, PdfJsonValue> | undefined): IPdfCanvasGroupMetadata | undefined;
+export declare function blendGroupImageDataIntoBackdrop(backdrop: ImageData, source: ImageData, options: IPdfGroupPixelBlendOptions): ImageData;
+export declare function applySoftMaskImageDataToSource(source: ImageData, mask: ImageData, options?: IPdfSoftMaskImageDataOptions): ImageData;

package/lib/types/render/canvas-renderer.d.ts

@@ -0,0 +1,29 @@
+import type { IPdfDocument, IPdfSourceSuppression, PdfObjectId } from '@univerjs-pro/pdfs';
+import type { IPdfRenderScheduler } from '@univerjs-pro/pdfs-render';
+import type { IPdfCanvasGroupCompositor } from './canvas-group-compositor';
+import type { IPdfCanvasFactory } from './canvas-types';
+import type { IPdfFontFamilyResolver, IPdfPageRasterResolver } from './decode-manifest';
+import type { IPdfFontOutlineResolver } from './font-outline';
+import type { IPdfImageResolver } from './image-resolver';
+import type { IPdfCanvasViewport, IPdfCanvasViewportOptions } from './viewport';
+export interface IPdfCanvasRenderOptions extends IPdfCanvasViewportOptions {
+    background?: string;
+    showPageBoundary?: boolean;
+    showRawObjects?: boolean;
+    showAnnotations?: boolean;
+    showAnnotationBounds?: boolean;
+    imageResolver?: IPdfImageResolver;
+    fontFamilyResolver?: IPdfFontFamilyResolver;
+    fontOutlineResolver?: IPdfFontOutlineResolver;
+    pageRasterResolver?: IPdfPageRasterResolver;
+    canvasFactory?: IPdfCanvasFactory;
+    groupCompositor?: IPdfCanvasGroupCompositor | null;
+    enableTransparencyGroups?: boolean;
+    preferPageRaster?: boolean;
+    scheduler?: IPdfRenderScheduler;
+    suppressedDisplayOperationIds?: Iterable<string>;
+    suppressedObjectIds?: ReadonlySet<PdfObjectId>;
+    sourceSuppressions?: Iterable<IPdfSourceSuppression>;
+}
+export declare function renderPdfDocumentToCanvas(document: IPdfDocument, canvas: HTMLCanvasElement, options?: IPdfCanvasRenderOptions): IPdfCanvasViewport;
+export declare function renderPdfPageToCanvas(document: IPdfDocument, pageId: string, canvas: HTMLCanvasElement, options?: IPdfCanvasRenderOptions): IPdfCanvasViewport;

package/lib/types/render/canvas-shading.d.ts

@@ -0,0 +1,12 @@
+import type { IPdfPage, IPdfShadingAsset, PdfMatrix } from '@univerjs-pro/pdfs';
+import type { IPdfCanvasViewport } from './viewport';
+export interface ICanvasShadingAssetDrawParams {
+    asset: IPdfShadingAsset | undefined;
+    matrix: PdfMatrix | undefined;
+    page: IPdfPage;
+    context: CanvasRenderingContext2D;
+    viewport: IPdfCanvasViewport;
+}
+export type CanvasShadingFillStyle = string | CanvasGradient;
+export declare function drawCanvasShadingAsset(params: ICanvasShadingAssetDrawParams): void;
+export declare function createCanvasShadingFillStyle(params: ICanvasShadingAssetDrawParams): CanvasShadingFillStyle | undefined;

package/lib/types/render/canvas-text.d.ts

@@ -0,0 +1,15 @@
+import type { IPdfBackendTextContext } from '@univerjs-pro/pdfs-render';
+import type { IPdfFontFamilyResolver } from './decode-manifest';
+import type { IPdfFontOutlineResolver } from './font-outline';
+import type { IPdfCanvasViewport } from './viewport';
+export interface IPdfCanvasTextRenderOptions {
+    fontFamilyResolver?: IPdfFontFamilyResolver;
+    fontOutlineResolver?: IPdfFontOutlineResolver;
+}
+export interface ICanvasTextOperationDrawParams {
+    textContext: IPdfBackendTextContext;
+    context: CanvasRenderingContext2D;
+    viewport: IPdfCanvasViewport;
+    options?: IPdfCanvasTextRenderOptions;
+}
+export declare function drawCanvasTextOperation(params: ICanvasTextOperationDrawParams): void;

package/lib/types/render/canvas-types.d.ts

@@ -0,0 +1,3 @@
+export interface IPdfCanvasFactory {
+    createCanvas(width: number, height: number): HTMLCanvasElement | undefined;
+}

package/lib/types/render/decode-manifest.d.ts

@@ -0,0 +1,210 @@
+import type { IPdfDocument, IPdfFontAsset, IPdfPage, IPdfTextRun, PdfAssetId } from '@univerjs-pro/pdfs';
+import type { IPdfImageResolver } from './image-resolver';
+import type { IPdfFontOutline, IPdfFontOutlineResolver } from './font-outline';
+import type { IPdfCanvasViewport } from './viewport';
+export interface IPdfLocalDecodeManifest {
+    /** Stable marker used to distinguish this file from qpdf JSON and Univer PDF model JSON. */
+    schema: 'univer-pdf-decode-manifest';
+    /** Manifest schema version. Increment this when entry shapes become incompatible. */
+    schemaVersion: 1;
+    /** Optional model document id that this decode output belongs to. */
+    documentId?: string;
+    /** Original PDF file name, kept for diagnostics and human inspection. */
+    sourceFileName?: string;
+    /** ISO timestamp generated by the local batch decoder or future backend worker. */
+    generatedAt: string;
+    /** Decoder provenance. This lets the frontend reason about local, worker, and backend outputs uniformly. */
+    decoder: {
+        kind: 'local-batch' | 'go-local' | 'worker' | 'backend';
+        tools?: Record<string, string>;
+    };
+    /** Page-level decoded rasters keyed by page id whenever the model page ids are known. */
+    pageRasters: Record<string, IPdfDecodedPageRasterEntry>;
+    /** Image-level decoded assets keyed by PDF model image asset id. */
+    imageAssets: Record<string, IPdfDecodedImageAssetEntry>;
+    /** Font-face assets keyed by PDF model font id when a decoder can create a browser-loadable font. */
+    fontFaces?: Record<string, IPdfDecodedFontFaceEntry>;
+    /** Non-fatal limitations or fallbacks used while producing the manifest. */
+    warnings?: string[];
+}
+export interface IPdfDecodedPageRasterEntry {
+    /** Asset category discriminator for page raster entries. */
+    kind: 'pageRaster';
+    /** Target page id in IPdfDocument.pages. */
+    pageId: string;
+    /** Zero-based page index for fallback matching when page ids are unavailable. */
+    pageIndex: number;
+    /** Decode status. Failed entries are retained for diagnostics but skipped by the renderer. */
+    status: 'decoded' | 'failed';
+    /** Browser-loadable image encoding. */
+    format?: 'png' | 'jpeg' | 'webp';
+    /** Manifest-relative asset URL for served files. */
+    href?: string;
+    /** Embedded asset payload for file-input demos and offline previews. */
+    dataUrl?: string;
+    /** Decoded raster width in pixels. */
+    width?: number;
+    /** Decoded raster height in pixels. */
+    height?: number;
+    /** Decode resolution. The renderer stretches to the PDF viewport, so this is diagnostic for now. */
+    dpi?: number;
+    /** Failure reason when status is failed. */
+    error?: string;
+}
+export interface IPdfDecodedImageAssetEntry {
+    /** Asset category discriminator for image XObject and inline image entries. */
+    kind: 'image';
+    /** Target image asset id in the IPdfDocument asset table. */
+    assetId: string;
+    /** Decode status, including page-raster coverage while object-level extraction is unavailable. */
+    status: 'decoded' | 'covered-by-page-raster' | 'pending' | 'failed';
+    /** Browser-loadable image encoding after stream filters and color transforms are decoded. */
+    format?: 'png' | 'jpeg' | 'webp';
+    /** Manifest-relative asset URL for served files. */
+    href?: string;
+    /** Embedded asset payload for file-input demos and offline previews. */
+    dataUrl?: string;
+    /** Decoded image width in pixels. */
+    width?: number;
+    /** Decoded image height in pixels. */
+    height?: number;
+    /** Original PDF object reference such as "12 0 R", when known. */
+    objectRef?: string;
+    /** Resource dictionary name such as "Im1", when known. */
+    resourceName?: string;
+    /** Decoder path used for this asset, useful for diagnostics and future cache invalidation. */
+    decodeMethod?: 'pdfimages' | 'jbig2dec' | 'qdf-dct-stream' | 'qdf-dct-stream-cmyk-to-rgb' | 'qdf-raw-image-stream' | 'page-raster-crop' | 'pdfium-page-raster-crop' | 'custom';
+    /** Source PDF filter/encoding reported by the decoder, such as "ccitt", "jbig2", or "image". */
+    sourceEncoding?: string;
+    /** Image asset id for an explicit PDF `/Mask` image when this entry has been pre-composed by the decoder. */
+    maskAssetId?: string;
+    /** Image asset id for a PDF `/SMask` soft mask when this entry has been pre-composed by the decoder. */
+    softMaskAssetId?: string;
+    /**
+     * Alpha or stencil source that has already been resolved into this browser-loadable image.
+     *
+     * Front-end renderers should treat entries with values other than `none` as already
+     * composed and avoid applying PDF mask logic again.
+     */
+    alphaSource?: PdfDecodedImageAlphaSource;
+    /** Failure or fallback reason for diagnostics. */
+    error?: string;
+}
+export type PdfDecodedImageAlphaSource = 'decoded-alpha' | 'soft-mask' | 'image-mask' | 'color-key' | 'none';
+export type PdfDecodedFontFaceDecodeMethod = 
+/** PDFium returned an already browser-loadable OpenType/TrueType/WOFF container. */
+'pdfium-font-data'
+/** PDFium returned raw CFF/CIDFontType0C data and the Go decoder wrapped it as OTF. */
+ | 'pdfium-cff-to-otf'
+/** PDFium exposed CFF glyph outlines and the decoder rebuilt them into a sanitizer-safe OTF. */
+ | 'pdfium-cff-glyphs-to-otf'
+/** PDFium exposed Type1 glyph outlines and the decoder rebuilt them into a sanitizer-safe OTF. */
+ | 'pdfium-type1-glyphs-to-otf'
+/** PDFium exposed TrueType glyph outlines and the decoder rebuilt them into a sanitizer-safe OTF. */
+ | 'pdfium-truetype-glyphs-to-otf'
+/** QDF exposed raw CFF data and the decoder wrapped it as OTF. */
+ | 'qdf-cff-to-otf'
+/** QDF exposed the original TrueType stream and the decoder repacked sfnt tables for browser sanitizer compatibility. */
+ | 'qdf-truetype-sfnt-repack'
+/** QDF exposed an OpenType sfnt and the decoder realigned its table directory for browser sanitizer compatibility. */
+ | 'qdf-opentype-sfnt-repack'
+/** PDFium exposed TrueType data and the decoder repacked sfnt tables for browser sanitizer compatibility. */
+ | 'pdfium-truetype-sfnt-repack'
+/** PDFium exposed OpenType data and the decoder realigned its table directory for browser sanitizer compatibility. */
+ | 'pdfium-opentype-sfnt-repack'
+/** The decoder found raw font bytes but no suitable open-source conversion path is wired yet. */
+ | 'unsupported-font-program'
+/** Legacy/local-batch spelling for CFF wrapping kept for older manifests. */
+ | 'cff-to-otf'
+/** Future Type1 conversion path once a dedicated converter is added. */
+ | 'type1-to-otf'
+/** Future direct TrueType stream extraction path when it does not come from PDFium font data. */
+ | 'ttf'
+/** Escape hatch for one-off or experimental local decoders. */
+ | 'custom';
+export interface IPdfDecodedFontFaceEntry {
+    /** Asset category discriminator for browser-loadable decoded fonts. */
+    kind: 'fontFace';
+    /** Target model font id. For Type0 fonts this can be either the composite id or a descendant CID font id. */
+    fontId: PdfAssetId;
+    /** Decode status. Failed entries are retained for diagnostics and skipped by the renderer. */
+    status: 'decoded' | 'pending' | 'failed';
+    /** CSS font-family name registered for this decoded font. */
+    fontFamily?: string;
+    /** Browser-loadable font container produced by the decoder. */
+    format?: 'otf' | 'ttf' | 'woff' | 'woff2';
+    /** Manifest-relative asset URL for served font files. */
+    href?: string;
+    /** Embedded font payload for file-input demos and offline previews. */
+    dataUrl?: string;
+    /** Raw PDF stream asset id that produced this decoded font face. */
+    sourceStreamAssetId?: PdfAssetId;
+    /** Original embedded font program retained for front-end hinting or future rasterizers. */
+    sourceProgram?: IPdfDecodedFontSourceProgramEntry;
+    /** Original PDF object reference for diagnostics. */
+    objectRef?: string;
+    /** Decoder path used for this asset. */
+    decodeMethod?: PdfDecodedFontFaceDecodeMethod;
+    /** Failure reason when status is failed. */
+    error?: string;
+}
+export interface IPdfDecodedFontSourceProgramEntry {
+    /** Resource binding id. This normally matches the model font's fontFileStreamAssetId. */
+    assetId: PdfAssetId;
+    /** Retention status; a failed entry does not invalidate the browser-loadable decoded face. */
+    status: 'decoded' | 'failed';
+    /** Original embedded program kind. */
+    format?: 'type1';
+    /** Manifest-relative URL for local and backend-served manifests. */
+    href?: string;
+    /** Optional inline source for offline fixtures. */
+    dataUrl?: string;
+    /** Failure reason when the original program could not be retained. */
+    error?: string;
+}
+export interface IPdfFontFamilyResolverContext {
+    /** Current model document. */
+    document: IPdfDocument;
+    /** Font asset referenced by the text run. */
+    font: IPdfFontAsset;
+    /** Text run being rendered. */
+    run: IPdfTextRun;
+}
+export type IPdfFontFamilyResolver = (context: IPdfFontFamilyResolverContext) => string | undefined;
+export type PdfDecodedFontFaceMatchKind = 'direct' | 'descendant' | 'source-stream' | 'family';
+export interface IPdfDecodedFontFaceMatch {
+    entry: IPdfDecodedFontFaceEntry;
+    matchKind: PdfDecodedFontFaceMatchKind;
+    rank: number;
+}
+export interface IPdfPageRasterResolverContext {
+    /** Current model document. */
+    document: IPdfDocument;
+    /** Current page being rendered. */
+    page: IPdfPage;
+    /** Canvas viewport after PDF point units are mapped to CSS pixels. */
+    viewport: IPdfCanvasViewport;
+}
+export interface IPdfResolvedPageRaster {
+    /** Runtime-loaded image source that canvas can draw. */
+    source: CanvasImageSource;
+    /** Manifest entry that produced this source. */
+    entry: IPdfDecodedPageRasterEntry;
+}
+export type PdfPageRasterResolverResult = CanvasImageSource | IPdfResolvedPageRaster | undefined;
+/** Resolves a decoded page raster for a page render. */
+export type IPdfPageRasterResolver = (context: IPdfPageRasterResolverContext) => PdfPageRasterResolverResult;
+export interface IPdfDecodeManifestResolverOptions {
+    /** Runtime image objects keyed by page id or manifest href. */
+    pageRasterSources?: Record<string, CanvasImageSource>;
+    /** Runtime image objects keyed by image asset id, manifest href, or data URL. */
+    imageSources?: Record<string, CanvasImageSource>;
+    /** Parsed Type1 outlines keyed by font id, manifest href, data URL, or decoded family. */
+    fontOutlines?: Record<string, IPdfFontOutline>;
+}
+export declare function createPdfDecodeManifestPageRasterResolver(manifest: IPdfLocalDecodeManifest, options?: IPdfDecodeManifestResolverOptions): IPdfPageRasterResolver;
+export declare function getResolvedPageRasterSource(result: PdfPageRasterResolverResult): CanvasImageSource | undefined;
+export declare function createPdfDecodeManifestImageResolver(manifest: IPdfLocalDecodeManifest, options?: IPdfDecodeManifestResolverOptions): IPdfImageResolver;
+export declare function createPdfDecodeManifestFontFamilyResolver(manifest: IPdfLocalDecodeManifest): IPdfFontFamilyResolver;
+export declare function createPdfDecodeManifestFontOutlineResolver(manifest: IPdfLocalDecodeManifest, options?: IPdfDecodeManifestResolverOptions): IPdfFontOutlineResolver;
+export declare function resolveDecodedFontFaceMatch(font: IPdfFontAsset, manifest: IPdfLocalDecodeManifest, document?: IPdfDocument): IPdfDecodedFontFaceMatch | undefined;

package/lib/types/render/document-json.d.ts

@@ -0,0 +1,3 @@
+import type { IPdfDocument } from '@univerjs-pro/pdfs';
+export declare function parsePdfDocumentJsonText(text: string): IPdfDocument;
+export declare function assertPdfDocumentJson(value: unknown): IPdfDocument;

package/lib/types/render/document-object-renderer.d.ts

@@ -0,0 +1,21 @@
+import type { IPdfDocument, PdfObjectId } from '@univerjs-pro/pdfs';
+import type { IPdfFontFamilyResolver } from './decode-manifest';
+import type { IPdfFontOutlineResolver } from './font-outline';
+import type { IPdfImageResolver } from './image-resolver';
+import type { IPdfCanvasViewport } from './viewport';
+export interface IPdfDocumentObjectRenderOptions {
+    document: IPdfDocument;
+    pageId: string;
+    context: CanvasRenderingContext2D;
+    viewport: IPdfCanvasViewport;
+    imageResolver?: IPdfImageResolver;
+    fontFamilyResolver?: IPdfFontFamilyResolver;
+    fontOutlineResolver?: IPdfFontOutlineResolver;
+    suppressedObjectIds?: ReadonlySet<PdfObjectId>;
+}
+/**
+ * Render persisted semantic/editable page objects as part of the normal
+ * document render path. Editor-only affordances such as selection, handles, and
+ * active text state stay in the overlay renderer.
+ */
+export declare function renderPdfDocumentPageObjectsToCanvas(options: IPdfDocumentObjectRenderOptions): void;

package/lib/types/render/font-outline.d.ts

@@ -0,0 +1,27 @@
+import type { IPdfDocument, IPdfFontAsset, IPdfTextRun } from '@univerjs-pro/pdfs';
+export interface IPdfFontOutlinePathCommand {
+    type: 'M' | 'L' | 'C' | 'Q' | 'Z';
+    x?: number;
+    y?: number;
+    x1?: number;
+    y1?: number;
+    x2?: number;
+    y2?: number;
+}
+export interface IPdfFontOutline {
+    charToGlyph: (character: string) => {
+        index: number;
+    };
+    getPath: (text: string, x: number, y: number, fontSize: number) => {
+        commands: IPdfFontOutlinePathCommand[];
+    };
+}
+export interface IPdfFontOutlineResolverContext {
+    document: IPdfDocument;
+    font: IPdfFontAsset;
+    run: IPdfTextRun;
+}
+export type IPdfFontOutlineResolver = (context: IPdfFontOutlineResolverContext) => IPdfFontOutline | undefined;
+export declare function parsePdfFontOutline(data: ArrayBuffer): IPdfFontOutline;
+export declare function isPdfType1FontAsset(font: IPdfFontAsset | undefined): boolean;
+export declare function tracePdfFontOutlineText(context: CanvasRenderingContext2D, outline: IPdfFontOutline, text: string, x: number, y: number, fontSize: number): boolean;

package/lib/types/render/font-render-report.d.ts

@@ -0,0 +1,71 @@
+import type { IPdfDocument, IPdfFontAsset, PdfAssetId } from '@univerjs-pro/pdfs';
+import type { IPdfDecodedFontFaceEntry, IPdfLocalDecodeManifest, PdfDecodedFontFaceMatchKind } from './decode-manifest';
+export interface IPdfFontRenderReportOptions {
+    decodeManifest?: IPdfLocalDecodeManifest;
+}
+export interface IPdfFontRenderReport {
+    schema: 'univer-pdf-font-render-report';
+    schemaVersion: 1;
+    documentId: string;
+    totals: IPdfFontRenderReportTotals;
+    fonts: IPdfFontRenderReportFont[];
+    textRuns: IPdfFontRenderReportTextRun[];
+}
+export interface IPdfFontRenderReportTotals {
+    fontAssets: number;
+    embeddedFonts: number;
+    decodedFontFaces: number;
+    textOps: number;
+    textRuns: number;
+    glyphRuns: number;
+    textRunsUsingDecodedFontFace: number;
+    textRunsUsingFallbackFont: number;
+    missingFontAssets: number;
+    fontsRequiringCMap: number;
+    fontsRequiringGlyphProgram: number;
+    fontsRequiringShaping: number;
+}
+export interface IPdfFontRenderReportFont {
+    fontId: PdfAssetId;
+    family?: string;
+    postScriptName?: string;
+    pdfSubtype?: string;
+    fontProgramKind?: string;
+    embedded: boolean;
+    subset?: boolean;
+    descendantFontIds?: PdfAssetId[];
+    diagnostics?: IPdfFontAsset['diagnostics'];
+    decodedFontFace?: IPdfFontRenderReportDecodedFontFace;
+    decodeReadiness: IPdfFontDecodeReadiness;
+    referencedByTextRuns: number;
+    glyphRunCount: number;
+    renderStatus: IPdfFontRenderStatus;
+}
+export interface IPdfFontRenderReportDecodedFontFace {
+    fontId: PdfAssetId;
+    fontFamily?: string;
+    format?: IPdfDecodedFontFaceEntry['format'];
+    decodeMethod?: IPdfDecodedFontFaceEntry['decodeMethod'];
+    sourceStreamAssetId?: PdfAssetId;
+    matchKind: PdfDecodedFontFaceMatchKind;
+}
+export interface IPdfFontRenderReportTextRun {
+    displayListId: string;
+    opId: string;
+    runIndex: number;
+    textLength: number;
+    fontId?: PdfAssetId;
+    fontFamily?: string;
+    glyphCount?: number;
+    sourceCodeCount?: number;
+    renderStatus: IPdfFontRenderStatus;
+    decodedFontFaceFontId?: PdfAssetId;
+}
+export type IPdfFontRenderStatus = 'decoded-font-face' | 'fallback-css-font' | 'missing-font-asset' | 'no-font-reference';
+export type IPdfFontDecodeReadinessStatus = 'decoded-font-face' | 'needs-decoded-font-face' | 'needs-cmap' | 'needs-type3-charproc-rendering' | 'ready-or-fallback';
+export type IPdfFontDecodeRecommendedAction = 'none' | 'decode-cff-cidfonttype0c-to-otf' | 'parse-cmap-or-to-unicode' | 'render-type3-charproc-display-list';
+export interface IPdfFontDecodeReadiness {
+    status: IPdfFontDecodeReadinessStatus;
+    recommendedAction: IPdfFontDecodeRecommendedAction;
+}
+export declare function createPdfFontRenderReport(document: IPdfDocument, options?: IPdfFontRenderReportOptions): IPdfFontRenderReport;

package/lib/types/render/image-resolver.d.ts

@@ -0,0 +1,30 @@
+import type { IPdfDocument, IPdfImageAsset, PdfDisplayOperation } from '@univerjs-pro/pdfs';
+import type { IPdfCanvasViewport } from './viewport';
+/**
+ * Resolved image payload consumed by the canvas renderer.
+ *
+ * The resolver may return this wrapper when it wants to attach derived sizing
+ * or diagnostics without changing the model asset.
+ */
+export interface IPdfResolvedImage {
+    source: CanvasImageSource;
+    width?: number;
+    height?: number;
+}
+/**
+ * Context passed to the front-end image resolver.
+ *
+ * The model keeps raw PDF stream metadata; this resolver only provides already
+ * decoded, canvas-compatible image sources for display operations.
+ */
+export interface IPdfImageResolverContext {
+    document: IPdfDocument;
+    asset: IPdfImageAsset;
+    op: Extract<PdfDisplayOperation, {
+        type: 'image';
+    }>;
+    viewport: IPdfCanvasViewport;
+}
+export type PdfImageResolverResult = CanvasImageSource | IPdfResolvedImage | undefined;
+export type IPdfImageResolver = (context: IPdfImageResolverContext) => PdfImageResolverResult;
+export declare function getResolvedImageSource(result: PdfImageResolverResult): CanvasImageSource | undefined;

package/lib/types/render/pdf-canvas-render-session.d.ts

@@ -0,0 +1,34 @@
+import type { IPdfDocument } from '@univerjs-pro/pdfs';
+import type { IPdfPageWindowPlan, IPdfRenderCacheSnapshot, IPdfRenderTaskResult } from '@univerjs-pro/pdfs-render';
+import type { IPdfCanvasRenderOptions } from './canvas-renderer';
+import type { IPdfCanvasViewport } from './viewport';
+export interface IPdfCanvasRenderSessionOptions {
+    bufferBefore?: number;
+    bufferAfter?: number;
+    maxCacheEntries?: number;
+    maxCacheBytes?: number;
+}
+export interface IPdfCanvasRenderTaskDiagnostics {
+    taskId: string;
+    planId: string;
+    status: IPdfRenderTaskResult['status'];
+    cacheKey: string;
+    opCount: number;
+    byteSize: number;
+}
+export interface IPdfCanvasRenderDiagnostics {
+    pageWindow: IPdfPageWindowPlan;
+    cache: IPdfRenderCacheSnapshot;
+    scheduledTaskCount: number;
+    lastTask?: IPdfCanvasRenderTaskDiagnostics;
+}
+export interface IPdfCanvasRenderResult {
+    viewport: IPdfCanvasViewport;
+    diagnostics: IPdfCanvasRenderDiagnostics;
+}
+export interface IPdfCanvasRenderSession {
+    renderPage(document: IPdfDocument, pageId: string, canvas: HTMLCanvasElement, options?: Omit<IPdfCanvasRenderOptions, 'scheduler'>): IPdfCanvasRenderResult;
+    getDiagnostics(): IPdfCanvasRenderDiagnostics;
+    reset(): void;
+}
+export declare function createPdfCanvasRenderSession(options?: IPdfCanvasRenderSessionOptions): IPdfCanvasRenderSession;