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

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

@@ -0,0 +1,45 @@
+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 { Disposable } from '@univerjs/core';
+import { BoardElementEditService } from './board-element-edit.service';
+import { BoardShapeIntrinsicSizeService } from './board-shape-intrinsic-size.service';
+export interface IBoardTextEditingParams extends IShapeTextEditingParams {
+    unitId: string;
+    subUnitId: string;
+    shapeId: string;
+    shapeKey: string;
+    visible: boolean;
+}
+export declare class BoardTextEditingService extends Disposable {
+    private readonly _boardElementService;
+    private readonly _editService;
+    private readonly _intrinsicSizeService;
+    private readonly _editingParams$;
+    readonly editingParams$: Observable<Nullable<IBoardTextEditingParams>>;
+    private readonly _onSavingEditorData$;
+    readonly onSavingEditorData$: Observable<Nullable<boolean>>;
+    private _ignoreExternalFocusChangesUntil;
+    private _discardEditingKey;
+    private _externalCompletionPointerDownEvent;
+    constructor(_boardElementService: IBoardElementService, _editService: BoardElementEditService, _intrinsicSizeService: BoardShapeIntrinsicSizeService);
+    dispose(): void;
+    setEditing(params: Nullable<IBoardTextEditingParams>): void;
+    setOnSavingEditorData(params: Nullable<boolean>): void;
+    getEditing(): Nullable<IBoardTextEditingParams>;
+    ignoreExternalFocusChanges(duration?: number): void;
+    shouldIgnoreExternalFocusChanges(): boolean;
+    completeEditing(event?: PointerEvent): void;
+    shouldIgnoreSelectionPointerDown(evt: Event): boolean;
+    cancelEditing(): void;
+    updateShapeText(params: IShapeTextUpdateParams): boolean;
+    updatePlainTextShapeHostSize(params: IShapeTextHostSizeUpdateParams): boolean;
+    private _updateConnectorLabelText;
+    private _resolveHostSize;
+    private _resolveConnectorLabelHostSize;
+    private _updateConnectorLabelSize;
+    private _updateConnectorLabelElement;
+    private _ensureConnectorLabel;
+    private _shouldDiscardEditorUpdate;
+}

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

