@univerjs-pro/boards-ui 1.0.0-alpha.3

package/lib/types/render-objects/board-document-text-render.util.d.ts

@@ -0,0 +1,61 @@
+import type { BooleanNumber, HorizontalAlign, IDocumentData, LocaleService } from '@univerjs/core';
+import type { UniverRenderingContext } from '@univerjs/engine-render';
+import { VerticalAlign, WrapStrategy } from '@univerjs/core';
+import { Documents } from '@univerjs/engine-render';
+/** Context supplied to optional extensions for embedded Board document rendering. */
+export interface IBoardDocumentTextExtensionContext {
+    documentData: IDocumentData;
+    documents: Documents;
+}
+/** Factory for an optional embedded-document renderer such as LaTeX. */
+export type BoardDocumentTextExtensionFactory = (context: IBoardDocumentTextExtensionContext) => void;
+/**
+ * Registers an optional extension for Board's embedded document renderer.
+ *
+ * Feature packages call this once from an explicit integration entrypoint. Existing and future text render resources
+ * receive the extension without introducing a dependency from Boards UI back to the feature package.
+ */
+export declare function registerBoardDocumentTextExtension(factory: BoardDocumentTextExtensionFactory): {
+    dispose: () => void;
+};
+export interface IBoardDocumentTextRenderOptions {
+    key: string;
+    text?: string;
+    documentData?: IDocumentData;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    localeService?: LocaleService;
+    horizontalAlign?: HorizontalAlign;
+    verticalAlign?: VerticalAlign;
+    isHorizontal?: boolean;
+    wrapStrategy?: WrapStrategy;
+    shapeTextOpticalVerticalAlign?: BooleanNumber | boolean;
+    clip?: boolean;
+}
+export interface IBoardDocumentTextRenderResources {
+    actualHeight: number;
+    contentHeight: number;
+    dispose: () => void;
+    documents: Documents;
+    contentVerticalOffset: number;
+    minHeight: number;
+    opticalVerticalOffset: number;
+    width: number;
+}
+export interface IBoardDocumentTextRenderCache {
+    signature?: string;
+    resources?: IBoardDocumentTextRenderResources;
+}
+export declare function prepareBoardDocumentTextData(documentData: IDocumentData, options: Pick<IBoardDocumentTextRenderOptions, 'horizontalAlign' | 'isHorizontal' | 'verticalAlign' | 'wrapStrategy'> & {
+    width: number;
+    height: number;
+}): IDocumentData;
+export declare function createBoardDocumentTextRenderResources(options: IBoardDocumentTextRenderOptions & {
+    documentData: IDocumentData;
+}): IBoardDocumentTextRenderResources;
+export declare function shouldClipBoardDocumentTextResources(options: Pick<IBoardDocumentTextRenderOptions, 'clip' | 'wrapStrategy'>, documentData: IDocumentData): boolean;
+export declare function drawBoardDocumentTextResources(ctx: UniverRenderingContext, resources: IBoardDocumentTextRenderResources, left: number, top: number, clip: boolean): void;
+export declare function disposeBoardDocumentTextRenderCache(cache?: IBoardDocumentTextRenderCache): void;
+export declare function renderTextWithDocumentModel(ctx: UniverRenderingContext, options: IBoardDocumentTextRenderOptions, cache?: IBoardDocumentTextRenderCache): boolean;

package/lib/types/render-objects/board-grid-object.d.ts

@@ -0,0 +1,17 @@
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import type { IResolvedBoardGridConfig } from '../utils/board-grid.util';
+import { BaseObject } from '@univerjs/engine-render';
+export interface IBoardGridObjectState extends IResolvedBoardGridConfig {
+    visible: boolean;
+    zoomRatio: number;
+}
+export declare const BOARD_GRID_OBJECT_KEY = "board-grid-object";
+export declare const BOARD_GRID_OBJECT_LAYER_INDEX: 0;
+export declare class BoardGridObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardGridObjectState>);
+    updateState(state?: Partial<IBoardGridObjectState>): void;
+    isHit(_coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, bounds: IViewportInfo): this;
+    private _drawDots;
+}

package/lib/types/render-objects/board-guide-object.d.ts

