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

package/lib/types/services/board-element-edit.service.d.ts

@@ -0,0 +1,124 @@
+import type { BoardConnectorRouting, BoardModel, IBoardConnectorLabel, IBoardConnectorStyle, IBoardSwimlaneData, ICommitBoardContainerTransformOperationParams, IRemoveBoardElementsOperationParams, IRemoveBoardSwimlaneLaneOperationParams, IUpdateBoardElementOperationParams, IUpdateBoardElementsOperationItem, IUpdateBoardElementsOperationParams } from '@univerjs-pro/boards';
+import type { IBoardElementSelectionMoveDelta } from '../utils/board-selection-move.util';
+import type { IBoardElementSelectionResizeResult } from '../utils/board-selection-resize.util';
+import type { IBoardSelectionContext } from './board-element-state.service';
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { ICommandService } from '@univerjs/core';
+import { IBoardElementStateService } from './board-element-state.service';
+export interface IBoardElementEditSelectionSnapshot {
+    context: IBoardSelectionContext;
+    selectedIds: string[];
+    focusedId?: string | null;
+}
+export interface IBoardElementMoveSelectedOptions {
+    selectedIds: string[];
+    delta: IBoardElementSelectionMoveDelta;
+    focusedId?: string | null;
+}
+export interface IBoardElementResizeSelectionOptions {
+    selectedIds: string[];
+    focusedId?: string | null;
+}
+export interface IBoardElementUpdateSelectedConnectorStyleOptions {
+    selectedIds: string[];
+    focusedId?: string | null;
+    style: Partial<IBoardConnectorStyle>;
+}
+export interface IBoardElementUpdateSelectedConnectorRoutingOptions {
+    selectedIds: string[];
+    focusedId?: string | null;
+    routing: BoardConnectorRouting;
+}
+export interface IBoardElementUpdateSelectedConnectorLabelOptions {
+    selectedIds: string[];
+    focusedId?: string | null;
+    label: IBoardConnectorLabel;
+}
+export interface IBoardElementWrapSelectedInContainerOptions {
+    selectedIds: string[];
+    containerId?: string;
+    title?: string;
+}
+export interface IBoardElementReparentSelectedOptions {
+    selectedIds: string[];
+    parentId?: string;
+    focusedId?: string | null;
+}
+export interface IBoardElementMoveSelectedOutOfContainerOptions {
+    selectedIds: string[];
+    focusedId?: string | null;
+}
+export interface IBoardElementCommitContainerTransformOptions {
+    containerId: string;
+    transform: ICommitBoardContainerTransformOperationParams['transform'];
+    interaction: ICommitBoardContainerTransformOperationParams['interaction'];
+    selectedIds?: string[];
+    focusedId?: string | null;
+}
+export type IBoardElementEditSwimlaneLane = IBoardSwimlaneData['lanes'][number];
+export interface IBoardElementEditAddSwimlaneLaneOptions {
+    insertIndex?: number;
+}
+export interface IBoardElementEditRemoveSwimlaneLaneOptions {
+    contentPolicy?: IRemoveBoardSwimlaneLaneOperationParams['contentPolicy'];
+    targetLaneId?: string;
+}
+export interface IBoardElementRemoveElementsOptions {
+    unitId: string;
+    subUnitId: string;
+    elementIds: string[];
+}
+export type IBoardElementUpdateElementOptions = IUpdateBoardElementOperationParams;
+export type IBoardElementUpdateElementsOperationItem = IUpdateBoardElementsOperationItem;
+export interface IBoardElementUpdateElementsOptions {
+    unitId: string;
+    subUnitId: string;
+    updates: IBoardElementUpdateElementsOperationItem[];
+    forceCaptureElementIds?: readonly string[];
+}
+export declare class BoardElementEditService {
+    private readonly _commandService;
+    private readonly _boardElementService;
+    private readonly _elementStateService;
+    constructor(_commandService: ICommandService, _boardElementService: IBoardElementService, _elementStateService: IBoardElementStateService);
+    removeElements(params: IBoardElementRemoveElementsOptions): Promise<boolean>;
+    protected _removeElements(params: IRemoveBoardElementsOperationParams): Promise<boolean>;
+    private _resolveRemoveElementsWithBoundConnectors;
+    removeSelectedElements(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, selectedIds: string[]): Promise<boolean>;
+    moveSelectedElements(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, options: IBoardElementMoveSelectedOptions): Promise<boolean>;
+    updateResizedElement(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, resized: IBoardElementSelectionResizeResult, options: IBoardElementResizeSelectionOptions): Promise<boolean>;
+    wrapSelectedElementsInContainer(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, options: IBoardElementWrapSelectedInContainerOptions): Promise<boolean>;
+    reparentSelectedElements(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, options: IBoardElementReparentSelectedOptions): Promise<boolean>;
+    moveSelectedElementsOutOfContainer(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, options: IBoardElementMoveSelectedOutOfContainerOptions): Promise<boolean>;
+    selectParentContainer(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, elementId: string | null | undefined): Promise<boolean>;
+    disbandContainer(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, containerId: string | null | undefined): Promise<boolean>;
+    fitContainerToContent(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, containerId: string | null | undefined): Promise<boolean>;
+    setContainerMembershipLocked(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, containerId: string | null | undefined, membershipLocked: boolean): Promise<boolean>;
+    setContainerAutoResize(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, containerId: string | null | undefined, autoResize: boolean): Promise<boolean>;
+    renameContainer(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, containerId: string | null | undefined, title: string): Promise<boolean>;
+    addSwimlaneLane(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, containerId: string | null | undefined, lane: IBoardElementEditSwimlaneLane, options?: IBoardElementEditAddSwimlaneLaneOptions): Promise<boolean>;
+    removeSwimlaneLane(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, containerId: string | null | undefined, laneId: string, options?: IBoardElementEditRemoveSwimlaneLaneOptions): Promise<boolean>;
+    reorderSwimlaneLane(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, containerId: string | null | undefined, laneId: string, targetIndex: number): Promise<boolean>;
+    setSwimlaneLaneCollapsed(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, containerId: string | null | undefined, laneId: string, collapsed: boolean): Promise<boolean>;
+    renameSwimlaneLane(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, containerId: string | null | undefined, laneId: string, title: string): Promise<boolean>;
+    selectContainerContents(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, containerId: string | null | undefined): Promise<boolean>;
+    private _setSwimlaneLanes;
+    private _getMutableContainerItem;
+    private _hasLockedElements;
+    private _canReparentElementsInKnownData;
+    private _canApplyElementUpdatesInKnownData;
+    private _canWrapElementsInKnownData;
+    private _canRemoveElementsInKnownData;
+    private _canDisbandContainerInKnownData;
+    private _getSwimlaneData;
+    commitContainerTransform(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, options: IBoardElementCommitContainerTransformOptions): Promise<boolean>;
+    updateSelectedConnectorStyle(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, options: IBoardElementUpdateSelectedConnectorStyleOptions): Promise<boolean>;
+    updateSelectedConnectorRouting(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, options: IBoardElementUpdateSelectedConnectorRoutingOptions): Promise<boolean>;
+    updateSelectedConnectorLabel(boardModel: BoardModel | null | undefined, context: IBoardSelectionContext | null | undefined, options: IBoardElementUpdateSelectedConnectorLabelOptions): Promise<boolean>;
+    updateElement(params: IBoardElementUpdateElementOptions, selectionSnapshot?: IBoardElementEditSelectionSnapshot): Promise<boolean>;
+    protected _updateElement(params: IUpdateBoardElementOperationParams, selectionSnapshot?: IBoardElementEditSelectionSnapshot): Promise<boolean>;
+    updateElements(params: IBoardElementUpdateElementsOptions, selectionSnapshot?: IBoardElementEditSelectionSnapshot): Promise<boolean>;
+    protected _updateElements(params: IUpdateBoardElementsOperationParams, selectionSnapshot?: IBoardElementEditSelectionSnapshot): Promise<boolean>;
+    private _restoreSelection;
+    private _resolveUpdatesWithBoundConnectorRefreshes;
+}