@@ -0,0 +1,85 @@
+import type { BoardConnectorRouting, BoardShapeType, IBoardConnectorStyle, IBoardSwimlaneData } from '@univerjs-pro/boards';
+import type { IBoardPendingInsert } from './board-ui-state.service';
+import { BoardToolType } from '@univerjs-pro/boards';
+import { ICommandService, IConfigService, IUniverInstanceService } from '@univerjs/core';
+import { IBoardUIStateService } from './board-ui-state.service';
+export interface IBoardTableInsertOptions {
+    rows?: number;
+    columns?: number;
+    keepShapeSidebarOpen?: boolean;
+    width?: number;
+    height?: number;
+    diagramPreset?: string;
+}
+export interface IBoardShapeInsertOptions {
+    height?: number;
+    width?: number;
+}
+interface IBoardToolMindMapBlueprintNode {
+    text: string;
+    orderKey?: string;
+    side?: 'left' | 'right' | 'top' | 'bottom';
+    collapsed?: boolean;
+    branchColorKey?: string;
+    foreignAttributes?: Record<string, string>;
+    children: IBoardToolMindMapBlueprintNode[];
+}
+export declare class BoardToolService {
+    private readonly _stateService;
+    private readonly _commandService;
+    private readonly _instanceService;
+    private readonly _configService;
+    constructor(_stateService: IBoardUIStateService, _commandService: ICommandService, _instanceService: IUniverInstanceService, _configService: IConfigService);
+    private _getInsertConfig;
+    private _isToolbarAvailable;
+    private _collapseInsertTools;
+    collapseFloatingTools(): void;
+    closeShapeSidebar(): void;
+    private _getActiveBoardModel;
+    private _executeActiveBoardOperation;
+    activateToolbarTool(tool: BoardToolType): void;
+    private _insertTable;
+    private _resolveTablePendingInsert;
+    beginTableInsert(size?: IBoardTableInsertOptions): void;
+    beginTableInsertDrag(size?: IBoardTableInsertOptions): void;
+    private _insertChart;
+    private _beginLineMode;
+    beginLineInsert(routing: BoardConnectorRouting, style?: Partial<IBoardConnectorStyle>): void;
+    private _openContainerPanel;
+    beginContainerInsert(size?: {
+        width?: number;
+        height?: number;
+    }): void;
+    private _openSwimlanePanel;
+    beginSwimlaneInsert(orientation: IBoardSwimlaneData['orientation']): void;
+    private _beginPenMode;
+    private _openMindMapPanel;
+    beginMindMapInsert(template?: {
+        rootText?: string;
+        structureKind?: 'mindmap-horizontal' | 'mindmap-vertical' | 'tree-right' | 'tree-left' | 'tree-alternate' | 'timeline-horizontal' | 'timeline-vertical';
+        branchLineType?: 'rounded-orthogonal' | 'curve' | 'orthogonal';
+        children?: Array<{
+            text?: string;
+            orderKey?: string;
+            side?: 'left' | 'right' | 'top' | 'bottom';
+            collapsed?: boolean;
+            branchColorKey?: string;
+            foreignAttributes?: Record<string, string>;
+        }>;
+        blueprint?: {
+            title?: string;
+            root: IBoardToolMindMapBlueprintNode;
+        };
+    }): void;
+    private _beginResourcesPanel;
+    private _beginImport;
+    private _resolveShapePendingInsert;
+    beginShapeInsert(shapeType: BoardShapeType | string, options?: IBoardShapeInsertOptions): void;
+    beginShapeInsertDrag(shapeType: BoardShapeType | string, options?: IBoardShapeInsertOptions): void;
+    beginPendingInsertDrag(pendingInsert: IBoardPendingInsert): void;
+    cancelPendingInsertDrag(): void;
+    beginStickyInsert(fillColor: string): void;
+    beginStickyInsertDrag(fillColor: string): void;
+    openShapeSidebar(): void;
+}
+export {};

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