@@ -0,0 +1,29 @@
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import { BaseObject } from '@univerjs/engine-render';
+export type BoardGuideOrientation = 'horizontal' | 'vertical';
+export interface IBoardGuideLine {
+    orientation: BoardGuideOrientation;
+    position: number;
+    start: number;
+    end: number;
+    color?: string;
+    label?: {
+        x: number;
+        y: number;
+    };
+    labelText?: string;
+}
+export interface IBoardGuideObjectState {
+    guides: IBoardGuideLine[];
+    zoomRatio?: number;
+}
+export declare const BOARD_GUIDE_OBJECT_KEY = "board-guide-object";
+export declare const BOARD_GUIDE_OBJECT_LAYER_INDEX: 4;
+export declare class BoardGuideObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardGuideObjectState>);
+    updateState(state?: Partial<IBoardGuideObjectState>): void;
+    isHit(_coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+    private _drawGuideLabel;
+}

package/lib/types/render-objects/board-image-object.d.ts

@@ -0,0 +1,16 @@
+import type { IBoardImageElement } from '@univerjs-pro/boards';
+import type { IImageIoService } from '@univerjs/core';
+import type { IImageProps } from '@univerjs/engine-render';
+import { ImageSourceType } from '@univerjs/core';
+import { Image } from '@univerjs/engine-render';
+export interface IBoardImageObjectProps extends IImageProps {
+    element: IBoardImageElement;
+    imageSourceType: ImageSourceType;
+}
+export declare class BoardImageObject extends Image {
+    private _element;
+    constructor(key: string, props: IBoardImageObjectProps);
+    updateElement(element: IBoardImageElement): void;
+    getElement(): IBoardImageElement;
+    loadSource(imageIoService: IImageIoService): Promise<void>;
+}

package/lib/types/render-objects/board-ink-draft-object.d.ts

@@ -0,0 +1,16 @@
+import type { IInkSourceModel, IInkStyle } from '@univerjs-pro/ink';
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import { BaseObject } from '@univerjs/engine-render';
+export interface IBoardInkDraftObjectState {
+    model: IInkSourceModel | null;
+    style: IInkStyle;
+}
+export declare const BOARD_INK_DRAFT_OBJECT_KEY = "board-ink-draft-object";
+export declare const BOARD_INK_DRAFT_OBJECT_LAYER_INDEX: 3;
+export declare class BoardInkDraftObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardInkDraftObjectState>);
+    updateState(state?: Partial<IBoardInkDraftObjectState>): void;
+    isHit(_coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+}

package/lib/types/render-objects/board-ink-eraser-draft-object.d.ts

@@ -0,0 +1,18 @@
+import type { IInkPoint } from '@univerjs-pro/ink';
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import { BaseObject } from '@univerjs/engine-render';
+export interface IBoardInkEraserDraftObjectState {
+    points: IInkPoint[];
+    radius: number;
+    color: string;
+    visible: boolean;
+}
+export declare const BOARD_INK_ERASER_DRAFT_OBJECT_KEY = "board-ink-eraser-draft-object";
+export declare const BOARD_INK_ERASER_DRAFT_OBJECT_LAYER_INDEX: number;
+export declare class BoardInkEraserDraftObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardInkEraserDraftObjectState>);
+    updateState(state?: Partial<IBoardInkEraserDraftObjectState>): void;
+    isHit(_coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+}

package/lib/types/render-objects/board-ink-pen-editor-object.d.ts

@@ -0,0 +1,39 @@
+import type { IInkPenHandleRef, IInkPenModel, IInkPenPathHit, IInkPoint, IInkStyle } from '@univerjs-pro/ink';
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import { BaseObject } from '@univerjs/engine-render';
+export interface IBoardInkPenEditorObjectState {
+    model: IInkPenModel | null;
+    style: IInkStyle;
+    previewPoint?: IInkPoint | null;
+    activeHandle?: IInkPenHandleRef | null;
+    hoverHandle?: IInkPenHandleRef | null;
+    hoverInsert?: IInkPenPathHit | null;
+    closeAnchorId?: string | null;
+    exitButtonVisible?: boolean;
+    exitButtonHovered?: boolean;
+    exitButtonLabel?: string;
+}
+export declare const BOARD_INK_PEN_EDITOR_OBJECT_KEY = "board-ink-pen-editor-object";
+export declare const BOARD_INK_PEN_EDITOR_OBJECT_LAYER_INDEX: number;
+export interface IBoardInkPenEditorExitButtonRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export declare function getBoardInkPenEditorExitButtonRect(model: IInkPenModel, label: string): IBoardInkPenEditorExitButtonRect;
+export declare function isPointInBoardInkPenEditorExitButton(model: IInkPenModel, label: string, point: IInkPoint): boolean;
+export declare class BoardInkPenEditorObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardInkPenEditorObjectState>);
+    updateState(state?: Partial<IBoardInkPenEditorObjectState>): void;
+    isHit(_coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+    private _renderPath;
+    private _renderControlLines;
+    private _renderHandles;
+    private _renderAnchor;
+    private _renderControlHandle;
+    private _renderInsertPreview;
+    private _renderExitButton;
+}

