@univerjs-pro/boards-ui 1.0.0-alpha.8 → 1.0.0-beta.1

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

@@ -29,15 +29,22 @@ export interface IBoardCopySelectionAsImageOptions {
     };
     padding?: number;
 }
+export declare class BoardClipboardStoreService {
+    private _payload;
+    private _stylePayload;
+    setPayload(payload: IBoardClipboardPayload | null | undefined): void;
+    getPayload(): IBoardClipboardPayload | null;
+    setStylePayload(payload: IBoardElementStylePayload | null | undefined): void;
+    getStylePayload(): IBoardElementStylePayload | null;
+}
 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);
+    private readonly _storeService;
+    constructor(_boardElementService: IBoardElementService, _elementInsertService: BoardElementInsertService, _resourceAdapterService: IBoardClipboardResourceAdapterService, _commandService: ICommandService, _undoRedoService: IUndoRedoService, _storeService: BoardClipboardStoreService);
     setPayload(payload: IBoardClipboardPayload | null | undefined): void;
     getPayload(): IBoardClipboardPayload | null;
     setStylePayload(payload: IBoardElementStylePayload | null | undefined): void;

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

@@ -39,6 +39,7 @@ export interface IBoardElementUpdateSelectedConnectorLabelOptions {
     selectedIds: string[];
     focusedId?: string | null;
     label: IBoardConnectorLabel;
+    historyId?: string;
 }
 export interface IBoardElementWrapSelectedInContainerOptions {
     selectedIds: string[];
@@ -80,6 +81,7 @@ export interface IBoardElementUpdateElementsOptions {
     unitId: string;
     subUnitId: string;
     updates: IBoardElementUpdateElementsOperationItem[];
+    historyId?: string;
     forceCaptureElementIds?: readonly string[];
     membershipMode?: BoardContainerMembershipUpdateMode;
 }

package/lib/types/services/board-embed-integration.service.d.ts

@@ -1,3 +1,5 @@
+import type { UniverInstanceType } from '@univerjs/core';
+import type { Observable } from 'rxjs';
 /**
  * Optional host-side bridge supplied by Embed UI.
  *
@@ -5,6 +7,13 @@
  * prevent the host canvas from reclaiming focus for a child-owned pointer event.
  */
 export interface IBoardEmbedRuntimeFocusCoordinator {
+    readonly runtimeSessionChanged$?: Observable<void>;
+    resolveRuntimeScopeByChildUnitId?(childUnitId: string | undefined): {
+        embedId: string;
+        hostUnitId?: string;
+        childUnitId?: string;
+        childType?: UniverInstanceType;
+    } | undefined;
     shouldSuppressHostInteraction(unitId: string | undefined, target?: EventTarget | null, event?: Event): boolean;
 }
 export declare const IBoardEmbedRuntimeFocusCoordinator: import("@wendellhu/redi").IdentifierDecorator<IBoardEmbedRuntimeFocusCoordinator>;

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

@@ -18,5 +18,6 @@ export declare class BoardFindService {
     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;
+    getElementViewportPoint(boardModel: BoardModel | null | undefined, elementId: string): IBoardViewportPoint | null;
     focusResult(boardModel: BoardModel | null | undefined, elementId: string, viewportPoint: IBoardViewportPoint): boolean;
 }

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

@@ -1,5 +1,6 @@
 import { IConfigService, IImageIoService, ImageSourceType, IUniverInstanceService } from '@univerjs/core';
 import { BoardElementInsertService } from './board-element-insert.service';
+import { BoardViewportService } from './board-viewport.service';
 export interface IBoardImageInsertOptions {
     point?: {
         x: number;
@@ -10,8 +11,9 @@ export declare class BoardImageInsertService {
     private readonly _instanceService;
     private readonly _elementInsertService;
     private readonly _configService;
+    private readonly _viewportService;
     private readonly _imageIoService?;
-    constructor(_instanceService: IUniverInstanceService, _elementInsertService: BoardElementInsertService, _configService: IConfigService, _imageIoService?: IImageIoService | undefined);
+    constructor(_instanceService: IUniverInstanceService, _elementInsertService: BoardElementInsertService, _configService: IConfigService, _viewportService: BoardViewportService, _imageIoService?: IImageIoService | undefined);
     insertImage(file: File, options?: IBoardImageInsertOptions): Promise<boolean>;
     resolveImageSource(file: File): Promise<{
         source: string;

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

@@ -0,0 +1,21 @@
+import type { Observable } from 'rxjs';
+import type { IBoardViewportPoint } from '../utils/board-viewport.util';
+import { Disposable } from '@univerjs/core';
+export interface IBoardPointerStateSnapshot {
+    unitId: string;
+    subUnitId: string;
+    pointer: IBoardViewportPoint | null;
+}
+export interface IBoardPointerStateService {
+    readonly state$: Observable<IBoardPointerStateSnapshot | null>;
+    getSnapshot(): IBoardPointerStateSnapshot | null;
+    setPointer(state: IBoardPointerStateSnapshot): void;
+}
+export declare const IBoardPointerStateService: import("@wendellhu/redi").IdentifierDecorator<IBoardPointerStateService>;
+export declare class BoardPointerStateService extends Disposable implements IBoardPointerStateService {
+    private readonly _state$;
+    readonly state$: Observable<IBoardPointerStateSnapshot | null>;
+    dispose(): void;
+    getSnapshot(): IBoardPointerStateSnapshot | null;
+    setPointer(state: IBoardPointerStateSnapshot): void;
+}

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

@@ -0,0 +1,38 @@
+import type { IBoardRect } from '@univerjs-pro/boards';
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { IShapeHostAdapterRegistry } from '@univerjs-pro/engine-shape';
+import { ShapeFormulaService } from '@univerjs-pro/shape-editor';
+import { IRenderManagerService } from '@univerjs/engine-render';
+import { IBoardElementStateService } from './board-element-state.service';
+import { IBoardUIStateService } from './board-ui-state.service';
+export declare const BOARD_SCREENSHOT_MIN_SCALE = 0.1;
+export declare const BOARD_SCREENSHOT_MAX_SCALE = 4;
+export interface IBoardScreenshotOptions {
+    bounds: IBoardRect;
+    scale?: number;
+}
+export interface IBoardScreenshotResult {
+    contentBounds: IBoardRect;
+    dataUrl: string;
+    height: number;
+    scale: number;
+    subUnitId: string;
+    unitId: string;
+    width: number;
+}
+export declare class BoardScreenshotService {
+    private readonly _boardElementService;
+    private readonly _boardElementStateService;
+    private readonly _boardUIStateService;
+    private readonly _renderManagerService;
+    private readonly _shapeHostAdapterRegistry;
+    private readonly _shapeFormulaService;
+    constructor(_boardElementService: IBoardElementService, _boardElementStateService: IBoardElementStateService, _boardUIStateService: IBoardUIStateService, _renderManagerService: IRenderManagerService, _shapeHostAdapterRegistry: IShapeHostAdapterRegistry, _shapeFormulaService: ShapeFormulaService);
+    capture(unitId: string, subUnitId: string, options: IBoardScreenshotOptions): Promise<IBoardScreenshotResult | false>;
+    private _prepareCaptureState;
+    private _restoreCaptureState;
+    private _waitForElements;
+    private _waitForFormulaShapes;
+    private _waitForViewport;
+    private _waitForStableImage;
+}

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

@@ -1,6 +1,7 @@
 import type { BoardModel } from '@univerjs-pro/boards';
 import type { IBoardSelectionPoint } from '../utils/board-selection-interaction.util';
 import { IBoardElementService } from '@univerjs-pro/boards';
+import { IRenderManagerService } from '@univerjs/engine-render';
 import { IBoardElementStateService } from './board-element-state.service';
 export interface IBoardPointerSelectionOptions {
     boardModel: BoardModel | null | undefined;
@@ -13,7 +14,10 @@ export interface IBoardPointerSelectionOptions {
 export declare class BoardSelectionService {
     private readonly _boardElementService;
     private readonly _elementStateService;
-    constructor(_boardElementService: IBoardElementService, _elementStateService: IBoardElementStateService);
+    private readonly _renderManagerService;
+    constructor(_boardElementService: IBoardElementService, _elementStateService: IBoardElementStateService, _renderManagerService: Pick<IRenderManagerService, 'getRenderUnitById'>);
     selectByPointerGesture(options: IBoardPointerSelectionOptions): boolean;
+    private _createRenderBoundsResolver;
+    private _createRenderHitTester;
     private _resolveInvertedSelection;
 }

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

@@ -1,13 +1,11 @@
-import type { BoardModel, IBoardSettings } from '@univerjs-pro/boards';
+import type { BoardModel } from '@univerjs-pro/boards';
+import type { IBoardSettings } from '../config/config';
 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);
+    constructor(_commandService: ICommandService, _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-shortcut-runtime.service.d.ts

@@ -0,0 +1,32 @@
+import type { BoardModel } from '@univerjs-pro/boards';
+import type { IAccessor, IExecutionOptions } from '@univerjs/core';
+import type { IRenderContext, IRenderModule } from '@univerjs/engine-render';
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { Disposable, ICommandService, IConfigService, IUniverInstanceService } from '@univerjs/core';
+import { BoardClipboardService } from './board-clipboard.service';
+import { BoardElementEditService } from './board-element-edit.service';
+import { IBoardElementStateService } from './board-element-state.service';
+import { BoardSettingsService } from './board-settings.service';
+import { BoardSwimlaneLaneRenameService } from './board-swimlane-lane-rename.service';
+import { BoardTextEditingService } from './board-text-editing.service';
+import { BoardToolService } from './board-tool.service';
+import { IBoardUIStateService } from './board-ui-state.service';
+import { BoardViewportService } from './board-viewport.service';
+export declare class BoardShortcutRuntimeService extends Disposable implements IRenderModule {
+    readonly renderContext: IRenderContext<BoardModel>;
+    readonly instanceService: IUniverInstanceService;
+    readonly commandService: ICommandService;
+    readonly configService: IConfigService;
+    readonly elementService: IBoardElementService;
+    readonly elementStateService: IBoardElementStateService;
+    readonly uiStateService: IBoardUIStateService;
+    readonly clipboardService: BoardClipboardService;
+    readonly elementEditService: BoardElementEditService;
+    readonly settingsService: BoardSettingsService;
+    readonly swimlaneLaneRenameService: BoardSwimlaneLaneRenameService;
+    readonly textEditingService: BoardTextEditingService;
+    readonly toolService: BoardToolService;
+    readonly viewportService: BoardViewportService;
+    constructor(renderContext: IRenderContext<BoardModel>, instanceService: IUniverInstanceService, commandService: ICommandService, configService: IConfigService, elementService: IBoardElementService, elementStateService: IBoardElementStateService, uiStateService: IBoardUIStateService, clipboardService: BoardClipboardService, elementEditService: BoardElementEditService, settingsService: BoardSettingsService, swimlaneLaneRenameService: BoardSwimlaneLaneRenameService, textEditingService: BoardTextEditingService, toolService: BoardToolService, viewportService: BoardViewportService);
+}
+export declare function resolveBoardShortcutRuntime(accessor: IAccessor, options?: IExecutionOptions): BoardShortcutRuntimeService | null;

package/lib/types/services/board-text-editing.service.d.ts

@@ -1,17 +1,18 @@
-import type { IShapeTextEditingParams, IShapeTextHostSizeUpdateParams, IShapeTextUpdateParams } from '@univerjs-pro/shape-editor-ui';
 import type { Nullable } from '@univerjs/core';
 import type { Observable } from 'rxjs';
 import { IBoardElementService } from '@univerjs-pro/boards';
+import * as ShapeEditorUI from '@univerjs-pro/shape-editor-ui';
 import { Disposable } from '@univerjs/core';
 import { BoardElementEditService } from './board-element-edit.service';
 import { BoardShapeIntrinsicSizeService } from './board-shape-intrinsic-size.service';
-export interface IBoardTextEditingParams extends IShapeTextEditingParams {
+export interface IBoardTextEditingParams extends ShapeEditorUI.IShapeTextEditingParams {
     unitId: string;
     subUnitId: string;
     shapeId: string;
     shapeKey: string;
     visible: boolean;
 }
+type IBoardTextEditingKeyParams = Pick<IBoardTextEditingParams, 'shapeId' | 'subUnitId' | 'unitId'>;
 export declare class BoardTextEditingService extends Disposable {
     private readonly _boardElementService;
     private readonly _editService;
@@ -23,18 +24,20 @@ export declare class BoardTextEditingService extends Disposable {
     private _ignoreExternalFocusChangesUntil;
     private _discardEditingKey;
     private _externalCompletionPointerDownEvent;
+    private _connectorLabelHistory;
     constructor(_boardElementService: IBoardElementService, _editService: BoardElementEditService, _intrinsicSizeService: BoardShapeIntrinsicSizeService);
     dispose(): void;
     setEditing(params: Nullable<IBoardTextEditingParams>): void;
     setOnSavingEditorData(params: Nullable<boolean>): void;
     getEditing(): Nullable<IBoardTextEditingParams>;
+    markConnectorLabelInsertion(params: IBoardTextEditingKeyParams, historyId: string): void;
     ignoreExternalFocusChanges(duration?: number): void;
     shouldIgnoreExternalFocusChanges(): boolean;
     completeEditing(event?: PointerEvent): void;
     shouldIgnoreSelectionPointerDown(evt: Event): boolean;
     cancelEditing(): void;
-    updateShapeText(params: IShapeTextUpdateParams): boolean;
-    updatePlainTextShapeHostSize(params: IShapeTextHostSizeUpdateParams): boolean;
+    updateShapeText(params: ShapeEditorUI.IShapeTextUpdateParams): boolean;
+    updatePlainTextShapeHostSize(params: ShapeEditorUI.IShapeTextHostSizeUpdateParams): boolean;
     private _updateConnectorLabelText;
     private _resolveHostSize;
     private _resolveConnectorLabelHostSize;
@@ -43,3 +46,5 @@ export declare class BoardTextEditingService extends Disposable {
     private _ensureConnectorLabel;
     private _shouldDiscardEditorUpdate;
 }
+export declare function areBoardShapeTextValuesEquivalent(first: unknown, second: unknown): boolean;
+export {};

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

@@ -71,7 +71,6 @@ export declare class BoardToolService {
             root: IBoardToolMindMapBlueprintNode;
         };
     }): void;
-    private _beginImport;
     private _resolveShapePendingInsert;
     beginShapeInsert(shapeType: BoardShapeType | string, options?: IBoardShapeInsertOptions): void;
     beginShapeInsertDrag(shapeType: BoardShapeType | string, options?: IBoardShapeInsertOptions): void;

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

@@ -1,4 +1,5 @@
-import type { BoardConnectorRouting, BoardShapeType, IBoardConnectorStyle, IBoardSettings, IBoardSwimlaneData } from '@univerjs-pro/boards';
+import type { BoardConnectorRouting, BoardShapeType, IBoardConnectorStyle, IBoardSwimlaneData } from '@univerjs-pro/boards';
+import type { IBoardSettings } from '../config/config';
 import type { IBoardInsertRect } from '../utils/board-insert.util';
 import type { IBoardViewportPoint, IBoardViewportTransform } from '../utils/board-viewport.util';
 import { BoardToolType } from '@univerjs-pro/boards';

package/lib/types/services/board-unit-presence-ui-adapter.service.d.ts

@@ -0,0 +1,32 @@
+import type { ILocalUnitPresenceState, IRemoteUnitPresenceState, IUnitPresenceUIAdapter } from '@univerjs/ui';
+import type { Observable } from 'rxjs';
+import { IUniverInstanceService, RxDisposable, UniverInstanceType } from '@univerjs/core';
+import { IBoardElementStateService } from './board-element-state.service';
+import { IBoardPointerStateService } from './board-pointer-state.service';
+import { IBoardUIStateService } from './board-ui-state.service';
+export declare class BoardUnitPresenceUIAdapter extends RxDisposable implements IUnitPresenceUIAdapter {
+    private readonly _boardElementStateService;
+    private readonly _boardPointerStateService;
+    private readonly _boardUIStateService;
+    private readonly _univerInstanceService;
+    readonly unitType = UniverInstanceType.UNIVER_BOARD;
+    readonly presenceKind = "board-element-selection";
+    readonly statusUIPart = "board.top-right-menu.leading";
+    private readonly _active$;
+    private _activationCount;
+    readonly active$: Observable<boolean>;
+    readonly localPresence$: Observable<ILocalUnitPresenceState>;
+    private readonly _remotePresences;
+    constructor(_boardElementStateService: IBoardElementStateService, _boardPointerStateService: IBoardPointerStateService, _boardUIStateService: IBoardUIStateService, _univerInstanceService: IUniverInstanceService);
+    dispose(): void;
+    activate(): import("@wendellhu/redi").IDisposable;
+    isActive(): boolean;
+    getLocalPresence(unitId: string): ILocalUnitPresenceState | null;
+    getRemotePresences$(unitId: string): Observable<ReadonlyMap<string, IRemoteUnitPresenceState>>;
+    setRemotePresence(state: IRemoteUnitPresenceState): void;
+    removeRemotePresence(unitId: string, memberId: string): void;
+    clearRemotePresences(unitId: string): void;
+    private _getShareInterval;
+    private _getOrCreateRemotePresenceSubject;
+    private _disposeRemotePresenceSubject;
+}

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

@@ -1,6 +1,7 @@
 import type { BoardModel } from '@univerjs-pro/boards';
-import type { IBoardViewportSize, IBoardViewportZoomConfig } from '../utils/board-viewport.util';
+import type { IBoardViewportPoint, IBoardViewportSize, IBoardViewportZoomConfig } from '../utils/board-viewport.util';
 import { IBoardElementService } from '@univerjs-pro/boards';
+import { IRenderManagerService } from '@univerjs/engine-render';
 import { IBoardUIStateService } from './board-ui-state.service';
 export interface IBoardViewportFitContentOptions {
     viewportSize: IBoardViewportSize;
@@ -10,6 +11,9 @@ export interface IBoardViewportFitContentOptions {
 export declare class BoardViewportService {
     private readonly _boardElementService;
     private readonly _uiStateService;
-    constructor(_boardElementService: IBoardElementService, _uiStateService: IBoardUIStateService);
+    private readonly _renderManagerService;
+    constructor(_boardElementService: IBoardElementService, _uiStateService: IBoardUIStateService, _renderManagerService: Pick<IRenderManagerService, 'getRenderUnitById'>);
     fitContent(boardModel: BoardModel | null | undefined, options: IBoardViewportFitContentOptions): boolean;
+    getViewportCenterPoint(boardModel: BoardModel | null | undefined): IBoardViewportPoint | null;
+    private _createRenderBoundsResolver;
 }

package/lib/types/utils/board-alignment-guides.util.d.ts

@@ -1,4 +1,5 @@
 import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IBoardGuideCandidate } from './board-guide-candidates.util';
 import type { IBoardSelectionRect } from './board-selection-geometry.util';
 export interface IBoardAlignmentGuide {
     position: number;
@@ -15,6 +16,7 @@ export interface IResolveBoardElementAlignmentGuidesOptions {
     elementData: Record<string, IBoardElementData>;
     elementOrder: string[];
     threshold: number;
+    candidates?: readonly IBoardGuideCandidate[];
 }
 export interface IBoardAlignmentSnap {
     delta: {

package/lib/types/utils/board-connector-hit-test.util.d.ts

@@ -1,4 +1,5 @@
 import type { IBoardConnectorData, IBoardConnectorPoint, IBoardElementData } from '@univerjs-pro/boards';
+import type { IBoardConnectorRenderGeometry } from './board-connector-render-geometry.util';
 import type { BoardConnectorPathCommand } from './board-connector-routing.util';
 export interface IHitTestBoardConnectorElementOptions {
     connectorData: IBoardConnectorData;
@@ -7,6 +8,7 @@ export interface IHitTestBoardConnectorElementOptions {
     connectorId?: string;
     pathCommands?: readonly BoardConnectorPathCommand[];
     routePoints?: readonly IBoardConnectorPoint[];
+    renderGeometry?: IBoardConnectorRenderGeometry | null;
     pathTolerance?: number;
 }
 export declare const BOARD_CONNECTOR_DEFAULT_HIT_TOLERANCE = 8;

package/lib/types/utils/board-connector-marker-anchor.util.d.ts

@@ -13,5 +13,4 @@ export interface IResolveBoardConnectorMarkerAnchorsOptions {
     elementData?: Record<string, IBoardElementData>;
     endpointGap?: number;
 }
-export declare const BOARD_CONNECTOR_ENDPOINT_VISUAL_GAP = 5;
 export declare function resolveBoardConnectorMarkerAnchors(_routing: BoardConnectorRouting, points: readonly IBoardConnectorPoint[], pathCommands: readonly BoardConnectorPathCommand[], options?: IResolveBoardConnectorMarkerAnchorsOptions): IBoardConnectorMarkerAnchors | null;

package/lib/types/utils/board-connector-marker.util.d.ts

@@ -2,7 +2,28 @@ import type { IBoardConnectorMarker, IBoardConnectorPoint } from '@univerjs-pro/
 import type { UniverRenderingContext } from '@univerjs/engine-render';
 export declare const BOARD_CONNECTOR_DEFAULT_MARKER_SIZE = 12;
 export declare const BOARD_CONNECTOR_DEFAULT_MARKER_COLOR = "#1f2937";
+export declare const BOARD_CONNECTOR_ENDPOINT_VISUAL_GAP = 5;
+export type BoardConnectorMarkerUnderlayPolicy = 'continue-to-tip' | 'stop-at-base';
+export interface IBoardConnectorMarkerGeometry {
+    size: number;
+    tipOffset: number;
+    strokeCutback: number;
+    rearExtent: number;
+    forwardExtent: number;
+    lateralExtent: number;
+    strokeOutset: number;
+    underlayPolicy: BoardConnectorMarkerUnderlayPolicy;
+}
+export interface IBoardConnectorMarkerPaintBounds {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
 export declare function resolveBoardConnectorMarkerSize(marker: IBoardConnectorMarker, strokeWidth: number): number;
+export declare function resolveBoardConnectorMarkerGeometry(marker: IBoardConnectorMarker | undefined, strokeWidth: number): IBoardConnectorMarkerGeometry;
+export declare function resolveBoardConnectorMarkerPaintBounds(marker: IBoardConnectorMarker | undefined, point: IBoardConnectorPoint, tangent: IBoardConnectorPoint, strokeWidth: number): IBoardConnectorMarkerPaintBounds | null;
+export declare function resolveBoardConnectorMarkerTerminalLength(marker: IBoardConnectorMarker | undefined, strokeWidth: number, endpointGap: number, cornerExit: number): number;
 export declare function getBoardConnectorMarkerTrim(marker: IBoardConnectorMarker | undefined, strokeWidth: number): number;
 export declare function hitTestBoardConnectorMarker(marker: IBoardConnectorMarker | undefined, point: IBoardConnectorPoint, markerPoint: IBoardConnectorPoint, tangent: IBoardConnectorPoint, style: {
     strokeWidth: number;

package/lib/types/utils/board-connector-quick-connect.util.d.ts

@@ -10,6 +10,7 @@ export interface ICreateBoardConnectorQuickConnectElementsOptions {
     style: IBoardConnectorStyle;
     targetPoint?: IBoardConnectorPoint;
     shapeType?: ShapeTypeEnum | string;
+    sourceShape?: IBoardShapeElement;
     sourceSize?: {
         width?: number;
         height?: number;

package/lib/types/utils/board-connector-render-bounds.util.d.ts

@@ -7,5 +7,4 @@ export interface IResolveBoardConnectorRenderBoundsOptions {
     stabilityHint?: IResolveBoardConnectorRoutePointsOptions['stabilityHint'];
 }
 export declare function expandBoardConnectorBounds(bounds: IBoardConnectorRouteBounds, padding: number): IBoardConnectorRouteBounds;
-export declare function resolveBoardConnectorMarkerBoundsPadding(connectorData: IBoardConnectorData): number;
 export declare function resolveBoardConnectorRenderBounds(connectorData: IBoardConnectorData, options?: IResolveBoardConnectorRenderBoundsOptions): IBoardConnectorRouteBounds;

package/lib/types/utils/board-connector-render-geometry.util.d.ts

@@ -0,0 +1,33 @@
+import type { IBoardConnectorData, IBoardConnectorPoint, IBoardElementData } from '@univerjs-pro/boards';
+import type { IBoardConnectorMarkerAnchors } from './board-connector-marker-anchor.util';
+import type { IBoardConnectorMarkerGeometry, IBoardConnectorMarkerPaintBounds } from './board-connector-marker.util';
+import type { BoardConnectorPathCommand, IBoardConnectorRouteBounds } from './board-connector-routing.util';
+export interface IBoardConnectorTerminalRenderGeometry {
+    anchor: IBoardConnectorMarkerAnchors['start'];
+    marker: IBoardConnectorMarkerGeometry;
+    markerBounds: IBoardConnectorMarkerPaintBounds | null;
+    endpointGap: number;
+    strokeTrim: number;
+    terminalSegmentLength: number;
+    requiredTerminalLength: number;
+}
+export interface IBoardConnectorRenderGeometry {
+    routePoints: readonly IBoardConnectorPoint[];
+    pathCommands: readonly BoardConnectorPathCommand[];
+    strokeRoutePoints: readonly IBoardConnectorPoint[];
+    strokePathCommands: readonly BoardConnectorPathCommand[];
+    start: IBoardConnectorTerminalRenderGeometry;
+    end: IBoardConnectorTerminalRenderGeometry;
+    strokePathLength: number;
+    dashOffset: number;
+    bounds: IBoardConnectorRouteBounds;
+}
+export interface IResolveBoardConnectorRenderGeometryOptions {
+    connectorData: IBoardConnectorData;
+    routePoints: readonly IBoardConnectorPoint[];
+    pathCommands: readonly BoardConnectorPathCommand[];
+    elementData?: Record<string, IBoardElementData>;
+    fallbackBounds?: IBoardConnectorRouteBounds;
+}
+export declare function resolveBoardConnectorDashOffset(dash: readonly number[] | undefined, pathLength: number, hasStartMarker: boolean, hasEndMarker: boolean): number;
+export declare function resolveBoardConnectorRenderGeometry(options: IResolveBoardConnectorRenderGeometryOptions): IBoardConnectorRenderGeometry | null;

package/lib/types/utils/board-connector-router.util.d.ts

@@ -56,6 +56,7 @@ export interface IResolveBoardOrthogonalObstacleRouteOptions {
     };
     fallbackRoute?: () => IBoardConnectorPoint[];
 }
+export declare function createBoardConnectorRoutingObstaclesForElementIds(elementData: Record<string, IBoardElementData>, elementIds: Iterable<string>, clearance?: number): IBoardRoutingObstacle[];
 export declare function createBoardConnectorRoutingObstacleIndex(elementData: Record<string, IBoardElementData> | undefined, options?: ICreateBoardConnectorRoutingObstaclesOptions): IBoardRoutingObstacleIndex;
 export declare function isBoardRoutingPointInsideObstacle(point: IBoardConnectorPoint, obstacle: IBoardRoutingObstacle): boolean;
 export declare function doesBoardRoutingSegmentIntersectObstacle(segment: IBoardRoutingSegment, obstacle: IBoardRoutingObstacle): boolean;

package/lib/types/utils/board-connector-routing.util.d.ts

@@ -1,5 +1,5 @@
-import type { IBoardConnectorData, IBoardConnectorEndpoint, IBoardConnectorPoint, IBoardElementData, IBoardElementTransform } from '@univerjs-pro/boards';
-import type { IBoardRoutingSegment } from './board-connector-router.util';
+import type { IBoardConnectorData, IBoardConnectorElement, IBoardConnectorEndpoint, IBoardConnectorMarker, IBoardConnectorPoint, IBoardElementData, IBoardElementTransform } from '@univerjs-pro/boards';
+import type { IBoardRoutingObstacleIndex, IBoardRoutingSegment } from './board-connector-router.util';
 export interface IBoardConnectorRouteBounds {
     left: number;
     top: number;
@@ -44,13 +44,37 @@ export interface IResolveBoardConnectorRoutePointsOptions extends IResolveBoardC
         tolerance?: number;
     };
     resolvedRoutePoints?: readonly IBoardConnectorPoint[];
+    routingCache?: BoardConnectorRoutingCache;
+    connectorCrossingPenaltyEnabled?: boolean;
 }
 export declare const BOARD_CONNECTOR_MIN_BOUNDS_SIZE = 1;
+export declare const BOARD_CONNECTOR_ROUNDED_CORNER_RADIUS = 16;
+type IBoardConnectorElementData = IBoardElementData & {
+    element: IBoardConnectorElement;
+};
 export declare function resolveBoardConnectorEndpointPoint(endpoint: IBoardConnectorEndpoint, options?: IResolveBoardConnectorEndpointPointOptions): IBoardConnectorPoint | null;
 export declare function resolveBoardConnectorEndpoint(endpoint: IBoardConnectorEndpoint, options?: IResolveBoardConnectorEndpointOptions): IBoardConnectorResolvedEndpoint | null;
 export declare function isBoardConnectorTerminalSegmentAlignedWithEndpointNormal(segment: IBoardRoutingSegment, endpoint: IBoardConnectorResolvedEndpoint, terminal: 'start' | 'end'): boolean;
 export declare function isBoardConnectorRouteAlignedWithEndpoints(connectorData: IBoardConnectorData, routePoints: readonly IBoardConnectorPoint[] | undefined, options?: IResolveBoardConnectorEndpointPointOptions): routePoints is readonly IBoardConnectorPoint[];
 export declare function normalizeBoardConnectorEndpointManualRoutePoints(connectorData: IBoardConnectorData, options?: IResolveBoardConnectorEndpointOptions): IBoardConnectorData;
+export declare class BoardConnectorRoutingCache {
+    private _elementData?;
+    private readonly _connectorSceneKeyById;
+    private readonly _obstacleKeyByElementId;
+    private readonly _obstacleIndexesByExclusion;
+    private readonly _routePointsByConnectorId;
+    private readonly _crossingRoutePointsByConnectorId;
+    invalidate(elementData?: Record<string, IBoardElementData>, invalidatedElementIds?: Iterable<string>): string[];
+    private _reset;
+    private _syncConnectorSnapshot;
+    private _syncObstacleSnapshot;
+    private _invalidateDependentRoutes;
+    getObstacleIndex(elementData: Record<string, IBoardElementData> | undefined, excludeElementIds: readonly string[]): IBoardRoutingObstacleIndex;
+    resolveRoutePoints(connectorData: IBoardConnectorData, options?: IResolveBoardConnectorRoutePointsOptions): IBoardConnectorPoint[];
+    private _resolveRouteDependency;
+    resolveCrossingRoutePoints(item: IBoardConnectorElementData, elementData: Record<string, IBoardElementData>): IBoardConnectorPoint[];
+}
+export declare function resolveBoardConnectorTerminalPadding(marker: IBoardConnectorMarker | undefined, strokeWidth: number, rounded: boolean): number;
 export declare function resolveBoardConnectorRoutePoints(connectorData: IBoardConnectorData, options?: IResolveBoardConnectorRoutePointsOptions): IBoardConnectorPoint[];
 export declare function resolveBoardConnectorPathCommands(connectorData: IBoardConnectorData, options?: IResolveBoardConnectorRoutePointsOptions): BoardConnectorPathCommand[];
 export declare function resolveBoardConnectorPathBounds(commands: readonly BoardConnectorPathCommand[], fallbackTransform?: IBoardElementTransform): IBoardConnectorRouteBounds;
@@ -63,7 +87,11 @@ export declare function resolveBoardConnectorPathBounds(commands: readonly Board
  */
 export declare function resolveBoardConnectorPathGeometry(commands: readonly BoardConnectorPathCommand[]): IBoardConnectorPathGeometry | null;
 export declare function trimBoardConnectorPathCommands(commands: readonly BoardConnectorPathCommand[], startTrim: number, endTrim: number): BoardConnectorPathCommand[];
+export declare function resolveBoardConnectorPathLength(commands: readonly BoardConnectorPathCommand[]): number;
+export declare function resolveBoardConnectorRoundedRoutePathLength(points: readonly IBoardConnectorPoint[], cornerRadius?: number): number;
 export declare function hitTestBoardConnectorPath(point: IBoardConnectorPoint, commands: readonly BoardConnectorPathCommand[], tolerance: number): boolean;
 export declare function resolveBoardConnectorRouteBounds(points: readonly IBoardConnectorPoint[], fallbackTransform?: IBoardElementTransform): IBoardConnectorRouteBounds;
 export declare function distanceToBoardConnectorSegment(point: IBoardConnectorPoint, start: IBoardConnectorPoint, end: IBoardConnectorPoint): number;
+export declare function resolveBoardConnectorPolylineLength(points: readonly IBoardConnectorPoint[]): number;
 export declare function trimBoardConnectorRoute(points: readonly IBoardConnectorPoint[], startTrim: number, endTrim: number): IBoardConnectorPoint[];
+export {};

package/lib/types/utils/board-container-spatial-index.util.d.ts

@@ -1,4 +1,5 @@
 import type { IBoardElementData, IBoardRect } from '@univerjs-pro/boards';
+import { resolveBoardElementBounds } from './board-selection-geometry.util';
 export interface IBoardPoint {
     x: number;
     y: number;
@@ -7,6 +8,7 @@ export interface ICreateBoardElementSpatialIndexOptions {
     unitId: string;
     subUnitId: string;
     elementData: Record<string, IBoardElementData>;
+    resolveElementBounds?: Parameters<typeof resolveBoardElementBounds>[2];
 }
 export interface IBoardElementSpatialIndex {
     queryIntersecting(bounds: IBoardRect): string[];

package/lib/types/utils/board-floating-toolbar-selection.util.d.ts

@@ -1,5 +1,8 @@
-import type { BoardConnectorRouting, IBoardConnectorStyle, IBoardElementData } from '@univerjs-pro/boards';
+import type { BoardConnectorRouting, IBoardConnectorStyle, IBoardContainerElement, IBoardElementData, IBoardSwimlaneLane, IBoardTextStyle } from '@univerjs-pro/boards';
 import type { IShapeData } from '@univerjs-pro/engine-shape';
+import type { buildShapeTextDataUpdate } from '@univerjs-pro/shape-editor-ui';
+import type { ITextStyle } from '@univerjs/core';
+import { HorizontalAlign, VerticalAlign } from '@univerjs/core';
 export type BoardFloatingToolbarOwner = 'common' | 'connector' | 'mind-map' | 'none' | 'shape' | 'table';
 export interface IBoardFloatingToolbarSelection {
     elements: IBoardElementData[];
@@ -13,6 +16,24 @@ export interface IResolveBoardFloatingToolbarSelectionOptions {
     selectedIds: readonly string[];
     getElementById: (unitId: string, subUnitId: string, elementId: string) => IBoardElementData | null | undefined;
 }
+export interface IBoardSwimlaneLaneTypographyTarget {
+    container: IBoardContainerElement;
+    lane: IBoardSwimlaneLane;
+}
+export declare function boardTextStyleToToolbarTextStyle(style: IBoardTextStyle | undefined, fallbackFontSize: number): ITextStyle;
+export declare function getContainerTitleStyle(element: IBoardContainerElement | undefined): IBoardTextStyle | undefined;
+export declare function getSwimlaneLaneTypographyTarget(element: IBoardContainerElement | undefined, laneId: string | undefined): IBoardSwimlaneLaneTypographyTarget | null;
+export declare function getSwimlaneLaneTitleTextModel(target: IBoardSwimlaneLaneTypographyTarget | null): {
+    ha?: HorizontalAlign;
+    va?: VerticalAlign;
+} | null;
+export declare function getSwimlaneContainerTitleTextModel(element: IBoardContainerElement | undefined): {
+    ha?: HorizontalAlign;
+    va?: VerticalAlign;
+} | null;
+export declare function isUnfocusedSwimlaneTypographyTarget(element: IBoardContainerElement, laneTarget: IBoardSwimlaneLaneTypographyTarget | null): boolean;
+export declare function buildTitleStyleUpdate(currentStyle: IBoardTextStyle | undefined, params: Parameters<typeof buildShapeTextDataUpdate>[1]): IBoardTextStyle;
+export declare function buildContainerTitleStyleUpdate(element: IBoardContainerElement, params: Parameters<typeof buildShapeTextDataUpdate>[1]): IBoardTextStyle;
 /**
  * Resolves one owner for the selection-level floating toolbar.
  *

package/lib/types/utils/board-guide-candidates.util.d.ts

@@ -0,0 +1,13 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IBoardSelectionRect } from './board-selection-geometry.util';
+export interface IBoardGuideCandidate {
+    elementId: string;
+    rect: IBoardSelectionRect;
+}
+export interface ICreateBoardGuideCandidatesOptions {
+    activeIds: readonly string[];
+    bounds?: IBoardSelectionRect;
+    elementData: Record<string, IBoardElementData>;
+    elementOrder: readonly string[];
+}
+export declare function createBoardGuideCandidates(options: ICreateBoardGuideCandidatesOptions): IBoardGuideCandidate[];

package/lib/types/utils/board-page-background-image.util.d.ts

@@ -0,0 +1,15 @@
+import type { BoardBackgroundImageFit } from '@univerjs-pro/boards';
+export interface IBoardPageBackgroundImageSource {
+    fit: BoardBackgroundImageFit;
+    image: HTMLImageElement;
+}
+export interface IDrawBoardPageBackgroundImageOptions {
+    cropLeft?: number;
+    cropTop?: number;
+    frameHeight: number;
+    frameWidth: number;
+    scaleX?: number;
+    scaleY?: number;
+}
+export declare function getBoardPageBackgroundImageSource(unitId: string, subUnitId: string, root?: ParentNode): IBoardPageBackgroundImageSource | null;
+export declare function drawBoardPageBackgroundImage(context: CanvasRenderingContext2D, source: IBoardPageBackgroundImageSource, options: IDrawBoardPageBackgroundImageOptions): void;