@@ -0,0 +1,98 @@
+import type { BoardConnectorRouting, BoardShapeType, IBoardConnectorStyle, IBoardSettings, IBoardSwimlaneData } from '@univerjs-pro/boards';
+import type { IBoardInsertRect } from '../utils/board-insert.util';
+import type { IBoardViewportPoint, IBoardViewportTransform } from '../utils/board-viewport.util';
+import { BoardToolType } from '@univerjs-pro/boards';
+import { Disposable, IConfigService } from '@univerjs/core';
+import { BehaviorSubject } from 'rxjs';
+export type IBoardPendingInsert = {
+    type: BoardToolType.Shape;
+    shapeType: BoardShapeType | string;
+    width?: number;
+    height?: number;
+} | {
+    type: BoardToolType.Text;
+} | {
+    type: BoardToolType.Sticky;
+    fillColor: string;
+} | {
+    type: BoardToolType.Container;
+    width?: number;
+    height?: number;
+} | {
+    type: BoardToolType.Swimlane;
+    orientation?: IBoardSwimlaneData['orientation'];
+} | {
+    type: BoardToolType.Table;
+    columns: number;
+    diagramPreset?: string;
+    height: number;
+    rows: number;
+    width: number;
+} | {
+    type: BoardToolType.MindMap;
+};
+export interface IBoardUIState {
+    settings: Required<IBoardSettings>;
+    activeTool: BoardToolType | null;
+    connectorRouting: BoardConnectorRouting;
+    connectorStyle: IBoardConnectorStyle;
+    pendingInsert: IBoardPendingInsert | null;
+    pendingInsertDragActive: boolean;
+    pendingInsertPreviewRect: IBoardInsertRect | null;
+    objectListPanelOpen: boolean;
+    shapeSidebarOpen: boolean;
+    zoomRatio: number;
+    viewportPanOffset: IBoardViewportPoint;
+}
+export interface IBoardUIStateService {
+    readonly state$: ReturnType<BehaviorSubject<IBoardUIState>['asObservable']>;
+    getState(): IBoardUIState;
+    getSettings(): Required<IBoardSettings>;
+    setSettings(settings: Partial<IBoardSettings>): void;
+    setActiveTool(tool: BoardToolType | null): void;
+    setConnectorRouting(routing: BoardConnectorRouting | string | undefined): void;
+    setConnectorStyle(style: Partial<IBoardConnectorStyle>): void;
+    reverseConnectorMarkers(): void;
+    setPendingInsert(pendingInsert: IBoardPendingInsert): void;
+    beginPendingInsertDrag(pendingInsert: IBoardPendingInsert): void;
+    endPendingInsertDrag(): void;
+    setPendingInsertPreviewRect(rect: IBoardInsertRect | null): void;
+    clearPendingInsert(): void;
+    setObjectListPanelOpen(open: boolean): void;
+    setShapeSidebarOpen(open: boolean): void;
+    setZoomRatio(zoomRatio: number): void;
+    setZoomRatioAtViewportPoint(zoomRatio: number, viewportPoint: IBoardViewportPoint): void;
+    setViewportPanOffset(panOffset: IBoardViewportPoint): void;
+    setViewportTransform(viewport: IBoardViewportTransform): void;
+    shiftViewportPanOffset(delta: IBoardViewportPoint): void;
+}
+export declare const IBoardUIStateService: import("@wendellhu/redi").IdentifierDecorator<IBoardUIStateService>;
+export declare class BoardUIStateService extends Disposable implements IBoardUIStateService {
+    private readonly _configService?;
+    private readonly _interactionConfig;
+    private readonly _state$;
+    readonly state$: ReturnType<BehaviorSubject<IBoardUIState>['asObservable']>;
+    constructor(_configService?: IConfigService | undefined);
+    dispose(): void;
+    getState(): IBoardUIState;
+    getSettings(): Required<IBoardSettings>;
+    private _isToolbarAvailable;
+    private _persistConnectorRoutingStyle;
+    setSettings(settings: Partial<IBoardSettings>): void;
+    setActiveTool(tool: BoardToolType | null): void;
+    setConnectorRouting(routing: BoardConnectorRouting | string | undefined): void;
+    setConnectorStyle(style: Partial<IBoardConnectorStyle>): void;
+    reverseConnectorMarkers(): void;
+    setPendingInsert(pendingInsert: IBoardPendingInsert): void;
+    beginPendingInsertDrag(pendingInsert: IBoardPendingInsert): void;
+    endPendingInsertDrag(): void;
+    setPendingInsertPreviewRect(rect: IBoardInsertRect | null): void;
+    clearPendingInsert(): void;
+    setObjectListPanelOpen(open: boolean): void;
+    setShapeSidebarOpen(open: boolean): void;
+    setZoomRatio(zoomRatio: number): void;
+    setZoomRatioAtViewportPoint(zoomRatio: number, viewportPoint: IBoardViewportPoint): void;
+    setViewportPanOffset(panOffset: IBoardViewportPoint): void;
+    setViewportTransform(viewport: IBoardViewportTransform): void;
+    shiftViewportPanOffset(delta: IBoardViewportPoint): void;
+}

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