package/lib/types/render-objects/board-ink-stage-action-button-object.d.ts

@@ -0,0 +1,32 @@
+import type { IInkPoint } from '@univerjs-pro/ink';
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import { BaseObject } from '@univerjs/engine-render';
+export interface IBoardInkStageActionButtonRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface IBoardInkStageActionBoundsRect extends IBoardInkStageActionButtonRect {
+    rotation?: number;
+}
+export interface IBoardInkStageActionButtonObjectState {
+    rect: IBoardInkStageActionButtonRect | null;
+    boundsRect: IBoardInkStageActionBoundsRect | null;
+    label: string;
+    hovered: boolean;
+    visible: boolean;
+}
+export declare const BOARD_INK_STAGE_ACTION_BUTTON_OBJECT_KEY = "board-ink-stage-action-button-object";
+export declare const BOARD_INK_STAGE_ACTION_BUTTON_OBJECT_LAYER_INDEX: number;
+export declare function getBoardInkStageActionButtonRect(bounds: IBoardInkStageActionBoundsRect, label: string): IBoardInkStageActionButtonRect;
+export declare function isPointInBoardInkStageActionButton(rect: IBoardInkStageActionButtonRect | null, point: IInkPoint): boolean;
+export declare class BoardInkStageActionButtonObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardInkStageActionButtonObjectState>);
+    updateState(state?: Partial<IBoardInkStageActionButtonObjectState>): void;
+    isHit(_coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+    private _renderBounds;
+    private _renderButton;
+}

package/lib/types/render-objects/board-ink-tool-cursor-object.d.ts

@@ -0,0 +1,19 @@
+import type { IInkPoint } from '@univerjs-pro/ink';
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import { BaseObject } from '@univerjs/engine-render';
+export interface IBoardInkToolCursorObjectState {
+    point: IInkPoint | null;
+    radius: number;
+    color: string;
+    visible: boolean;
+    solid: boolean;
+}
+export declare const BOARD_INK_TOOL_CURSOR_OBJECT_KEY = "board-ink-tool-cursor-object";
+export declare const BOARD_INK_TOOL_CURSOR_OBJECT_LAYER_INDEX: number;
+export declare class BoardInkToolCursorObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardInkToolCursorObjectState>);
+    updateState(state?: Partial<IBoardInkToolCursorObjectState>): void;
+    isHit(_coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+}

package/lib/types/render-objects/board-pending-insert-object.d.ts

@@ -0,0 +1,35 @@
+import type { IBoardPageElement, IBoardThemeData } from '@univerjs-pro/boards';
+import type { IShapeData } from '@univerjs-pro/engine-shape';
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import type { IBoardPendingInsert } from '../services/board-ui-state.service';
+import type { IBoardInsertPoint, IBoardInsertRect } from '../utils/board-insert.util';
+import { ShapeTypeEnum } from '@univerjs-pro/engine-shape';
+import { BaseObject } from '@univerjs/engine-render';
+export interface IBoardPendingInsertObjectState {
+    pendingInsert: IBoardPendingInsert | null;
+    point: IBoardInsertPoint | null;
+    previewAlpha: number;
+    rect?: IBoardInsertRect | null;
+    themeData?: IBoardThemeData;
+    zoomRatio?: number;
+}
+export declare const BOARD_PENDING_INSERT_OBJECT_KEY = "board-pending-insert-object";
+export declare const BOARD_PENDING_INSERT_OBJECT_LAYER_INDEX: 3;
+export declare const BOARD_PENDING_INSERT_ALPHA = 0.18;
+export declare function resolveBoardPendingInsertShapeModelData(element: IBoardPageElement, shapeData: IShapeData): {
+    shapeType: ShapeTypeEnum;
+    shapeData: IShapeData;
+};
+export declare class BoardPendingInsertObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardPendingInsertObjectState>);
+    updateState(state?: Partial<IBoardPendingInsertObjectState>): void;
+    isHit(_coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+    private _resolvePreviewAlpha;
+    private _resolveZoomRatio;
+    private _drawShapePreview;
+    private _drawSwimlanePreviewStructure;
+    private _drawTablePreview;
+    private _drawTextPreview;
+}

