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

package/lib/types/commands/operations/pdf-page-thumbnail.operation.d.ts

@@ -0,0 +1,7 @@
+import type { ICommand } from '@univerjs/core';
+export declare const PdfMovePageUpOperation: ICommand<object, boolean>;
+export declare const PdfMovePageDownOperation: ICommand<object, boolean>;
+export declare const PdfCopyPageOperation: ICommand<object, boolean>;
+export declare const PdfRotatePageClockwiseOperation: ICommand<object, boolean>;
+export declare const PdfDeletePageOperation: ICommand<object, boolean>;
+export declare const PDF_PAGE_THUMBNAIL_OPERATIONS: ICommand[];

package/lib/types/config/config.d.ts

@@ -0,0 +1,13 @@
+/** Configuration for the formal PDF UI plugin. */
+export interface IUniverPdfsUIConfig {
+    editor: {
+        /** Creates local editor runtime state and editing controllers. */
+        enabled: boolean;
+    };
+    /** Module worker entry used for OffscreenCanvas page-thumbnail rendering. */
+    thumbnailWorkerURL?: string | URL | Worker;
+}
+export declare const PDFS_UI_PLUGIN_CONFIG_KEY = "pdfs-ui.config";
+export declare const configSymbol: unique symbol;
+export declare const defaultPluginConfig: IUniverPdfsUIConfig;
+export declare const defaultPdfsUIPluginConfig: IUniverPdfsUIConfig;

package/lib/types/context-menu/pdf-context-menu-position.d.ts

@@ -0,0 +1,5 @@
+/** Context-menu surfaces owned by the PDF UI package. */
+export declare enum PdfContextMenuPosition {
+    CANVAS = "pdfs.contextMenu.canvas",
+    PAGE_THUMBNAIL = "pdfs.contextMenu.page-thumbnail"
+}

package/lib/types/controllers/components.controller.d.ts

@@ -0,0 +1,9 @@
+import { Disposable } from '@univerjs/core';
+import { ComponentManager, IconManager } from '@univerjs/ui';
+export declare class ComponentsController extends Disposable {
+    private readonly _componentManager;
+    private readonly _iconManager;
+    constructor(_componentManager: ComponentManager, _iconManager: IconManager);
+    private _registerComponents;
+    private _registerIcons;
+}

package/lib/types/controllers/pdf-editor-unit.controller.d.ts