@@ -0,0 +1,15 @@
+import type { BoardModel } from '@univerjs-pro/boards';
+import type { IBoardViewportSize, IBoardViewportZoomConfig } from '../utils/board-viewport.util';
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { IBoardUIStateService } from './board-ui-state.service';
+export interface IBoardViewportFitContentOptions {
+    viewportSize: IBoardViewportSize;
+    padding?: number;
+    zoom?: IBoardViewportZoomConfig;
+}
+export declare class BoardViewportService {
+    private readonly _boardElementService;
+    private readonly _uiStateService;
+    constructor(_boardElementService: IBoardElementService, _uiStateService: IBoardUIStateService);
+    fitContent(boardModel: BoardModel | null | undefined, options: IBoardViewportFitContentOptions): boolean;
+}

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

@@ -0,0 +1,27 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IBoardSelectionRect } from './board-selection-geometry.util';
+export interface IBoardAlignmentGuide {
+    position: number;
+    sourceElementId: string;
+    sourceId: string;
+}
+export interface IBoardAlignmentGuides {
+    vertical: IBoardAlignmentGuide[];
+    horizontal: IBoardAlignmentGuide[];
+}
+export interface IResolveBoardElementAlignmentGuidesOptions {
+    activeRect: IBoardSelectionRect;
+    activeIds: string[];
+    elementData: Record<string, IBoardElementData>;
+    elementOrder: string[];
+    threshold: number;
+}
+export interface IBoardAlignmentSnap {
+    delta: {
+        x: number;
+        y: number;
+    };
+    guides: IBoardAlignmentGuides;
+}
+export declare function resolveBoardElementAlignmentGuides(options: IResolveBoardElementAlignmentGuidesOptions): IBoardAlignmentGuides;
+export declare function resolveBoardElementAlignmentSnap(options: IResolveBoardElementAlignmentGuidesOptions): IBoardAlignmentSnap;

package/lib/types/utils/board-clipboard.util.d.ts

@@ -0,0 +1,40 @@
+import type { IBoardElementData, IUpdateBoardElementsOperationItem } from '@univerjs-pro/boards';
+export type BoardClipboardElement = IBoardElementData['element'];
+export interface IBoardClipboardPayload {
+    elements: BoardClipboardElement[];
+    resources?: Record<string, unknown>;
+}
+export type BoardElementStylePayloadKind = 'shape' | 'connector' | 'text';
+export interface IBoardElementStylePayload {
+    kind: BoardElementStylePayloadKind;
+    shapeData?: Record<string, unknown>;
+    connectorStyle?: Record<string, unknown>;
+    textStyle?: Record<string, unknown>;
+}
+export interface ICreateBoardElementClipboardPayloadOptions {
+    selectedIds: string[];
+    elementOrder: string[];
+    elementData: Record<string, IBoardElementData>;
+}
+export interface ICreateBoardPasteElementsOptions {
+    payload: IBoardClipboardPayload;
+    offset: {
+        x: number;
+        y: number;
+    };
+    targetParentId?: string;
+    createId?: (sourceId: string) => string;
+}
+export interface ICreateBoardPasteElementsWithIdMapResult {
+    elements: BoardClipboardElement[];
+    elementIdMap: Map<string, string>;
+}
+export interface ICreateBoardElementStyleUpdatesOptions {
+    payload: IBoardElementStylePayload;
+    selectedIds: string[];
+    elementData: Record<string, IBoardElementData>;
+}
+export declare function createBoardElementClipboardPayload(options: ICreateBoardElementClipboardPayloadOptions): IBoardClipboardPayload | null;
+export declare function createBoardElementStylePayload(element: BoardClipboardElement | undefined): IBoardElementStylePayload | null;
+export declare function createBoardElementStyleUpdates(options: ICreateBoardElementStyleUpdatesOptions): IUpdateBoardElementsOperationItem[];
+export declare function createBoardPasteElementsWithIdMap(options: ICreateBoardPasteElementsOptions): ICreateBoardPasteElementsWithIdMapResult;

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