package/lib/types/services/board-element-insert.service.d.ts

@@ -0,0 +1,40 @@
+import type { BoardModel, IAddBoardElementOperationParams, IAddBoardElementsOperationParams, IBoardPageElement } from '@univerjs-pro/boards';
+import type { IBoardInsertPoint, IBoardInsertRect } from '../utils/board-insert.util';
+import type { IBoardPendingInsert } from './board-ui-state.service';
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { ICommandService } from '@univerjs/core';
+import { IBoardElementStateService } from './board-element-state.service';
+import { BoardTextEditingService } from './board-text-editing.service';
+import { IBoardUIStateService } from './board-ui-state.service';
+export interface IBoardInsertPendingElementOptions {
+    boardModel: BoardModel | null | undefined;
+    pendingInsert: IBoardPendingInsert | null | undefined;
+    point: IBoardInsertPoint;
+    rect?: IBoardInsertRect | null;
+}
+export interface IBoardInsertElementsOptions {
+    fitContainerId?: string;
+}
+export interface IBoardInsertElementAtPointOptions {
+    boardModel: BoardModel | null | undefined;
+    element: IBoardPageElement | null | undefined;
+    point: IBoardInsertPoint;
+    insertIndex?: number;
+}
+export declare class BoardElementInsertService {
+    private readonly _commandService;
+    private readonly _elementStateService;
+    private readonly _uiStateService;
+    private readonly _boardElementService;
+    private readonly _boardTextEditingService;
+    constructor(_commandService: ICommandService, _elementStateService: IBoardElementStateService, _uiStateService: IBoardUIStateService, _boardElementService: IBoardElementService, _boardTextEditingService: BoardTextEditingService);
+    insertElement(params: IAddBoardElementOperationParams): Promise<boolean>;
+    insertElements(params: IAddBoardElementsOperationParams, options?: IBoardInsertElementsOptions): Promise<boolean>;
+    insertElementAtPoint(options: IBoardInsertElementAtPointOptions): Promise<boolean>;
+    insertPendingElement(options: IBoardInsertPendingElementOptions): Promise<boolean>;
+    private _resolvePointInsertedElementContainerCapture;
+    private _openTextEditingForInsertedElement;
+    private _hasDuplicateInsertIds;
+    private _hasBlockedParent;
+    private _hasInvalidKnownFitContainer;
+}