package/lib/types/render-objects/board-selection-marquee-object.d.ts

@@ -0,0 +1,28 @@
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import type { IBoardSelectionRect } from '../utils/board-selection-geometry.util';
+import { BaseObject } from '@univerjs/engine-render';
+export interface IBoardSelectionMarqueeObjectState {
+    rect: IBoardSelectionRect | null;
+    zoomRatio?: number;
+}
+export declare const BOARD_SELECTION_MARQUEE_OBJECT_KEY = "board-selection-marquee-object";
+export declare const BOARD_SELECTION_DIMENSIONS_OBJECT_KEY = "board-selection-dimensions-object";
+export declare const BOARD_SELECTION_OVERLAY_LAYER_INDEX: 4;
+export declare class BoardSelectionMarqueeObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardSelectionMarqueeObjectState>);
+    updateState(state?: Partial<IBoardSelectionMarqueeObjectState>): void;
+    isHit(_coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+}
+export interface IBoardSelectionDimensionsObjectState {
+    bounds: IBoardSelectionRect | null;
+    zoomRatio?: number;
+}
+export declare class BoardSelectionDimensionsObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardSelectionDimensionsObjectState>);
+    updateState(state?: Partial<IBoardSelectionDimensionsObjectState>): void;
+    isHit(_coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+}

package/lib/types/render-objects/board-shape-object.d.ts

@@ -0,0 +1,75 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IShapeData, IShapeRect } from '@univerjs-pro/engine-shape';
+import type { LocaleService } from '@univerjs/core';
+import type { IObjectFullState, IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import { ShapeModel, ShapeTypeEnum } from '@univerjs-pro/engine-shape';
+import { Shape } from '@univerjs/engine-render';
+export type IBoardShapeElement = IBoardElementData['element'] & {
+    shapeData: IShapeData;
+};
+export interface IBoardShapeObjectProps {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    angle?: number;
+    flipX?: boolean;
+    flipY?: boolean;
+    zIndex?: number;
+    visible?: boolean;
+    evented?: boolean;
+    shapeModel: ShapeModel;
+    element: IBoardShapeElement;
+    localeService?: LocaleService;
+    focusedLaneId?: string | null;
+    focusedTitle?: boolean;
+}
+/**
+ * Board canvas object for board shape elements.
+ *
+ * It keeps the board render layer independent while still using the shared
+ * engine-shape renderer for preset geometry.
+ */
+export declare class BoardShapeObject extends Shape<IBoardShapeObjectProps> {
+    private readonly _shapeModel;
+    private readonly _localeService?;
+    private _element;
+    private _focusedLaneId;
+    private _focusedTitle;
+    private _isEditing;
+    private readonly _documentTextRenderCache;
+    isDrawingObject: boolean;
+    constructor(key: string, config: IBoardShapeObjectProps);
+    updateElement(element: IBoardShapeElement): void;
+    getElement(): IBoardShapeElement;
+    getShapeModel(): ShapeModel;
+    measureTextBoxNaturalCrossSize(width: number, height: number): number | null;
+    setFocusedLaneId(focusedLaneId: string | null | undefined): void;
+    setFocusedTitle(focusedTitle: boolean | null | undefined): void;
+    transformByState(option: IObjectFullState): this;
+    setEditing(isEditing: boolean): void;
+    getTextRect(width: number, height: number): IShapeRect;
+    _draw(ctx: UniverRenderingContext, _bounds?: IViewportInfo, renderWidth?: number, renderHeight?: number): void;
+    private _drawShapeModel;
+    private _drawEngineParticipantShape;
+    private _drawSequenceLifeline;
+    private _drawGenericContainerTitleLabel;
+    private _resolveGenericContainerTitleLabelBounds;
+    private _drawFocusedSwimlaneLane;
+    private _drawSwimlaneLanes;
+    private _drawSwimlaneTitleBar;
+    private _drawSwimlaneTitleSeparator;
+    private _drawSwimlaneLaneHeaderBands;
+    private _drawSwimlaneLaneTitles;
+    private _drawSwimlaneLaneHeaderSeparators;
+    private _drawShapeText;
+    render(mainCtx: UniverRenderingContext, bounds: IViewportInfo): this;
+    private _resolveRenderCullingBound;
+    getInverseCoord(coord: Vector2): Vector2;
+    isHit(coord: Vector2): boolean;
+    static createShapeModel(element: IBoardShapeElement): ShapeModel;
+    static resolveShapeModelData(element: IBoardShapeElement): {
+        shapeType: ShapeTypeEnum;
+        shapeData: IShapeData;
+    };
+}

package/lib/types/render-objects/board-swimlane-resize-object.d.ts

@@ -0,0 +1,33 @@
+import type { IBoardConnectorPoint } from '@univerjs-pro/boards';
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import { BaseObject } from '@univerjs/engine-render';
+export interface IBoardSwimlaneResizeDraftAffordance {
+    line: {
+        start: IBoardConnectorPoint;
+        end: IBoardConnectorPoint;
+    };
+    labelPoint: IBoardConnectorPoint;
+    size: number;
+}
+export interface IBoardSwimlaneResizeHoverAffordance {
+    line: {
+        start: IBoardConnectorPoint;
+        end: IBoardConnectorPoint;
+    };
+    orientation: 'horizontal' | 'vertical';
+}
+export interface IBoardSwimlaneResizeObjectState {
+    draft: IBoardSwimlaneResizeDraftAffordance | null;
+    hover: IBoardSwimlaneResizeHoverAffordance | null;
+    zoomRatio: number;
+}
+export declare const BOARD_SWIMLANE_RESIZE_OBJECT_KEY = "board-swimlane-resize-object";
+export declare const BOARD_SWIMLANE_RESIZE_OBJECT_LAYER_INDEX: 6;
+export declare class BoardSwimlaneResizeObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardSwimlaneResizeObjectState>);
+    updateState(state?: Partial<IBoardSwimlaneResizeObjectState>): void;
+    getResizeState(): IBoardSwimlaneResizeObjectState;
+    isHit(coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+}