@@ -0,0 +1,7 @@
+import type { IBoardConnectorData, IBoardElementData } from '@univerjs-pro/boards';
+export type BoardConnectorAdjacencyMap = Map<string, string[]>;
+export interface ICreateBoardConnectorAdjacencyMapOptions {
+    includeHidden?: boolean;
+}
+export declare function getBoardConnectorBoundShapeIds(connectorData: IBoardConnectorData): string[];
+export declare function createBoardConnectorAdjacencyMap(elementData: Record<string, IBoardElementData>, options?: ICreateBoardConnectorAdjacencyMapOptions): BoardConnectorAdjacencyMap;

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

@@ -0,0 +1,15 @@
+import type { IBoardConnectorEndpoint, IBoardConnectorPoint, IBoardElementData } from '@univerjs-pro/boards';
+export interface IBoardConnectorAffordanceHandle {
+    elementId: string;
+    endpoint: IBoardConnectorEndpoint;
+    point: IBoardConnectorPoint;
+    normal: IBoardConnectorPoint;
+    segmentIndex: number;
+    visualScreenOffset?: number;
+}
+export interface IResolveBoardConnectorAffordanceHandlesOptions {
+    selectedIds: readonly string[];
+    elementData: Record<string, IBoardElementData>;
+}
+export declare function withBoardConnectorEndpointFallbackPoint(endpoint: IBoardConnectorEndpoint, point: IBoardConnectorPoint): IBoardConnectorEndpoint;
+export declare function resolveBoardConnectorAffordanceHandles(options: IResolveBoardConnectorAffordanceHandlesOptions): IBoardConnectorAffordanceHandle[];

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

@@ -0,0 +1,14 @@
+import type { IBoardConnectorData, IBoardConnectorPoint, IBoardElementData } from '@univerjs-pro/boards';
+import type { BoardConnectorPathCommand } from './board-connector-routing.util';
+export interface IHitTestBoardConnectorElementOptions {
+    connectorData: IBoardConnectorData;
+    point: IBoardConnectorPoint;
+    elementData?: Record<string, IBoardElementData>;
+    connectorId?: string;
+    pathCommands?: readonly BoardConnectorPathCommand[];
+    routePoints?: readonly IBoardConnectorPoint[];
+    pathTolerance?: number;
+}
+export declare const BOARD_CONNECTOR_DEFAULT_HIT_TOLERANCE = 8;
+export declare function resolveBoardConnectorHitTolerance(strokeWidth?: number): number;
+export declare function hitTestBoardConnectorElement(options: IHitTestBoardConnectorElementOptions): boolean;

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

@@ -0,0 +1,17 @@
+import type { IBoardConnectorData, IBoardConnectorLabel, IBoardConnectorPoint } from '@univerjs-pro/boards';
+import type { IResolveBoardConnectorRoutePointsOptions } from './board-connector-routing.util';
+export declare const BOARD_CONNECTOR_LABEL_DEFAULT_WIDTH = 96;
+export declare const BOARD_CONNECTOR_LABEL_DEFAULT_HEIGHT = 28;
+export declare const BOARD_CONNECTOR_LABEL_DEFAULT_PATH_RATIO = 0.5;
+export declare const BOARD_CONNECTOR_LABEL_TEXT_PADDING_X = 6;
+export declare const BOARD_CONNECTOR_LABEL_TEXT_PADDING_Y = 3;
+export interface IBoardConnectorLabelRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export declare function resolveBoardConnectorLabelPathPoints(connectorData: IBoardConnectorData, options?: IResolveBoardConnectorRoutePointsOptions): IBoardConnectorPoint[];
+export declare function resolveBoardConnectorLabelRect(points: readonly IBoardConnectorPoint[], label: IBoardConnectorData['label'] | IBoardConnectorLabel): IBoardConnectorLabelRect;
+export declare function resolveBoardConnectorLabelDragUpdate(points: readonly IBoardConnectorPoint[], label: IBoardConnectorLabel, point: IBoardConnectorPoint): IBoardConnectorLabel;
+export declare function resolveBoardConnectorLabelSnapUpdate(points: readonly IBoardConnectorPoint[], label: IBoardConnectorLabel): IBoardConnectorLabel;

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