@@ -0,0 +1,15 @@
+import { ICommandService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import { IPdfEditorRuntimeService } from '../services/pdf-editor-runtime.service';
+import { IPdfPageRegionIndexService } from '../services/pdf-page-region-index.service';
+/**
+ * Binds client-only PDF editor runtime state to the formal PDF Unit lifecycle.
+ * Unit disposal is the sole owner of runtime cleanup at this boundary.
+ */
+export declare class PdfEditorUnitController extends RxDisposable {
+    private readonly _instanceService;
+    private readonly _runtimeService;
+    private readonly _pageRegionService;
+    private readonly _commandService;
+    constructor(_instanceService: IUniverInstanceService, _runtimeService: IPdfEditorRuntimeService, _pageRegionService: IPdfPageRegionIndexService, _commandService: ICommandService);
+    private _init;
+}

package/lib/types/controllers/pdf-inspector.controller.d.ts

@@ -0,0 +1,12 @@
+import { Disposable, IUniverInstanceService, LocaleService } from '@univerjs/core';
+import { ISidebarService } from '@univerjs/ui';
+/** Keeps the standard Univer right sidebar attached to the active PDF Unit. */
+export declare class PdfInspectorController extends Disposable {
+    private readonly _sidebarService;
+    private readonly _localeService;
+    private _panel;
+    private _unitId;
+    constructor(instanceService: IUniverInstanceService, _sidebarService: ISidebarService, _localeService: LocaleService);
+    dispose(): void;
+    private _setUnit;
+}

package/lib/types/controllers/pdf-page-thumbnail-contextmenu.controller.d.ts

@@ -0,0 +1,8 @@
+import { Disposable, ICommandService } from '@univerjs/core';
+import { IMenuManagerService } from '@univerjs/ui';
+/** Registers the PDF page-rail menu and its operations in one UI scope. */
+export declare class PdfPageThumbnailContextMenuController extends Disposable {
+    private readonly _menuManagerService;
+    private readonly _commandService;
+    constructor(_menuManagerService: IMenuManagerService, _commandService: ICommandService);
+}

package/lib/types/controllers/pdf-ribbon.controller.d.ts

@@ -0,0 +1,6 @@
+import { Disposable } from '@univerjs/core';
+import { IMenuManagerService } from '@univerjs/ui';
+/** Adds PDF actions to the standard Univer ribbon. */
+export declare class PdfRibbonController extends Disposable {
+    constructor(menuManagerService: IMenuManagerService);
+}

package/lib/types/controllers/pdf-ui.controller.d.ts

@@ -0,0 +1,9 @@
+import { Disposable, Injector } from '@univerjs/core';
+import { IUIPartsService } from '@univerjs/ui';
+/** Registers PDF views in the standard Univer workbench. */
+export declare class PdfUIController extends Disposable {
+    private readonly _injector;
+    private readonly _uiPartsService;
+    constructor(_injector: Injector, _uiPartsService: IUIPartsService);
+    private _registerWorkbenchParts;
+}

package/lib/types/editor/TextColorPicker.d.ts

@@ -0,0 +1,11 @@
+export interface IPdfEditorTextColorPickerProps {
+    value: string;
+    ariaLabel: string;
+    onChange: (color: string) => void;
+}
+export interface IPdfEditorTextColorPickerHost {
+    dispose(): void;
+}
+/** Mounts the shared Univer color picker into a non-React inspector host. */
+export declare function renderPdfEditorTextColorPicker(container: HTMLElement, props: IPdfEditorTextColorPickerProps): IPdfEditorTextColorPickerHost;
+export declare function PdfEditorTextColorPicker({ value, ariaLabel, onChange }: IPdfEditorTextColorPickerProps): import("react").JSX.Element;

package/lib/types/editor/canvas-text-edit-bridge.d.ts

@@ -0,0 +1,23 @@
+import type { IPdfDocument, IPdfEditorCommandResult, IPdfEditorSession, PdfPoint } from '@univerjs-pro/pdfs';
+import type { IPdfCanvasViewport } from '../render/viewport';
+import type { IPdfCanvasTextEditController, IPdfCanvasTextEditKeyInput, IPdfCanvasTextEditStartInput, IPdfCanvasTextEditState } from './canvas-text-editor';
+export interface IPdfCanvasTextEditPointInput {
+    session: IPdfEditorSession;
+    state: IPdfCanvasTextEditState;
+    cssPoint: PdfPoint;
+    viewport: Pick<IPdfCanvasViewport, 'zoom'>;
+    measureText: (text: string, font: string) => number;
+    document?: IPdfDocument;
+}
+export interface IPdfCanvasTextEditTarget extends IPdfCanvasTextEditStartInput {
+    offset: number;
+}
+export interface IPdfCanvasSemanticTextEditResult {
+    handled: boolean;
+    state?: IPdfCanvasTextEditState;
+    commandResults: IPdfEditorCommandResult[];
+}
+/** Resolve the same table/story/simple-text geometry used by the Canvas renderer. */
+export declare function resolvePdfCanvasTextEditTargetAtPoint(input: IPdfCanvasTextEditPointInput): IPdfCanvasTextEditTarget | undefined;
+/** Route only keys that change table/list/paragraph structure through the semantic controller. */
+export declare function handlePdfCanvasSemanticTextEditKeyDown(controller: IPdfCanvasTextEditController, getSession: () => IPdfEditorSession, input: IPdfCanvasTextEditKeyInput): IPdfCanvasSemanticTextEditResult;

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

@@ -0,0 +1,69 @@
+import type { IPdfEditorSession, IPdfEditorTextRange, PdfEditorGeneratedIdPrefix, PdfEmu, PdfId, PdfObjectId, PdfPageId, PdfRect, PdfTextListId, PdfTextRunId, PdfTextStoryId } from '@univerjs-pro/pdfs';
+export interface IPdfCanvasTextEditControllerOptions {
+    actorId: string;
+    clientId?: string;
+    getSession: () => IPdfEditorSession;
+    setSession?: (session: IPdfEditorSession) => void;
+    now?: () => number;
+    createId?: (prefix: PdfEditorGeneratedIdPrefix) => string;
+    resolveParagraphCommitLayout?: (state: IPdfCanvasTextEditState, session: IPdfEditorSession, intent: IPdfCanvasParagraphCommitIntent) => IPdfCanvasParagraphCommitLayout | undefined;
+}
+export interface IPdfCanvasParagraphCommitIntent {
+    kind: 'edit' | 'split' | 'merge';
+    /** True when `session` already contains the structural preview. */
+    structurePreviewApplied: boolean;
+}
+export interface IPdfCanvasParagraphCommitLayout {
+    previousBbox: PdfRect;
+    nextBbox: PdfRect;
+    pageBottom: PdfEmu;
+}
+export interface IPdfCanvasTextEditStartInput {
+    pageId?: PdfPageId;
+    objectId: PdfObjectId;
+    cellId?: PdfId;
+    storyId?: PdfTextStoryId;
+    blockId?: PdfId;
+    runId?: PdfTextRunId;
+    range?: IPdfEditorTextRange;
+}
+export interface IPdfCanvasTextEditKeyInput {
+    key: string;
+    shiftKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    altKey?: boolean;
+}
+export interface IPdfCanvasTextEditState {
+    pageId: PdfPageId;
+    objectId: PdfObjectId;
+    cellId?: PdfId;
+    originalText: string;
+    text: string;
+    selection: IPdfEditorTextRange;
+    /** Fixed endpoint used to preserve selection direction during Shift+Arrow. */
+    selectionAnchor?: number;
+    /** Moving endpoint used to preserve selection direction during Shift+Arrow. */
+    selectionFocus?: number;
+    storyId?: PdfTextStoryId;
+    blockId?: PdfId;
+    runId?: PdfTextRunId;
+    listId?: PdfTextListId;
+    listLevel?: number;
+}
+export interface IPdfCanvasTextEditController {
+    startObjectEdit(input: IPdfCanvasTextEditStartInput): IPdfCanvasTextEditState | undefined;
+    getState(): IPdfCanvasTextEditState | undefined;
+    setSelection(range: IPdfEditorTextRange): IPdfCanvasTextEditState | undefined;
+    beginSelection(offset: number): IPdfCanvasTextEditState | undefined;
+    extendSelection(offset: number): IPdfCanvasTextEditState | undefined;
+    insertText(text: string): IPdfCanvasTextEditState | undefined;
+    replaceText(text: string, range: IPdfEditorTextRange): IPdfCanvasTextEditState | undefined;
+    handleKeyDown(input: IPdfCanvasTextEditKeyInput): {
+        handled: boolean;
+        state?: IPdfCanvasTextEditState;
+    };
+    commit(): IPdfEditorSession;
+    cancel(): void;
+}
+export declare function createPdfCanvasTextEditController(options: IPdfCanvasTextEditControllerOptions): IPdfCanvasTextEditController;

package/lib/types/editor/chrome-model.d.ts

@@ -0,0 +1,61 @@
+import type { LocaleService } from '@univerjs/core';
+export declare enum PdfEditorRibbonTabId {
+    START = "pdf.ribbon.start",
+    INSERT = "pdf.ribbon.insert",
+    VIEW = "pdf.ribbon.view"
+}
+export declare enum PdfEditorRibbonGroupId {
+    FILE = "pdf.ribbon.group.file",
+    EDIT = "pdf.ribbon.group.edit",
+    TRANSFORM = "pdf.ribbon.group.transform",
+    INSERT = "pdf.ribbon.group.insert",
+    DISPLAY = "pdf.ribbon.group.display"
+}
+export declare enum PdfEditorRibbonActionId {
+    IMPORT_PDF = "pdf.ribbon.action.importPdf",
+    EXPORT_PDF = "pdf.ribbon.action.exportPdf",
+    UNDO = "pdf.ribbon.action.undo",
+    REDO = "pdf.ribbon.action.redo",
+    SELECT_TOOL = "pdf.ribbon.action.selectTool",
+    TEXT_TOOL = "pdf.ribbon.action.textTool",
+    FLIP_HORIZONTAL = "pdf.ribbon.action.flipHorizontal",
+    FLIP_VERTICAL = "pdf.ribbon.action.flipVertical",
+    ADD_TEXT = "pdf.ribbon.action.addText",
+    INSERT_IMAGE = "pdf.ribbon.action.insertImage",
+    INSERT_DIVIDER = "pdf.ribbon.action.insertDivider",
+    INSERT_TABLE = "pdf.ribbon.action.insertTable",
+    INSERT_LIST = "pdf.ribbon.action.insertList",
+    SHOW_ANNOTATIONS = "pdf.ribbon.action.showAnnotations",
+    SHOW_BOUNDS = "pdf.ribbon.action.showBounds",
+    SHOW_RAW = "pdf.ribbon.action.showRaw"
+}
+export type PdfEditorRibbonItemKind = 'button' | 'toggle';
+export type PdfEditorRibbonTool = 'select' | 'text';
+export interface IPdfEditorRibbonModelOptions {
+    activeTool: PdfEditorRibbonTool;
+    annotationsVisible: boolean;
+    boundsVisible: boolean;
+    rawVisible: boolean;
+    canTransformSelection: boolean;
+}
+export interface IPdfEditorRibbonItem {
+    id: PdfEditorRibbonActionId;
+    label: string;
+    kind: PdfEditorRibbonItemKind;
+    enabled: boolean;
+    active?: boolean;
+}
+export interface IPdfEditorRibbonGroup {
+    id: PdfEditorRibbonGroupId;
+    label: string;
+    items: IPdfEditorRibbonItem[];
+}
+export interface IPdfEditorRibbonTab {
+    id: PdfEditorRibbonTabId;
+    label: string;
+    groups: IPdfEditorRibbonGroup[];
+}
+export interface IPdfEditorRibbonModel {
+    tabs: IPdfEditorRibbonTab[];
+}
+export declare function createPdfEditorRibbonModel(options: IPdfEditorRibbonModelOptions, localeService: LocaleService): IPdfEditorRibbonModel;

package/lib/types/editor/context-menu-model.d.ts

@@ -0,0 +1,17 @@
+import type { IPdfEditorSession } from '@univerjs-pro/pdfs';
+import type { LocaleService } from '@univerjs/core';
+export type PdfEditorContextMenuActionId = 'addText' | 'editText' | 'copy' | 'paste' | 'replaceImage' | 'cropImage' | 'flipHorizontal' | 'flipVertical' | 'bringForward' | 'sendBackward' | 'exportPatch' | 'delete';
+export interface IPdfEditorContextMenuItem {
+    id: PdfEditorContextMenuActionId;
+    label: string;
+    enabled: boolean;
+    danger?: boolean;
+}
+export interface IPdfEditorContextMenuGroup {
+    id: string;
+    items: IPdfEditorContextMenuItem[];
+}
+export interface IPdfEditorContextMenuModel {
+    groups: IPdfEditorContextMenuGroup[];
+}
+export declare function createPdfEditorContextMenuModel(session: IPdfEditorSession, localeService: LocaleService): IPdfEditorContextMenuModel;

package/lib/types/editor/form-field-targets.d.ts

@@ -0,0 +1,8 @@
+import type { IPdfDocument, IPdfEditorFormFieldHitTarget, PdfPageId } from '@univerjs-pro/pdfs';
+/**
+ * Build bbox-level hit targets for page-visible AcroForm widgets.
+ *
+ * The returned target keeps both widget and field identities. The widget owns
+ * page placement and appearance; the form field owns semantic value state.
+ */
+export declare function createPdfFormFieldHitTargets(document: IPdfDocument, pageId: PdfPageId): IPdfEditorFormFieldHitTarget[];

package/lib/types/editor/form-field-values.d.ts

@@ -0,0 +1,16 @@
+import type { PdfJsonValue } from '@univerjs-pro/pdfs';
+/**
+ * Whether a PDF form value represents an active checkbox/radio state.
+ *
+ * PDF button fields often use name values such as `/Yes` and `/Off` instead of
+ * booleans. This helper keeps UI logic independent from one source convention.
+ */
+export declare function isPdfFormFieldOnValue(value: PdfJsonValue | undefined): boolean;
+/**
+ * Toggle a checkbox while preserving source-style PDF name values when known.
+ */
+export declare function togglePdfCheckboxValue(currentValue: PdfJsonValue | undefined, onValue?: PdfJsonValue, offValue?: PdfJsonValue): PdfJsonValue;
+/**
+ * Convert a PDF choice value into compact display text for an editor overlay.
+ */
+export declare function resolvePdfChoiceDisplayText(value: PdfJsonValue | undefined): string;

package/lib/types/editor/geometry.d.ts

@@ -0,0 +1,18 @@
+import type { PdfMatrix, PdfPoint, PdfRect } from '@univerjs-pro/pdfs';
+import type { IPdfCanvasViewport } from '../render/viewport';
+export interface IPdfEditorCssBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Convert a PDF editor model-space rect into page-local CSS pixels.
+ *
+ * Editor model coordinates are EMU. DOM overlays such as textareas and resize
+ * handles are positioned in CSS pixels, so this helper keeps that boundary
+ * explicit and shared with the canvas overlay renderer.
+ */
+export declare function pdfEditorModelRectToCssBox(rect: PdfRect, viewport: Pick<IPdfCanvasViewport, 'zoom'>): IPdfEditorCssBox;
+export declare function pdfEditorModelLengthToCssPx(value: number, viewport: Pick<IPdfCanvasViewport, 'zoom'>): number;
+export declare function pdfEditorCanvasPointToObjectLocalCssPoint(point: PdfPoint, transform: PdfMatrix | undefined, viewport: Pick<IPdfCanvasViewport, 'zoom'>): PdfPoint | undefined;

package/lib/types/editor/inspector-geometry.d.ts

@@ -0,0 +1,13 @@
+import type { PdfRect } from '@univerjs-pro/pdfs';
+/** Transform fields exposed by the PDF editor inspector. */
+export declare enum PdfEditorInspectorTransformFieldId {
+    X = "x",
+    Y = "y",
+    WIDTH = "width",
+    HEIGHT = "height"
+}
+/**
+ * Applies a logical CSS-pixel inspector value to an EMU object rectangle.
+ * Position edits preserve dimensions, while dimensions remain at least one px.
+ */
+export declare function updatePdfEditorInspectorBboxFromPx(bbox: readonly number[], fieldId: PdfEditorInspectorTransformFieldId, valuePx: number): PdfRect;

package/lib/types/editor/inspector-model.d.ts

@@ -0,0 +1,75 @@
+import type { IPdfEditorSession, IPdfStroke, IPdfTableCell, IPdfTableCellStyle, IPdfTableObject, IPdfTextBlock, IPdfTextRun, IPdfTextStory, PdfObjectId } from '@univerjs-pro/pdfs';
+import type { LocaleService } from '@univerjs/core';
+export type PdfEditorInspectorFieldType = 'readonly' | 'text' | 'number' | 'color' | 'select';
+export declare enum PdfEditorInspectorParagraphFieldId {
+    ALIGN = "paragraphAlign",
+    LINE_HEIGHT = "paragraphLineHeight",
+    INDENT = "paragraphIndent",
+    FIRST_LINE_INDENT = "paragraphFirstLineIndent",
+    RIGHT_INDENT = "paragraphRightIndent",
+    SPACING_BEFORE = "paragraphSpacingBefore",
+    SPACING_AFTER = "paragraphSpacingAfter"
+}
+export declare enum PdfEditorInspectorCellFieldId {
+    BACKGROUND = "cellBackground",
+    VERTICAL_ALIGN = "cellVerticalAlign"
+}
+export declare enum PdfEditorInspectorTableFieldId {
+    THEME = "tableTheme"
+}
+export declare enum PdfEditorInspectorPathFieldId {
+    STROKE_COLOR = "strokeColor"
+}
+export interface IPdfEditorInspectorTableTarget {
+    tableId: PdfObjectId;
+    pageId?: string;
+    table: IPdfTableObject;
+}
+export interface IPdfEditorInspectorTableCellTarget {
+    tableId: PdfObjectId;
+    cellId: string;
+    pageId?: string;
+    table: IPdfTableObject;
+    cell: IPdfTableCell;
+    style: IPdfTableCellStyle;
+    storyId: string;
+    story?: IPdfTextStory;
+    block?: IPdfTextBlock;
+}
+export interface IPdfEditorInspectorField {
+    id: string;
+    label: string;
+    type: PdfEditorInspectorFieldType;
+    value?: string | number | boolean;
+    unit?: string;
+}
+export interface IPdfEditorInspectorAction {
+    id: string;
+    label: string;
+    enabled?: boolean;
+}
+export interface IPdfEditorInspectorSection {
+    id: string;
+    title: string;
+    fields: IPdfEditorInspectorField[];
+    actions: IPdfEditorInspectorAction[];
+}
+export interface IPdfEditorInspectorModel {
+    title: string;
+    subtitle?: string;
+    sections: IPdfEditorInspectorSection[];
+}
+/** Resolves the run whose style should be represented by the inspector. */
+export declare function resolvePdfEditorInspectorTextRun(session: IPdfEditorSession, objectId: PdfObjectId): IPdfTextRun | undefined;
+/** Resolves the semantic story block containing the active text run. */
+export declare function resolvePdfEditorInspectorTextBlock(session: IPdfEditorSession, objectId: PdfObjectId): {
+    storyId: string;
+    block: IPdfTextBlock;
+} | undefined;
+/** Resolves the effective stroke of an editable path object. */
+export declare function resolvePdfEditorInspectorPathStroke(session: IPdfEditorSession, objectId: PdfObjectId): IPdfStroke | undefined;
+/** Resolves the active structured table cell for cell or cell-text selections. */
+export declare function resolvePdfEditorInspectorTableCell(session: IPdfEditorSession): IPdfEditorInspectorTableCellTarget | undefined;
+/** Resolves a table from object, cell, or cell-text selection. */
+export declare function resolvePdfEditorInspectorTable(session: IPdfEditorSession): IPdfEditorInspectorTableTarget | undefined;
+export declare function createPdfEditorInspectorModel(session: IPdfEditorSession, localeService: LocaleService): IPdfEditorInspectorModel;

package/lib/types/editor/keyboard-controller.d.ts

@@ -0,0 +1,32 @@
+import type { IPdfEditorCommandResult, IPdfEditorSession, PdfEditorGeneratedIdPrefix } from '@univerjs-pro/pdfs';
+import type { IPdfCanvasViewport } from '../render/viewport';
+export interface IPdfEditorKeyboardControllerOptions {
+    actorId: string;
+    viewport: IPdfCanvasViewport;
+    getSession: () => IPdfEditorSession;
+    setSession?: (session: IPdfEditorSession) => void;
+    clientId?: string;
+    now?: () => number;
+    createId?: (prefix: PdfEditorGeneratedIdPrefix) => string;
+    onUndo?: (session: IPdfEditorSession) => IPdfEditorSession | void;
+    onRedo?: (session: IPdfEditorSession) => IPdfEditorSession | void;
+    onClearActiveEdit?: () => void;
+}
+export interface IPdfEditorKeyboardInput {
+    key: string;
+    shiftKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    altKey?: boolean;
+    targetEditable?: boolean;
+}
+export interface IPdfEditorKeyboardResult {
+    handled: boolean;
+    session: IPdfEditorSession;
+    commandResult?: IPdfEditorCommandResult;
+    reason?: 'nudge' | 'delete' | 'undo' | 'redo' | 'escape';
+}
+export interface IPdfEditorKeyboardController {
+    handleKeyDown(input: IPdfEditorKeyboardInput): IPdfEditorKeyboardResult;
+}
+export declare function createPdfEditorKeyboardController(options: IPdfEditorKeyboardControllerOptions): IPdfEditorKeyboardController;

package/lib/types/editor/list-layout.d.ts

@@ -0,0 +1,21 @@
+import type { PdfId } from '@univerjs-pro/pdfs';
+import type { IPdfEditorTextStoryBlockLayout, IPdfEditorTextStoryLayout, IPdfEditorTextStoryLayoutInput, IPdfEditorTextStoryLineLayout, IPdfEditorTextStoryTextRect } from './story-layout';
+export type IPdfEditorListStoryLayoutInput = IPdfEditorTextStoryLayoutInput;
+export type IPdfEditorListLineLayout = IPdfEditorTextStoryLineLayout;
+export type IPdfEditorListBlockLayout = IPdfEditorTextStoryBlockLayout;
+export type IPdfEditorListStoryLayout = IPdfEditorTextStoryLayout;
+export type IPdfEditorListStoryTextRect = IPdfEditorTextStoryTextRect;
+export interface IPdfEditorListStoryTextTarget {
+    blockId: PdfId;
+    offset: number;
+    storyOffset: number;
+}
+/** Compatibility wrapper for list callers migrated to the shared Story Layout. */
+export declare function layoutPdfEditorListStory(input: IPdfEditorListStoryLayoutInput): IPdfEditorListStoryLayout;
+/** Compatibility wrapper that preserves the original list target shape. */
+export declare function getPdfEditorListStoryTargetAtPoint(layout: IPdfEditorListStoryLayout, point: readonly [number, number]): IPdfEditorListStoryTextTarget | undefined;
+export declare function getPdfEditorListStoryCaretRect(layout: IPdfEditorListStoryLayout, blockId: PdfId, offset: number): IPdfEditorListStoryTextRect | undefined;
+export declare function getPdfEditorListStorySelectionRects(layout: IPdfEditorListStoryLayout, blockId: PdfId, range: {
+    start: number;
+    end: number;
+}): IPdfEditorListStoryTextRect[];

package/lib/types/editor/managed-image-insert.d.ts

@@ -0,0 +1,41 @@
+import type { IPdfDocument, IPdfEditorCommandContext, IPdfEditorCommandResult, IPdfEditorSession, IPdfPage, PdfAssetId, PdfPageId, PdfRect } from '@univerjs-pro/pdfs';
+import type { PdfImageResolverResult } from '../render/image-resolver';
+import type { IPdfManagedImageRuntimeAdapter } from '../services/pdf-managed-image-runtime.adapter';
+export interface IPdfManagedImageDimensions {
+    width: number;
+    height: number;
+}
+export declare const PDF_MANAGED_IMAGE_MAX_PAGE_RATIO = 0.6;
+export interface IPdfManagedImageInsertionPreparationOptions {
+    document: IPdfDocument;
+    session: IPdfEditorSession;
+    pageId: PdfPageId;
+    file: File;
+    adapter: Pick<IPdfManagedImageRuntimeAdapter, 'save' | 'release'>;
+    commandContext: IPdfEditorCommandContext;
+    createAssetId(document: IPdfDocument, session: IPdfEditorSession): PdfAssetId;
+    zIndex: number;
+    isContextCurrent(): boolean;
+}
+export interface IPdfManagedImageInsertionPreparationResult {
+    assetId: PdfAssetId;
+    pageId: PdfPageId;
+    commandResult: IPdfEditorCommandResult;
+}
+export interface IPdfWorkbenchDisposableOwner {
+    dispose(): void;
+}
+export type PdfWorkbenchDisposeErrorReporter = (errors: readonly unknown[]) => void;
+/** Convert the visible native PDF page box into top-left editor EMU coordinates. */
+export declare function getPdfPageVisibleModelBox(page: Pick<IPdfPage, 'pdfBoxes'>): PdfRect;
+/**
+ * Fit an image within a centered portion of a PDF page box without changing
+ * its aspect ratio or enlarging it past its intrinsic CSS-pixel dimensions.
+ */
+export declare function fitPdfManagedImageIntoPage(image: IPdfManagedImageDimensions, pageBox: Readonly<PdfRect>, maxPageRatio?: number): PdfRect;
+/** Prepare and execute a managed image insertion without applying host UI state. */
+export declare function preparePdfManagedImageInsertion(options: IPdfManagedImageInsertionPreparationOptions): Promise<IPdfManagedImageInsertionPreparationResult>;
+/** Resolve a durable managed resource first and invoke the native fallback only when needed. */
+export declare function resolvePdfManagedImageRuntimeSource(documentId: string, editState: Pick<IPdfEditorSession['editState'], 'documentId' | 'managedResources'> | undefined, assetId: PdfAssetId, adapter: Pick<IPdfManagedImageRuntimeAdapter, 'resolve'>, fallback: () => PdfImageResolverResult): PdfImageResolverResult;
+/** Dispose every Workbench owner, then report all failures together. */
+export declare function disposePdfWorkbenchOwnersBestEffort(owners: readonly IPdfWorkbenchDisposableOwner[], reportErrors?: PdfWorkbenchDisposeErrorReporter): unknown[];

package/lib/types/editor/native-targets.d.ts

@@ -0,0 +1,32 @@
+import type { IPdfDocument, IPdfEditorNativeFormXObjectHitTarget, IPdfEditorNativeTextHitTarget, IPdfPage, PdfDisplayListId, PdfPageId } from '@univerjs-pro/pdfs';
+export interface IPdfNativeTargetBuildOptions {
+    /** Materialized page geometry to use while keeping source data indexed by document identity. */
+    page?: IPdfPage;
+    /**
+     * Maximum Form XObject nesting depth to walk while building targets.
+     *
+     * Real PDFs can contain recursive or deeply nested resources. A small cap
+     * keeps hit-target building bounded for large documents while covering the
+     * normal page -> form -> text cases.
+     */
+    maxFormDepth?: number;
+    /** Explicit page roots avoid treating nested same-page Form lists as roots. */
+    rootDisplayListIds?: readonly PdfDisplayListId[];
+}
+/**
+ * Build bbox-level hit targets for native PDF text display operations.
+ *
+ * The returned targets are already mapped into the containing page's model
+ * coordinate system (EMU, top-left origin). Form XObject targets include an
+ * operationPath so edit suppression can address one painted instance instead
+ * of every reuse of the same inner display operation.
+ */
+export declare function createPdfNativeTextHitTargets(document: IPdfDocument, pageId: PdfPageId, options?: IPdfNativeTargetBuildOptions): IPdfEditorNativeTextHitTarget[];
+/**
+ * Build bbox-level hit targets for native Form XObject paint operations.
+ *
+ * These targets represent one painted instance of a form, not the reusable form
+ * asset globally. The operationPath is therefore required for source
+ * suppression so editing one reuse does not hide every reuse of the same form.
+ */
+export declare function createPdfNativeFormXObjectHitTargets(document: IPdfDocument, pageId: PdfPageId, options?: IPdfNativeTargetBuildOptions): IPdfEditorNativeFormXObjectHitTarget[];

package/lib/types/editor/native-text-edit.d.ts

@@ -0,0 +1,9 @@
+import type { IPdfEditorNativeTextHitTarget, IPdfEditorSession } from '@univerjs-pro/pdfs';
+/**
+ * Resolve the selected native PDF text span back to its hit target.
+ *
+ * Native text is first selected as a SOURCE_SPAN because the original PDF
+ * operators must remain immutable. Promotion to an editable overlay needs the
+ * richer target payload, including bbox, runs, and source mapping.
+ */
+export declare function findPdfNativeTextTargetForSelection(session: IPdfEditorSession, targets: IPdfEditorNativeTextHitTarget[]): IPdfEditorNativeTextHitTarget | undefined;

package/lib/types/editor/overlay-renderer.d.ts

@@ -0,0 +1,63 @@
+import type { IPdfAcroFormDefaultAppearance, IPdfDocument, IPdfDurableEditState, IPdfEditorEditState, IPdfEditorSelectionState, IPdfEditorTextRange, IPdfImageAsset, PdfAssetId, PdfColor, PdfDisplayOperationId, PdfObjectId, PdfPageId, PdfRect } from '@univerjs-pro/pdfs';
+import type { IPdfFontFamilyResolver } from '../render/decode-manifest';
+import type { IPdfFontOutlineResolver } from '../render/font-outline';
+import type { IPdfImageResolver } from '../render/image-resolver';
+import type { IPdfCanvasViewport } from '../render/viewport';
+import { PdfFormFieldType } from '@univerjs-pro/pdfs';
+export interface IPdfEditorOverlayRenderOptions {
+    editState: IPdfEditorEditState;
+    pageId: PdfPageId;
+    includedObjectIds?: ReadonlySet<PdfObjectId>;
+    viewport: IPdfCanvasViewport;
+    selection?: IPdfEditorSelectionState;
+    showSelection?: boolean;
+    textPaddingCssPx?: number;
+    sourceSelectionBounds?: IPdfEditorSourceSelectionBounds[];
+    formFieldBounds?: IPdfEditorFormFieldOverlayBounds[];
+    document?: IPdfDocument;
+    fontFamilyResolver?: IPdfFontFamilyResolver;
+    fontOutlineResolver?: IPdfFontOutlineResolver;
+    imageResolver?: IPdfImageResolver;
+    imageAssetResolver?: IPdfEditorImageAssetResolver;
+    activeTextEditState?: IPdfEditorOverlayActiveTextEditState;
+}
+export type IPdfEditorImageAssetResolver = (document: IPdfDocument, editState: IPdfDurableEditState, assetId: PdfAssetId) => IPdfImageAsset | undefined;
+export interface IPdfEditorOverlayActiveTextEditState {
+    objectId: PdfObjectId;
+    cellId?: string;
+    storyId?: string;
+    blockId?: string;
+    runId?: string;
+    text: string;
+    selection?: IPdfEditorTextRange;
+}
+export interface IPdfEditorSourceSelectionBounds {
+    id: string;
+    pageId: PdfPageId;
+    bbox: PdfRect;
+    displayOperationId?: PdfDisplayOperationId;
+    kind?: 'image' | 'formXObject' | 'path' | 'text' | 'unknown';
+}
+export interface IPdfEditorFormFieldOverlayBounds {
+    id: string;
+    pageId: PdfPageId;
+    bbox: PdfRect;
+    widgetObjectId: string;
+    fieldObjectId?: string;
+    fieldType?: PdfFormFieldType;
+    onValue?: string;
+    defaultAppearance?: IPdfAcroFormDefaultAppearance;
+    needsAppearance?: boolean;
+    quadding?: number;
+    backgroundColor?: PdfColor;
+    borderColor?: PdfColor;
+    borderWidth?: number;
+}
+/**
+ * Render user-editable PDF overlay objects on top of the native page canvas.
+ *
+ * This renderer is deliberately separate from the PDF display-list renderer:
+ * imported native content remains in `pdfs-render`, while editor overlays are
+ * drawn from `PdfEditorEditState`.
+ */
+export declare function renderPdfEditorOverlayToCanvas(context: CanvasRenderingContext2D, options: IPdfEditorOverlayRenderOptions): void;