package/lib/types/services/board-element-state.service.d.ts

@@ -0,0 +1,83 @@
+import type { Observable } from 'rxjs';
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { Disposable } from '@univerjs/core';
+export interface IBoardSelectionContext {
+    unitId: string;
+    subUnitId: string;
+}
+export interface IBoardElementStateSnapshot {
+    context: IBoardSelectionContext | null;
+    selectedIds: string[];
+    focusedId: string | null;
+    focusedSwimlaneLane: IBoardFocusedSwimlaneLane | null;
+    hoverId: string | null;
+    activeEditingId: string | null;
+    isTransforming: boolean;
+}
+export type IBoardFocusedSwimlaneLane = IBoardFocusedSwimlaneLaneTarget | IBoardFocusedSwimlaneTitleTarget;
+export interface IBoardFocusedSwimlaneLaneTarget {
+    containerId: string;
+    kind?: 'lane';
+    laneId: string;
+}
+export interface IBoardFocusedSwimlaneTitleTarget {
+    containerId: string;
+    kind: 'title';
+}
+export declare function isBoardFocusedSwimlaneLaneTarget(focus: IBoardFocusedSwimlaneLane | null | undefined): focus is IBoardFocusedSwimlaneLaneTarget;
+export declare function isBoardFocusedSwimlaneTitleTarget(focus: IBoardFocusedSwimlaneLane | null | undefined): focus is IBoardFocusedSwimlaneTitleTarget;
+export interface IBoardElementStateService {
+    readonly state$: Observable<IBoardElementStateSnapshot>;
+    readonly selected$: Observable<string[]>;
+    readonly focused$: Observable<string | null>;
+    readonly hover$: Observable<string | null>;
+    readonly activeEditing$: Observable<string | null>;
+    getSnapshot(): IBoardElementStateSnapshot;
+    selectElements(context: IBoardSelectionContext, elementIds: string[], focusId?: string | null): void;
+    addElementToSelection(context: IBoardSelectionContext, elementId: string): void;
+    removeElementFromSelection(elementId: string): void;
+    toggleElementInSelection(context: IBoardSelectionContext, elementId: string): void;
+    clearSelection(): void;
+    setHoverElement(elementId: string | null): void;
+    setFocusedSwimlaneLane(context: IBoardSelectionContext | null, lane: IBoardFocusedSwimlaneLane | null): void;
+    setActiveEditingElement(context: IBoardSelectionContext | null, elementId: string | null): void;
+    setTransforming(isTransforming: boolean): void;
+    clearActiveEditing(): void;
+    isElementSelected(elementId: string): boolean;
+    isElementFocused(elementId: string): boolean;
+    isElementHovered(elementId: string): boolean;
+    isElementActiveEditing(elementId: string): boolean;
+}
+export declare const IBoardElementStateService: import("@wendellhu/redi").IdentifierDecorator<IBoardElementStateService>;
+export declare class BoardElementStateService extends Disposable implements IBoardElementStateService {
+    private readonly _boardElementService;
+    private readonly _state$;
+    readonly state$: Observable<IBoardElementStateSnapshot>;
+    readonly selected$: Observable<string[]>;
+    readonly focused$: Observable<string | null>;
+    readonly hover$: Observable<string | null>;
+    readonly activeEditing$: Observable<string | null>;
+    constructor(_boardElementService: IBoardElementService);
+    dispose(): void;
+    getSnapshot(): IBoardElementStateSnapshot;
+    selectElements(context: IBoardSelectionContext, elementIds: string[], focusId?: string | null): void;
+    addElementToSelection(context: IBoardSelectionContext, elementId: string): void;
+    removeElementFromSelection(elementId: string): void;
+    toggleElementInSelection(context: IBoardSelectionContext, elementId: string): void;
+    clearSelection(): void;
+    setHoverElement(elementId: string | null): void;
+    setFocusedSwimlaneLane(context: IBoardSelectionContext | null, lane: IBoardFocusedSwimlaneLane | null): void;
+    setActiveEditingElement(context: IBoardSelectionContext | null, elementId: string | null): void;
+    setTransforming(isTransforming: boolean): void;
+    clearActiveEditing(): void;
+    isElementSelected(elementId: string): boolean;
+    isElementFocused(elementId: string): boolean;
+    isElementHovered(elementId: string): boolean;
+    isElementActiveEditing(elementId: string): boolean;
+    private _emit;
+    private _bridgeToElementService;
+    private _resolveRootSelectedIds;
+    private _canSelectElement;
+    private _isSameSelectionContext;
+    private _dedupeElementIds;
+}

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