package/lib/types/services/board-canvas-pop-manager.service.d.ts

@@ -0,0 +1,22 @@
+import type { IDisposable } from '@univerjs/core';
+import type { BaseObject, IBoundRectNoAngle } from '@univerjs/engine-render';
+import type { IPopup } from '@univerjs/ui';
+import { Disposable } from '@univerjs/core';
+import { IRenderManagerService } from '@univerjs/engine-render';
+import { ICanvasPopupService } from '@univerjs/ui';
+export interface IBoardCanvasPopup extends Pick<IPopup, 'componentKey' | 'direction' | 'excludeOutside' | 'hideOnInvisible' | 'offset' | 'onClickOutside'> {
+    anchorBoundResolver?: (targetObject: BaseObject) => IBoundRectNoAngle;
+    extraProps?: Record<string, unknown>;
+    mask?: boolean;
+}
+export declare class BoardCanvasPopManagerService extends Disposable {
+    private readonly _globalPopupManagerService;
+    private readonly _renderManagerService;
+    constructor(_globalPopupManagerService: ICanvasPopupService, _renderManagerService: IRenderManagerService);
+    private _createObjectPositionObserver;
+    attachPopupToObject(unitId: string, subUnitId: string, targetObject: BaseObject, popup: IBoardCanvasPopup): IDisposable;
+    attachPopupToPoint(unitId: string, subUnitId: string, point: {
+        x: number;
+        y: number;
+    }, popup: IBoardCanvasPopup): IDisposable;
+}

package/lib/types/services/board-clipboard-resource-adapter.service.d.ts