@@ -0,0 +1,17 @@
+import type { IBoardConnectorData, IBoardConnectorPoint, IBoardElementData } from '@univerjs-pro/boards';
+import type { BoardConnectorPathCommand } from './board-connector-routing.util';
+export interface IBoardConnectorMarkerAnchor {
+    point: IBoardConnectorPoint;
+    tangent: IBoardConnectorPoint;
+}
+export interface IBoardConnectorMarkerAnchors {
+    start: IBoardConnectorMarkerAnchor;
+    end: IBoardConnectorMarkerAnchor;
+}
+export interface IResolveBoardConnectorMarkerAnchorsOptions {
+    connectorData?: IBoardConnectorData;
+    elementData?: Record<string, IBoardElementData>;
+    endpointGap?: number;
+}
+export declare const BOARD_CONNECTOR_ENDPOINT_VISUAL_GAP = 5;
+export declare function resolveBoardConnectorMarkerAnchors(routing: string, points: readonly IBoardConnectorPoint[], pathCommands: readonly BoardConnectorPathCommand[], options?: IResolveBoardConnectorMarkerAnchorsOptions): IBoardConnectorMarkerAnchors | null;

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

@@ -0,0 +1,13 @@
+import type { IBoardConnectorMarker, IBoardConnectorPoint } from '@univerjs-pro/boards';
+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 function resolveBoardConnectorMarkerSize(marker: IBoardConnectorMarker, strokeWidth: 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;
+}): boolean;
+export declare function drawBoardConnectorMarker(ctx: UniverRenderingContext, marker: IBoardConnectorMarker | undefined, point: IBoardConnectorPoint, tangent: IBoardConnectorPoint, style: {
+    stroke: string;
+    strokeWidth: number;
+}): void;

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

@@ -0,0 +1,8 @@
+import type { IBoardConnectorElement, IBoardConnectorPoint, IBoardElementData } from '@univerjs-pro/boards';
+export interface IResolveBoardConnectorMoveUpdateOptions {
+    element: IBoardConnectorElement;
+    delta: IBoardConnectorPoint;
+    elementData?: Record<string, IBoardElementData>;
+}
+export declare function canMoveBoardConnectorBody(element: IBoardConnectorElement): boolean;
+export declare function resolveBoardConnectorMoveUpdate(options: IResolveBoardConnectorMoveUpdateOptions): IBoardConnectorElement;

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

@@ -0,0 +1,22 @@
+import type { BoardConnectorRouting, IBoardConnectorElement, IBoardConnectorEndpoint, IBoardConnectorPoint, IBoardConnectorStyle, IBoardElementData, IBoardShapeElement } from '@univerjs-pro/boards';
+import { ShapeTypeEnum } from '@univerjs-pro/engine-shape';
+export declare const BOARD_QUICK_CONNECT_GAP = 200;
+export interface ICreateBoardConnectorQuickConnectElementsOptions {
+    sourceEndpoint: IBoardConnectorEndpoint;
+    sourcePoint: IBoardConnectorPoint;
+    normal: IBoardConnectorPoint;
+    routing: BoardConnectorRouting;
+    style: IBoardConnectorStyle;
+    targetPoint?: IBoardConnectorPoint;
+    shapeType?: ShapeTypeEnum | string;
+    sourceSize?: {
+        width?: number;
+        height?: number;
+    };
+    elementData?: Record<string, IBoardElementData>;
+}
+export interface ICreateBoardConnectorQuickConnectElementsResult {
+    shape: IBoardShapeElement;
+    connector: IBoardConnectorElement;
+}
+export declare function createBoardConnectorQuickConnectElements(options: ICreateBoardConnectorQuickConnectElementsOptions): ICreateBoardConnectorQuickConnectElementsResult;

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