@@ -0,0 +1,22 @@
+import type { BoardModel } from '@univerjs-pro/boards';
+import type { IBoardElementFindResult } from '../utils/board-find.util';
+import type { IBoardViewportPoint } from '../utils/board-viewport.util';
+import { IBoardElementService, IBoardTableAdapterService } from '@univerjs-pro/boards';
+import { LocaleService } from '@univerjs/core';
+import { IBoardElementStateService } from './board-element-state.service';
+import { IBoardUIStateService } from './board-ui-state.service';
+export declare class BoardFindService {
+    private readonly _boardElementService;
+    private readonly _elementStateService;
+    private readonly _uiStateService;
+    private readonly _localeService;
+    private readonly _tableAdapterService?;
+    constructor(_boardElementService: IBoardElementService, _elementStateService: IBoardElementStateService, _uiStateService: IBoardUIStateService, _localeService: LocaleService, _tableAdapterService?: IBoardTableAdapterService | undefined);
+    find(boardModel: BoardModel | null | undefined, query: string): IBoardElementFindResult[];
+    private _createLocaleTexts;
+    private _createTableSearchEntries;
+    selectElementResult(boardModel: BoardModel | null | undefined, elementId: string): boolean;
+    selectResult(boardModel: BoardModel | null | undefined, elementId: string): boolean;
+    focusElementResult(boardModel: BoardModel | null | undefined, elementId: string, viewportPoint: IBoardViewportPoint): boolean;
+    focusResult(boardModel: BoardModel | null | undefined, elementId: string, viewportPoint: IBoardViewportPoint): boolean;
+}

package/lib/types/services/board-image-insert.service.d.ts