@@ -0,0 +1,54 @@
+import type { IBoardPageElement } from '@univerjs-pro/boards';
+import type { IDisposable, IMutationInfo } from '@univerjs/core';
+export interface IBoardClipboardResourceAdapter {
+    readonly key: string;
+    collect(params: {
+        unitId: string;
+        subUnitId: string;
+        elements: IBoardPageElement[];
+    }): unknown | null;
+    preparePaste(params: {
+        targetUnitId: string;
+        targetSubUnitId: string;
+        payload: unknown;
+        elementIdMap: ReadonlyMap<string, string>;
+        elements: IBoardPageElement[];
+    }): IBoardClipboardPreparedResourcePaste | null;
+}
+export interface IBoardClipboardPreparedResourcePaste {
+    elements: IBoardPageElement[];
+    redoMutations: IMutationInfo[];
+    undoMutations: IMutationInfo[];
+}
+export interface IBoardClipboardResourceAdapterService {
+    registerAdapter(adapter: IBoardClipboardResourceAdapter): IDisposable;
+    collect(params: {
+        unitId: string;
+        subUnitId: string;
+        elements: IBoardPageElement[];
+    }): Record<string, unknown> | undefined;
+    preparePaste(params: {
+        targetUnitId: string;
+        targetSubUnitId: string;
+        resources: Record<string, unknown> | undefined;
+        elementIdMap: ReadonlyMap<string, string>;
+        elements: IBoardPageElement[];
+    }): IBoardClipboardPreparedResourcePaste | null;
+}
+export declare const IBoardClipboardResourceAdapterService: import("@wendellhu/redi").IdentifierDecorator<IBoardClipboardResourceAdapterService>;
+export declare class BoardClipboardResourceAdapterService implements IBoardClipboardResourceAdapterService {
+    private readonly _adapters;
+    registerAdapter(adapter: IBoardClipboardResourceAdapter): IDisposable;
+    collect(params: {
+        unitId: string;
+        subUnitId: string;
+        elements: IBoardPageElement[];
+    }): Record<string, unknown> | undefined;
+    preparePaste(params: {
+        targetUnitId: string;
+        targetSubUnitId: string;
+        resources: Record<string, unknown> | undefined;
+        elementIdMap: ReadonlyMap<string, string>;
+        elements: IBoardPageElement[];
+    }): IBoardClipboardPreparedResourcePaste | null;
+}

package/lib/types/services/board-clipboard.service.d.ts

@@ -0,0 +1,54 @@
+import type { BoardModel } from '@univerjs-pro/boards';
+import type { IBoardClipboardPayload, IBoardElementStylePayload } from '../utils/board-clipboard.util';
+import type { IBoardSelectionContext } from './board-element-state.service';
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { ICommandService, IUndoRedoService } from '@univerjs/core';
+import { IBoardClipboardResourceAdapterService } from './board-clipboard-resource-adapter.service';
+import { BoardElementInsertService } from './board-element-insert.service';
+export declare const BOARD_CLIPBOARD_PASTE_OFFSET = 24;
+export interface IBoardPastePayloadOptions {
+    targetParentId?: string;
+}
+export interface IResolveBoardPasteTargetParentOptions {
+    selectedIds: string[];
+    focusedId?: string | null;
+    hoverId?: string | null;
+}
+export interface IBoardCopySelectionAsImageOptions {
+    viewport: {
+        zoomRatio: number;
+        panOffset: {
+            x: number;
+            y: number;
+        };
+    };
+    zoom?: {
+        minZoomRatio?: number;
+        maxZoomRatio?: number;
+    };
+    padding?: number;
+}
+export declare class BoardClipboardService {
+    private readonly _boardElementService;
+    private readonly _elementInsertService;
+    private readonly _resourceAdapterService;
+    private readonly _commandService;
+    private readonly _undoRedoService;
+    private _payload;
+    private _stylePayload;
+    constructor(_boardElementService: IBoardElementService, _elementInsertService: BoardElementInsertService, _resourceAdapterService: IBoardClipboardResourceAdapterService, _commandService: ICommandService, _undoRedoService: IUndoRedoService);
+    setPayload(payload: IBoardClipboardPayload | null | undefined): void;
+    getPayload(): IBoardClipboardPayload | null;
+    setStylePayload(payload: IBoardElementStylePayload | null | undefined): void;
+    getStylePayload(): IBoardElementStylePayload | null;
+    createPayload(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, selectedIds: string[]): IBoardClipboardPayload | null;
+    createStylePayload(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, sourceId: string | null | undefined): IBoardElementStylePayload | null;
+    createStyleUpdates(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, selectedIds: string[], payload: IBoardElementStylePayload | null | undefined): import("@univerjs-pro/boards").IUpdateBoardElementsOperationItem[];
+    copySelectionAsImage(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, selectedIds: string[], sourceCanvas: HTMLCanvasElement | null | undefined, options: IBoardCopySelectionAsImageOptions): Promise<boolean>;
+    resolvePasteTargetParentId(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, options: IResolveBoardPasteTargetParentOptions): string | undefined;
+    private _resolveUnlockedContainerId;
+    pastePayload(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, payload: IBoardClipboardPayload | null | undefined, options?: IBoardPastePayloadOptions): Promise<IBoardClipboardPayload | null>;
+    private _canPastePayloadIntoContainer;
+    private _pastePayloadWithResourceMutations;
+    private _executeMutations;
+}