@@ -0,0 +1,11 @@
+import type { IBoardConnectorData, IBoardElementData, IBoardElementTransform } from '@univerjs-pro/boards';
+import type { IBoardConnectorRouteBounds, IResolveBoardConnectorRoutePointsOptions } from './board-connector-routing.util';
+export interface IResolveBoardConnectorRenderBoundsOptions {
+    elementData?: Record<string, IBoardElementData>;
+    connectorId?: string;
+    fallbackTransform?: IBoardElementTransform;
+    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-router.util.d.ts

@@ -0,0 +1,62 @@
+import type { IBoardConnectorPoint, IBoardElementData } from '@univerjs-pro/boards';
+export interface IBoardRoutingRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface IBoardRoutingSegment {
+    start: IBoardConnectorPoint;
+    end: IBoardConnectorPoint;
+}
+export type BoardRoutingObstacleKind = 'shape' | 'image' | 'table' | 'container' | 'generic';
+export interface IBoardRoutingObstacle {
+    id: string;
+    bounds: IBoardRoutingRect;
+    polygon?: IBoardConnectorPoint[];
+    clearance: number;
+    kind: BoardRoutingObstacleKind;
+}
+export interface IBoardRoutingPenaltyContext {
+    obstacles: readonly IBoardRoutingObstacle[];
+    searchRect: IBoardRoutingRect;
+}
+export interface IBoardRoutingGuideCoordinates {
+    xs?: readonly number[];
+    ys?: readonly number[];
+}
+export interface IBoardRoutingPenaltyProvider {
+    priority?: 'avoid' | 'soft';
+    scoreSegment(segment: IBoardRoutingSegment, context: IBoardRoutingPenaltyContext): number;
+    getGuideCoordinates?(context: IBoardRoutingPenaltyContext): IBoardRoutingGuideCoordinates;
+}
+export interface ICreateBoardConnectorRoutingObstaclesOptions {
+    clearance?: number;
+    excludeElementIds?: readonly string[];
+}
+export interface IBoardRoutingObstacleIndex {
+    obstacles: readonly IBoardRoutingObstacle[];
+    version: string;
+    query(bounds: IBoardRoutingRect): IBoardRoutingObstacle[];
+}
+export interface IResolveBoardOrthogonalObstacleRouteOptions {
+    start: IBoardConnectorPoint;
+    end: IBoardConnectorPoint;
+    preferredStartAxis?: 'horizontal' | 'vertical' | null;
+    preferredEndAxis?: 'horizontal' | 'vertical' | null;
+    obstacles?: readonly IBoardRoutingObstacle[];
+    obstacleIndex?: IBoardRoutingObstacleIndex;
+    maxGraphNodes?: number;
+    searchPadding?: number;
+    penaltyProviders?: readonly IBoardRoutingPenaltyProvider[];
+    stabilityHint?: {
+        routePoints: readonly IBoardConnectorPoint[];
+        penalty?: number;
+        tolerance?: number;
+    };
+    fallbackRoute?: () => IBoardConnectorPoint[];
+}
+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;
+export declare function resolveBoardOrthogonalObstacleRoute(options: IResolveBoardOrthogonalObstacleRouteOptions): IBoardConnectorPoint[];

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

@@ -0,0 +1,53 @@
+import type { IBoardConnectorData, IBoardConnectorEndpoint, IBoardConnectorPoint, IBoardElementData, IBoardElementTransform } from '@univerjs-pro/boards';
+import type { IBoardRoutingSegment } from './board-connector-router.util';
+export interface IBoardConnectorRouteBounds {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface IBoardConnectorResolvedEndpoint {
+    point: IBoardConnectorPoint;
+    normal?: IBoardConnectorPoint;
+    boundShapeId?: string;
+}
+export type BoardConnectorPathCommand = {
+    type: 'moveTo';
+    point: IBoardConnectorPoint;
+} | {
+    type: 'lineTo';
+    point: IBoardConnectorPoint;
+} | {
+    type: 'bezierCurveTo';
+    control1: IBoardConnectorPoint;
+    control2: IBoardConnectorPoint;
+    point: IBoardConnectorPoint;
+};
+export interface IResolveBoardConnectorEndpointPointOptions {
+    elementData?: Record<string, IBoardElementData>;
+    connectorId?: string;
+}
+export interface IResolveBoardConnectorEndpointOptions extends IResolveBoardConnectorEndpointPointOptions {
+}
+export interface IResolveBoardConnectorRoutePointsOptions extends IResolveBoardConnectorEndpointPointOptions {
+    stabilityHint?: {
+        routePoints: readonly IBoardConnectorPoint[];
+        penalty?: number;
+        tolerance?: number;
+    };
+    resolvedRoutePoints?: readonly IBoardConnectorPoint[];
+}
+export declare const BOARD_CONNECTOR_MIN_BOUNDS_SIZE = 1;
+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 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;
+export declare function trimBoardConnectorPathCommands(commands: readonly BoardConnectorPathCommand[], startTrim: number, endTrim: number): BoardConnectorPathCommand[];
+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 trimBoardConnectorRoute(points: readonly IBoardConnectorPoint[], startTrim: number, endTrim: number): IBoardConnectorPoint[];

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

@@ -0,0 +1,10 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IBoardSelectionContext } from '../services/board-element-state.service';
+export interface IResolveSelectedBoardConnectorDataOptions {
+    currentUnitId: string | null | undefined;
+    context: IBoardSelectionContext | null;
+    selectedIds: readonly string[];
+    focusedId: string | null;
+    getElementById: (unitId: string, subUnitId: string, elementId: string) => IBoardElementData | null | undefined;
+}
+export declare function resolveSelectedBoardConnectorData(options: IResolveSelectedBoardConnectorDataOptions): IBoardElementData | null;

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

@@ -0,0 +1,10 @@
+import type { IBoardConnectorPoint, IBoardElementData } from '@univerjs-pro/boards';
+import type { IBoardConnectorBoundarySnap } from './board-connector-snap.util';
+export interface IBoardConnectorSnapHighlight {
+    elementId: string;
+    point: IBoardConnectorPoint;
+    normal: IBoardConnectorPoint;
+    segmentStart: IBoardConnectorPoint;
+    segmentEnd: IBoardConnectorPoint;
+}
+export declare function resolveBoardConnectorSnapHighlight(snap: IBoardConnectorBoundarySnap | null | undefined, elementData: Record<string, IBoardElementData>): IBoardConnectorSnapHighlight | null;

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

@@ -0,0 +1,25 @@
+import type { IBoardConnectorEndpoint, IBoardConnectorPoint, IBoardElementData } from '@univerjs-pro/boards';
+export interface IBoardConnectorBoundarySnap {
+    endpoint: IBoardConnectorEndpoint;
+    point: IBoardConnectorPoint;
+    normal: IBoardConnectorPoint;
+    distance: number;
+    elementId: string;
+}
+export interface IResolveBoardConnectorBoundarySnapOptions {
+    point: IBoardConnectorPoint;
+    elementData: Record<string, IBoardElementData>;
+    threshold: number;
+    candidateElementIds?: readonly string[];
+    excludeElementIds?: readonly string[];
+    preferredElementId?: string | null;
+    hysteresisThreshold?: number;
+}
+export interface IIsBoardConnectorBoundarySnapCandidateOptions {
+    point: IBoardConnectorPoint;
+    elementDataItem: IBoardElementData;
+    elementData?: Record<string, IBoardElementData>;
+    threshold: number;
+}
+export declare function isBoardConnectorBoundarySnapCandidate(options: IIsBoardConnectorBoundarySnapCandidateOptions): boolean;
+export declare function resolveBoardConnectorBoundarySnap(options: IResolveBoardConnectorBoundarySnapOptions): IBoardConnectorBoundarySnap | null;