@@ -0,0 +1,23 @@
+import { IConfigService, IImageIoService, ImageSourceType, IUniverInstanceService } from '@univerjs/core';
+import { BoardElementInsertService } from './board-element-insert.service';
+export interface IBoardImageInsertOptions {
+    point?: {
+        x: number;
+        y: number;
+    };
+}
+export declare class BoardImageInsertService {
+    private readonly _instanceService;
+    private readonly _elementInsertService;
+    private readonly _configService;
+    private readonly _imageIoService?;
+    constructor(_instanceService: IUniverInstanceService, _elementInsertService: BoardElementInsertService, _configService: IConfigService, _imageIoService?: IImageIoService | undefined);
+    insertImage(file: File, options?: IBoardImageInsertOptions): Promise<boolean>;
+    resolveImageSource(file: File): Promise<{
+        source: string;
+        imageSourceType: ImageSourceType;
+        width: number;
+        height: number;
+    } | null>;
+    private _fileToDataUrl;
+}

package/lib/types/services/board-ink-edit.service.d.ts

@@ -0,0 +1,33 @@
+import type { Observable } from 'rxjs';
+import { Disposable } from '@univerjs/core';
+export interface IBoardInkEditingTarget {
+    unitId: string;
+    subUnitId: string;
+    elementId: string;
+}
+export type BoardInkEditSource = 'stage2' | 'shapeFloatingToolbar' | 'doubleClick';
+export type BoardInkEditReturnTo = 'stage2' | 'select';
+export interface IBoardInkBeginEditingOptions {
+    source?: BoardInkEditSource;
+    returnTo?: BoardInkEditReturnTo;
+}
+export interface IBoardInkEditState {
+    editingTarget: IBoardInkEditingTarget | null;
+    source: BoardInkEditSource | null;
+    returnTo: BoardInkEditReturnTo;
+}
+export interface IBoardInkEditService {
+    readonly state$: Observable<IBoardInkEditState>;
+    getState(): IBoardInkEditState;
+    beginEditing(target: IBoardInkEditingTarget, options?: IBoardInkBeginEditingOptions): void;
+    endEditing(): void;
+}
+export declare const IBoardInkEditService: import("@wendellhu/redi").IdentifierDecorator<IBoardInkEditService>;
+export declare class BoardInkEditService extends Disposable implements IBoardInkEditService {
+    private readonly _state$;
+    readonly state$: Observable<IBoardInkEditState>;
+    dispose(): void;
+    getState(): IBoardInkEditState;
+    beginEditing(target: IBoardInkEditingTarget, options?: IBoardInkBeginEditingOptions): void;
+    endEditing(): void;
+}

package/lib/types/services/board-ink-pen-adapter.service.d.ts

@@ -0,0 +1,22 @@
+import type { IBeginBoardPenOperationParams, IBoardPenAdapter } from '@univerjs-pro/boards';
+import type { IBeginInkModeParams, ICreateInkCustomShapeParams, IInkHostAdapter } from '@univerjs-pro/ink';
+import { IBoardPenAdapterService } from '@univerjs-pro/boards';
+import { IInkHostAdapterService } from '@univerjs-pro/ink';
+import { IInkUIStateService, InkUIService } from '@univerjs-pro/ink-ui';
+import { Disposable } from '@univerjs/core';
+import { BoardElementInsertService } from './board-element-insert.service';
+import { IBoardUIStateService } from './board-ui-state.service';
+export declare class BoardInkPenAdapterService extends Disposable implements IBoardPenAdapter, IInkHostAdapter {
+    private readonly _penAdapterService;
+    private readonly _inkHostAdapterService;
+    private readonly _uiStateService;
+    private readonly _inkUIService;
+    private readonly _insertService;
+    private readonly _inkStateService;
+    private readonly _penAdapterDisposable;
+    private readonly _inkHostAdapterDisposable;
+    constructor(_penAdapterService: IBoardPenAdapterService, _inkHostAdapterService: IInkHostAdapterService, _uiStateService: IBoardUIStateService, _inkUIService: InkUIService, _insertService: BoardElementInsertService, _inkStateService: IInkUIStateService);
+    beginPenMode(params: IBeginBoardPenOperationParams): boolean;
+    beginInkMode(params: IBeginInkModeParams): boolean;
+    createCustomShape(params: ICreateInkCustomShapeParams): Promise<boolean>;
+}