package/lib/types/services/board-connector-tool.service.d.ts

@@ -0,0 +1,11 @@
+import type { IBeginBoardLineOperationParams, IBoardLineAdapter } from '@univerjs-pro/boards';
+import { IBoardLineAdapterService } from '@univerjs-pro/boards';
+import { Disposable } from '@univerjs/core';
+import { IBoardUIStateService } from './board-ui-state.service';
+export declare class BoardConnectorToolService extends Disposable implements IBoardLineAdapter {
+    private readonly _lineAdapterService;
+    private readonly _uiStateService;
+    private readonly _adapterDisposable;
+    constructor(_lineAdapterService: IBoardLineAdapterService, _uiStateService: IBoardUIStateService);
+    beginLineMode(params: IBeginBoardLineOperationParams): boolean;
+}

package/lib/types/services/board-container-rename.service.d.ts

@@ -0,0 +1,20 @@
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { Disposable, IUniverInstanceService } from '@univerjs/core';
+import { BoardDomLayerService } from './board-dom-layer.service';
+import { BoardElementEditService } from './board-element-edit.service';
+import { IBoardElementStateService } from './board-element-state.service';
+export declare const BOARD_CONTAINER_DEFAULT_TITLE = "Container";
+export declare class BoardContainerRenameService extends Disposable {
+    private readonly _domLayerService;
+    private readonly _editService;
+    private readonly _elementStateService;
+    private readonly _elementService;
+    private readonly _instanceService;
+    private _popupDisposable;
+    constructor(_domLayerService: BoardDomLayerService, _editService: BoardElementEditService, _elementStateService: IBoardElementStateService, _elementService: IBoardElementService, _instanceService: IUniverInstanceService);
+    dispose(): void;
+    close(): void;
+    openFocusedContainerRenamePopup(): boolean;
+    openContainerRenamePopup(unitId: string, subUnitId: string, containerId: string): boolean;
+    private _resolveContainer;
+}

package/lib/types/services/board-container-tool.service.d.ts

@@ -0,0 +1,12 @@
+import type { IBeginBoardContainerOperationParams, IBeginBoardSwimlaneOperationParams, IBoardContainerAdapter } from '@univerjs-pro/boards';
+import { IBoardContainerAdapterService } from '@univerjs-pro/boards';
+import { Disposable } from '@univerjs/core';
+import { IBoardUIStateService } from './board-ui-state.service';
+export declare class BoardContainerToolService extends Disposable implements IBoardContainerAdapter {
+    private readonly _containerAdapterService;
+    private readonly _uiStateService;
+    private readonly _adapterDisposable;
+    constructor(_containerAdapterService: IBoardContainerAdapterService, _uiStateService: IBoardUIStateService);
+    beginContainerMode(_params: IBeginBoardContainerOperationParams): boolean;
+    beginSwimlaneMode(params: IBeginBoardSwimlaneOperationParams): boolean;
+}

package/lib/types/services/board-dom-layer.service.d.ts

@@ -0,0 +1,31 @@
+import type { IDisposable } from '@univerjs/core';
+import type { ReactNode } from 'react';
+import { Disposable } from '@univerjs/core';
+export interface IBoardDomLayerRect {
+    height: number;
+    left: number;
+    top: number;
+    width: number;
+}
+export interface IBoardDomLayerItem {
+    id: string;
+    unitId: string;
+    subUnitId: string;
+    rect: IBoardDomLayerRect;
+    content: ReactNode | (() => ReactNode);
+    elementId?: string;
+    interactive?: boolean;
+    zIndex?: number;
+}
+export declare class BoardDomLayerService extends Disposable {
+    private readonly _items;
+    private readonly _itemTokens;
+    private readonly _items$;
+    readonly items$: import("rxjs").Observable<readonly IBoardDomLayerItem[]>;
+    dispose(): void;
+    getItems(): readonly IBoardDomLayerItem[];
+    registerItem(item: IBoardDomLayerItem): IDisposable;
+    updateItem(id: string, patch: Partial<Omit<IBoardDomLayerItem, 'id'>>): void;
+    unregisterItem(id: string): void;
+    private _emitItems;
+}