package/lib/types/services/board-mermaid-import.service.d.ts

@@ -0,0 +1,82 @@
+import type { IBoardImportDiagnostic, IBoardImportDraft } from '@univerjs-pro/boards';
+import type { IDisposable } from '@univerjs/core';
+import type { Observable } from 'rxjs';
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { IExchangeService } from '@univerjs-pro/exchange-client';
+import { ICommandService, LocaleService } from '@univerjs/core';
+import { IBoardElementStateService } from './board-element-state.service';
+import { IBoardUIStateService } from './board-ui-state.service';
+export declare const BOARD_MERMAID_IMPORT_SOURCE_TYPE = "mermaid";
+export declare const BoardMermaidImportErrorKey: {
+    readonly ExchangeUnavailable: "boards-ui.mermaidImport.errors.exchangeUnavailable";
+    readonly EmptyCode: "boards-ui.mermaidImport.errors.emptyCode";
+    readonly InvalidDraft: "boards-ui.mermaidImport.errors.invalidDraft";
+    readonly InsertFailed: "boards-ui.mermaidImport.errors.insertFailed";
+};
+export type BoardMermaidImportErrorKey = typeof BoardMermaidImportErrorKey[keyof typeof BoardMermaidImportErrorKey];
+export declare const MERMAID_CODE_SAMPLES: Record<string, string>;
+export declare const DEFAULT_MERMAID_CODE: string;
+export declare const RENDER_ELEMENT_FAILED_DIAGNOSTIC_KEY = "boards-ui.mermaidImport.diagnostics.renderElementFailed";
+export interface IBoardMermaidImportContext {
+    unitId: string;
+    subUnitId: string;
+}
+export interface IBoardMermaidImportState extends IBoardMermaidImportContext {
+    open: boolean;
+    code: string;
+    containerName: string;
+    diagramType: string;
+    converting: boolean;
+    inserting: boolean;
+    draft: IBoardImportDraft | null;
+    diagnostics: IBoardImportDiagnostic[];
+    error: IBoardMermaidImportError | null;
+}
+export interface IBoardMermaidConvertOptions {
+    diagramType?: string;
+    fileName?: string;
+}
+export interface IBoardMermaidInsertOptions {
+    containerName?: string;
+    selectAfterInsert?: boolean;
+}
+export interface IBoardMermaidImportError {
+    key: BoardMermaidImportErrorKey;
+    detail?: string;
+}
+export interface IBoardMermaidImportService {
+    readonly state$: Observable<IBoardMermaidImportState>;
+    getState(): IBoardMermaidImportState;
+    openImport(context: IBoardMermaidImportContext): void;
+    close(): void;
+    updateCode(code: string): void;
+    updateContainerName(containerName: string): void;
+    updateDiagramType(diagramType: string): void;
+    convertMermaidToBoardDraft(code: string, options?: IBoardMermaidConvertOptions): Promise<IBoardImportDraft>;
+    convertCurrentCode(): Promise<IBoardImportDraft | null>;
+    insertCurrentDraft(options?: IBoardMermaidInsertOptions): Promise<boolean>;
+}
+export declare const IBoardMermaidImportService: import("@wendellhu/redi").IdentifierDecorator<IBoardMermaidImportService>;
+export declare class BoardMermaidImportService implements IBoardMermaidImportService, IDisposable {
+    private readonly _boardElementService;
+    private readonly _uiStateService;
+    private readonly _elementStateService;
+    private readonly _localeService;
+    private readonly _commandService;
+    private readonly _exchangeService?;
+    private readonly _state$;
+    private _convertRequestId;
+    readonly state$: Observable<IBoardMermaidImportState>;
+    constructor(_boardElementService: IBoardElementService, _uiStateService: IBoardUIStateService, _elementStateService: IBoardElementStateService, _localeService: LocaleService, _commandService: ICommandService, _exchangeService?: IExchangeService | undefined);
+    dispose(): void;
+    getState(): IBoardMermaidImportState;
+    openImport(context: IBoardMermaidImportContext): void;
+    close(): void;
+    updateCode(code: string): void;
+    updateContainerName(containerName: string): void;
+    updateDiagramType(diagramType: string): void;
+    convertMermaidToBoardDraft(code: string, options?: IBoardMermaidConvertOptions): Promise<IBoardImportDraft>;
+    convertCurrentCode(): Promise<IBoardImportDraft | null>;
+    insertCurrentDraft(options?: IBoardMermaidInsertOptions): Promise<boolean>;
+    asDisposable(): IDisposable;
+}

package/lib/types/services/board-render-scene.service.d.ts

@@ -0,0 +1,9 @@
+import { IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import { IRenderManagerService } from '@univerjs/engine-render';
+export declare class BoardRenderSceneService extends RxDisposable {
+    private readonly _instanceSrv;
+    private readonly _renderManagerService;
+    constructor(_instanceSrv: IUniverInstanceService, _renderManagerService: IRenderManagerService);
+    private _init;
+    private _createRenderer;
+}

package/lib/types/services/board-selection-overlay.service.d.ts

@@ -0,0 +1,13 @@
+import type { IBoardSelectionPoint } from '../utils/board-selection-interaction.util';
+import { Disposable } from '@univerjs/core';
+export interface IBoardSelectionDraft {
+    start: IBoardSelectionPoint;
+    current: IBoardSelectionPoint;
+}
+export declare class BoardSelectionOverlayService extends Disposable {
+    private readonly _selectionDraft$;
+    readonly selectionDraft$: import("rxjs").Observable<IBoardSelectionDraft | null>;
+    dispose(): void;
+    getSelectionDraft(): IBoardSelectionDraft | null;
+    setSelectionDraft(draft: IBoardSelectionDraft | null): void;
+}

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

@@ -0,0 +1,18 @@
+import type { BoardModel } from '@univerjs-pro/boards';
+import type { IBoardSelectionPoint } from '../utils/board-selection-interaction.util';
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { IBoardElementStateService } from './board-element-state.service';
+export interface IBoardPointerSelectionOptions {
+    boardModel: BoardModel | null | undefined;
+    start: IBoardSelectionPoint;
+    end: IBoardSelectionPoint;
+    preciseSelection: boolean;
+    invertSelection?: boolean;
+}
+export declare class BoardSelectionService {
+    private readonly _boardElementService;
+    private readonly _elementStateService;
+    constructor(_boardElementService: IBoardElementService, _elementStateService: IBoardElementStateService);
+    selectByPointerGesture(options: IBoardPointerSelectionOptions): boolean;
+    private _resolveInvertedSelection;
+}

package/lib/types/services/board-settings-action.service.d.ts

@@ -0,0 +1,21 @@
+import type { BoardModel } from '@univerjs-pro/boards';
+import type { IDisposable } from '@univerjs/core';
+import { ICommandService } from '@univerjs/core';
+import { BoardSettingsActionType } from '../common/settings-actions';
+export interface IBoardSettingsActionContext {
+    type: BoardSettingsActionType;
+    boardModel: BoardModel;
+    unitId: string;
+    subUnitId: string;
+}
+export interface IBoardSettingsActionAdapter {
+    executeAction(context: IBoardSettingsActionContext): boolean | Promise<boolean>;
+}
+export declare class BoardSettingsActionService {
+    private readonly _commandService;
+    private readonly _adapters;
+    constructor(_commandService: ICommandService);
+    registerAdapter(adapter: IBoardSettingsActionAdapter): IDisposable;
+    executeAction(type: BoardSettingsActionType, boardModel: BoardModel | null | undefined): Promise<boolean>;
+    private _executeDefaultAction;
+}

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

@@ -0,0 +1,13 @@
+import type { BoardModel, IBoardSettings } from '@univerjs-pro/boards';
+import { ICommandService, ThemeService } from '@univerjs/core';
+import { IBoardUIStateService } from './board-ui-state.service';
+export declare class BoardSettingsService {
+    private readonly _commandService;
+    private readonly _stateService;
+    private readonly _themeService;
+    constructor(_commandService: ICommandService, _stateService: IBoardUIStateService, _themeService: ThemeService);
+    setSettings(boardModel: BoardModel | null | undefined, settings: Partial<IBoardSettings>): Promise<boolean>;
+    setTheme(boardModel: BoardModel | null | undefined, themeId: string): Promise<boolean>;
+    syncFollowUniverTheme(boardModel: BoardModel | null | undefined): Promise<boolean>;
+    syncFromBoardModel(boardModel: BoardModel | null | undefined): void;
+}

package/lib/types/services/board-shape-intrinsic-size.service.d.ts

@@ -0,0 +1,34 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IShapeTextHostSizeUpdateParams, IShapeTextUpdateParams } from '@univerjs-pro/shape-editor-ui';
+import type { IDisposable } from '@univerjs/core';
+import { Disposable } from '@univerjs/core';
+export interface IBoardShapeIntrinsicSizeTextUpdateContext {
+    elementData: IBoardElementData;
+    params: IShapeTextUpdateParams;
+}
+export interface IBoardShapeIntrinsicSizeHostUpdateContext {
+    elementData: IBoardElementData;
+    params: IShapeTextHostSizeUpdateParams;
+}
+export interface IBoardShapeIntrinsicSizeProvider {
+    match: (elementData: IBoardElementData) => boolean;
+    updateShapeText?: (context: IBoardShapeIntrinsicSizeTextUpdateContext) => boolean;
+    updateHostSize?: (context: IBoardShapeIntrinsicSizeHostUpdateContext) => boolean;
+    previewHostSize?: (context: IBoardShapeIntrinsicSizeHostUpdateContext) => boolean;
+    resolveHostSize?: (context: IBoardShapeIntrinsicSizeHostUpdateContext) => {
+        width: number;
+        height: number;
+    } | null;
+}
+export declare class BoardShapeIntrinsicSizeService extends Disposable {
+    private readonly _providers;
+    registerProvider(provider: IBoardShapeIntrinsicSizeProvider): IDisposable;
+    handleShapeTextUpdate(context: IBoardShapeIntrinsicSizeTextUpdateContext): boolean;
+    handleHostSizeUpdate(context: IBoardShapeIntrinsicSizeHostUpdateContext): boolean;
+    previewHostSize(context: IBoardShapeIntrinsicSizeHostUpdateContext): boolean;
+    resolveHostSize(context: IBoardShapeIntrinsicSizeHostUpdateContext): {
+        width: number;
+        height: number;
+    } | null;
+    private _resolveProvider;
+}

package/lib/types/services/board-side-panel.service.d.ts

@@ -0,0 +1,37 @@
+import type { IDisposable } from '@univerjs/core';
+import type { ReactNode } from 'react';
+import type { Observable } from 'rxjs';
+import { Disposable } from '@univerjs/core';
+import { IBoardUIStateService } from './board-ui-state.service';
+export type BoardSidePanelCloseReason = 'api' | 'manual' | 'replace' | 'dispose';
+export interface IBoardSidePanelComponentDescriptor {
+    label: string;
+    [key: string]: unknown;
+}
+export interface IBoardSidePanelDescriptor {
+    id: string;
+    header?: ReactNode | IBoardSidePanelComponentDescriptor | {
+        title?: ReactNode;
+    };
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    children?: ReactNode | IBoardSidePanelComponentDescriptor;
+    onClose?: (reason: BoardSidePanelCloseReason) => void;
+}
+export interface IBoardSidePanelService {
+    open(panel: IBoardSidePanelDescriptor): IDisposable;
+    close(panelId?: string, reason?: BoardSidePanelCloseReason): void;
+    readonly activePanel$: Observable<IBoardSidePanelDescriptor | null>;
+}
+export declare const IBoardSidePanelService: import("@wendellhu/redi").IdentifierDecorator<IBoardSidePanelService>;
+export declare class BoardSidePanelService extends Disposable implements IBoardSidePanelService {
+    private readonly _stateService;
+    private readonly _activePanel$;
+    readonly activePanel$: Observable<IBoardSidePanelDescriptor | null>;
+    constructor(_stateService: IBoardUIStateService);
+    dispose(): void;
+    open(panel: IBoardSidePanelDescriptor): IDisposable;
+    close(panelId?: string, reason?: BoardSidePanelCloseReason): void;
+    private _closeActivePanel;
+}

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

@@ -0,0 +1,18 @@
+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 class BoardSwimlaneLaneRenameService 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;
+    openFocusedLaneRenamePopup(): boolean;
+    private _resolveSwimlaneContainer;
+}