@univerjs-pro/boards-ui 1.0.0-alpha.7 → 1.0.0-beta.0

package/lib/types/render-adapters/board-element-render-adapter.d.ts

@@ -3,7 +3,10 @@ import type { IShapeFormulaPresentation } from '@univerjs-pro/shape-editor';
 import type { IImageIoService, LocaleService } from '@univerjs/core';
 import type { BaseObject } from '@univerjs/engine-render';
 import type { IBoardFocusedSwimlaneLane } from '../services/board-element-state.service';
+import { BoardConnectorObject } from '../render-objects/board-connector-object';
 export declare const BOARD_ELEMENT_OBJECT_PREFIX = "board-element";
+type BoardConnectorLineJumpCacheOption = ConstructorParameters<typeof BoardConnectorObject>[1]['lineJumpCache'];
+type BoardConnectorRoutingCacheOption = ConstructorParameters<typeof BoardConnectorObject>[1]['routingCache'];
 export interface IBoardElementRenderObjectKey {
     unitId: string;
     elementId: string;
@@ -24,6 +27,8 @@ export interface ICreateBoardElementRenderObjectOptions {
     zIndex?: number;
     imageIoService?: IImageIoService;
     localeService?: LocaleService;
+    lineJumpCache?: BoardConnectorLineJumpCacheOption;
+    routingCache?: BoardConnectorRoutingCacheOption;
     adapters?: readonly IBoardElementRenderAdapter[];
     focusedSwimlaneLane?: IBoardFocusedSwimlaneLane | null;
     formulaPresentation?: IShapeFormulaPresentation;
@@ -38,6 +43,8 @@ export interface ISyncBoardElementRenderObjectOptions {
     focusedSwimlaneLane?: IBoardFocusedSwimlaneLane | null;
     formulaPresentation?: IShapeFormulaPresentation;
     animateFormulaPresentation?: boolean;
+    lineJumpCache?: BoardConnectorLineJumpCacheOption;
+    routingCache?: BoardConnectorRoutingCacheOption;
 }
 export interface IBoardElementRenderAdapterContext {
     unitId: string;
@@ -48,6 +55,8 @@ export interface IBoardElementRenderAdapterContext {
     zIndex?: number;
     imageIoService?: IImageIoService;
     localeService?: LocaleService;
+    lineJumpCache?: BoardConnectorLineJumpCacheOption;
+    routingCache?: BoardConnectorRoutingCacheOption;
     focusedSwimlaneLane?: IBoardFocusedSwimlaneLane | null;
     formulaPresentation?: IShapeFormulaPresentation;
     animateFormulaPresentation?: boolean;
@@ -68,5 +77,6 @@ export declare const BOARD_CONNECTOR_ELEMENT_RENDER_ADAPTER: IBoardElementRender
 export declare const BOARD_SHAPE_ELEMENT_RENDER_ADAPTER: IBoardElementRenderAdapter;
 export declare const BOARD_IMAGE_ELEMENT_RENDER_ADAPTER: IBoardElementRenderAdapter;
 export declare const BOARD_ELEMENT_RENDER_ADAPTERS: readonly IBoardElementRenderAdapter[];
-export declare function createBoardElementRenderObject({ unitId, elementDataItem, elementData, zIndex, imageIoService, localeService, adapters, focusedSwimlaneLane, formulaPresentation, }: ICreateBoardElementRenderObjectOptions): BaseObject | null;
+export declare function createBoardElementRenderObject({ unitId, elementDataItem, elementData, zIndex, imageIoService, localeService, lineJumpCache, routingCache, adapters, focusedSwimlaneLane, formulaPresentation, }: ICreateBoardElementRenderObjectOptions): BaseObject | null;
 export declare function syncBoardElementRenderObject(object: BaseObject, elementDataItem: IBoardElementData, options?: ISyncBoardElementRenderObjectOptions): boolean;
+export {};

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

@@ -1,7 +1,8 @@
 import type { IBoardConnectorElement, IBoardConnectorPoint, IBoardElementData } from '@univerjs-pro/boards';
-import type { LocaleService } from '@univerjs/core';
+import type { IDocumentData, LocaleService } from '@univerjs/core';
 import type { IObjectFullState, IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
 import type { IBoardConnectorLabelRect } from '../utils/board-connector-label.util';
+import type { BoardConnectorRoutingCache } from '../utils/board-connector-routing.util';
 import { BaseObject } from '@univerjs/engine-render';
 import { resolveBoardConnectorPathBounds, resolveBoardConnectorPathCommands, resolveBoardConnectorRoutePoints } from '../utils/board-connector-routing.util';
 export interface IBoardConnectorObjectProps {
@@ -15,6 +16,8 @@ export interface IBoardConnectorObjectProps {
     evented?: boolean;
     element: IBoardConnectorElement;
     elementData?: Record<string, IBoardElementData>;
+    lineJumpCache?: BoardConnectorLineJumpCache;
+    routingCache?: BoardConnectorRoutingCache;
     localeService?: LocaleService;
 }
 export interface IBoardConnectorRouteCache {
@@ -22,10 +25,30 @@ export interface IBoardConnectorRouteCache {
     pathCommands: ReturnType<typeof resolveBoardConnectorPathCommands>;
     bounds: ReturnType<typeof resolveBoardConnectorPathBounds>;
 }
+interface IBoardConnectorLineJump {
+    x: number;
+    y: number;
+    distance: number;
+}
+type BoardConnectorRouteResolver = typeof resolveBoardConnectorRoutePoints;
+export declare class BoardConnectorLineJumpCache {
+    private readonly _resolveRoutePoints;
+    private _elementData?;
+    private readonly _routePointsByConnectorId;
+    private readonly _lineJumpsByConnectorId;
+    constructor(_resolveRoutePoints?: BoardConnectorRouteResolver);
+    invalidate(elementData?: Record<string, IBoardElementData>): void;
+    resolveLineJumpsForRoute(connectorId: string, routePoints: readonly IBoardConnectorPoint[]): readonly IBoardConnectorLineJump[][];
+    private _clear;
+    private _getRoutePoints;
+    private _resolveLineJumpsForSegment;
+}
 export declare class BoardConnectorObject extends BaseObject {
     private _element;
     private _elementData?;
     private readonly _localeService?;
+    private readonly _lineJumpCache;
+    private readonly _routingCache?;
     private readonly _documentTextRenderCache;
     private _routeCache;
     private _routeStabilityHint;
@@ -36,9 +59,12 @@ export declare class BoardConnectorObject extends BaseObject {
     getElement(): IBoardConnectorElement;
     setEditing(isEditing: boolean): void;
     getRoutePoints(): IBoardConnectorPoint[];
+    getCachedRoutePoints(): readonly IBoardConnectorPoint[] | null;
     getPathCommands(): import("../utils/board-connector-routing.util").BoardConnectorPathCommand[];
+    getRenderBounds(): ReturnType<typeof resolveBoardConnectorPathBounds>;
     getLabelPathPoints(): IBoardConnectorPoint[];
     getLabelRect(): IBoardConnectorLabelRect | null;
+    measureLabelNaturalHeight(width: number, documentData?: IDocumentData): number | null;
     isLabelHit(point: IBoardConnectorPoint): boolean;
     private _getRouteCache;
     private _getRenderBounds;
@@ -46,13 +72,16 @@ export declare class BoardConnectorObject extends BaseObject {
     private _shouldUseRouteStabilityHint;
     transformByState(option: IObjectFullState): this;
     isHit(coord: Vector2): boolean;
+    hitTest(point: IBoardConnectorPoint): boolean;
     render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+    private _clipRouteAroundLabel;
     private _drawRoute;
     private _drawRoundedOrthogonalRoute;
     private _drawRouteWithLineJumps;
-    private _resolveLineJumpsForSegment;
     private _drawPathCommands;
     private _drawMarkers;
     private _resolveEndpointVisualGap;
     private _drawLabel;
+    private _drawLabelFrame;
 }
+export {};

package/lib/types/render-objects/board-element-render-layer.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { Scene, UniverRenderingContext } from '@univerjs/engine-render';
+import { BaseObject, Layer } from '@univerjs/engine-render';
+export interface IBoardElementRenderLayerMetrics {
+    cacheHits: number;
+    directRenders: number;
+    fullCacheRenders: number;
+    incrementalCacheRenders: number;
+    zoomPreviews: number;
+}
+/**
+ * Board-specific cache for the persistent element layer. Render objects stay as direct layer
+ * children, so object ordering and hit testing continue to use the engine's normal paths.
+ */
+export declare class BoardElementRenderLayer extends Layer {
+    private readonly _elementCacheCanvas;
+    private readonly _cacheProxy;
+    private readonly _metrics;
+    private _cacheState;
+    private _cacheContentValid;
+    private _rebuildRequested;
+    private _quietRevision;
+    private _quietFrame;
+    private _settleFrame;
+    constructor(scene: Scene, zIndex: number);
+    getMetrics(): Readonly<IBoardElementRenderLayerMetrics>;
+    addObject(object: BaseObject): this;
+    removeObject(object: BaseObject | string): void;
+    removeObjects(objects: BaseObject[] | string[]): void;
+    render(parentCtx?: UniverRenderingContext, isMaxLayer?: boolean): this;
+    private _paint;
+    private _canCache;
+    private _createCacheState;
+    private _refreshCache;
+    private _recenterCache;
+    private _getNewAreaBounds;
+    private _renderObjectsToCache;
+    private _renderDirect;
+    private _drawElementCache;
+    private _filterObjects;
+    private _shouldRecenter;
+    private _isSameScale;
+    private _markObjectsClean;
+    private _clearCanvas;
+    private _invalidateContent;
+    private _scheduleQuietRebuild;
+    private _cancelQuietFrames;
+    private _cancelQuietRebuild;
+    private _resetCache;
+    dispose(): void;
+}

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

@@ -2,6 +2,7 @@ import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/e
 import type { IBoardSelectionRect } from '../utils/board-selection-geometry.util';
 import { BaseObject } from '@univerjs/engine-render';
 export interface IBoardSelectionMarqueeObjectState {
+    preciseSelection?: boolean;
     rect: IBoardSelectionRect | null;
     zoomRatio?: number;
 }

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

@@ -1,5 +1,6 @@
 import type { BoardConnectorRouting, BoardModel, IBoardConnectorLabel, IBoardConnectorStyle, IBoardSwimlaneData, ICommitBoardContainerTransformOperationParams, IRemoveBoardElementsOperationParams, IRemoveBoardSwimlaneLaneOperationParams, IUpdateBoardElementCommandParams, IUpdateBoardElementsCommandItem, IUpdateBoardElementsCommandParams } from '@univerjs-pro/boards';
-import type { IBoardElementSelectionMoveDelta } from '../utils/board-selection-move.util';
+import type { BoardContainerMembershipUpdateMode } from '../utils/board-container-membership-update.util';
+import type { IBoardSelectionMoveDelta } 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';
@@ -12,8 +13,9 @@ export interface IBoardElementEditSelectionSnapshot {
 }
 export interface IBoardElementMoveSelectedOptions {
     selectedIds: string[];
-    delta: IBoardElementSelectionMoveDelta;
+    delta: IBoardSelectionMoveDelta;
     focusedId?: string | null;
+    membershipMode?: BoardContainerMembershipUpdateMode;
 }
 export interface IBoardElementResizeSelectionOptions {
     selectedIds: string[];
@@ -79,6 +81,7 @@ export interface IBoardElementUpdateElementsOptions {
     subUnitId: string;
     updates: IBoardElementUpdateElementsOperationItem[];
     forceCaptureElementIds?: readonly string[];
+    membershipMode?: BoardContainerMembershipUpdateMode;
 }
 export declare class BoardElementEditService {
     private readonly _commandService;

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-overlay.service.d.ts

@@ -3,6 +3,8 @@ import { Disposable } from '@univerjs/core';
 export interface IBoardSelectionDraft {
     start: IBoardSelectionPoint;
     current: IBoardSelectionPoint;
+    dragSelection: boolean;
+    preciseSelection: boolean;
 }
 export declare class BoardSelectionOverlayService extends Disposable {
     private readonly _selectionDraft$;

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

@@ -1,18 +1,23 @@
 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;
     start: IBoardSelectionPoint;
     end: IBoardSelectionPoint;
+    dragSelection: boolean;
     preciseSelection: boolean;
     invertSelection?: boolean;
 }
 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-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-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 { 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,8 @@ 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;
+    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-marker-anchor.util.d.ts

@@ -1,4 +1,4 @@
-import type { IBoardConnectorData, IBoardConnectorPoint, IBoardElementData } from '@univerjs-pro/boards';
+import type { BoardConnectorRouting, IBoardConnectorData, IBoardConnectorPoint, IBoardElementData } from '@univerjs-pro/boards';
 import type { BoardConnectorPathCommand } from './board-connector-routing.util';
 export interface IBoardConnectorMarkerAnchor {
     point: IBoardConnectorPoint;
@@ -14,4 +14,4 @@ export interface IResolveBoardConnectorMarkerAnchorsOptions {
     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;
+export declare function resolveBoardConnectorMarkerAnchors(_routing: BoardConnectorRouting, points: readonly IBoardConnectorPoint[], pathCommands: readonly BoardConnectorPathCommand[], options?: IResolveBoardConnectorMarkerAnchorsOptions): IBoardConnectorMarkerAnchors | null;

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

@@ -1,6 +1,7 @@
 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 declare const BOARD_QUICK_CONNECT_SIBLING_GAP = 40;
 export interface ICreateBoardConnectorQuickConnectElementsOptions {
     sourceEndpoint: IBoardConnectorEndpoint;
     sourcePoint: IBoardConnectorPoint;

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, IBoardConnectorPoint, IBoardElementData, IBoardElementTransform } from '@univerjs-pro/boards';
+import type { IBoardRoutingObstacleIndex, IBoardRoutingSegment } from './board-connector-router.util';
 export interface IBoardConnectorRouteBounds {
     left: number;
     top: number;
@@ -23,6 +23,14 @@ export type BoardConnectorPathCommand = {
     control2: IBoardConnectorPoint;
     point: IBoardConnectorPoint;
 };
+export interface IBoardConnectorPathEndpointGeometry {
+    point: IBoardConnectorPoint;
+    tangent: IBoardConnectorPoint | null;
+}
+export interface IBoardConnectorPathGeometry {
+    start: IBoardConnectorPathEndpointGeometry;
+    end: IBoardConnectorPathEndpointGeometry;
+}
 export interface IResolveBoardConnectorEndpointPointOptions {
     elementData?: Record<string, IBoardElementData>;
     connectorId?: string;
@@ -36,18 +44,42 @@ export interface IResolveBoardConnectorRoutePointsOptions extends IResolveBoardC
         tolerance?: number;
     };
     resolvedRoutePoints?: readonly IBoardConnectorPoint[];
+    routingCache?: BoardConnectorRoutingCache;
 }
 export declare const BOARD_CONNECTOR_MIN_BOUNDS_SIZE = 1;
+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 _obstacleIndexesByExclusion;
+    private readonly _routePointsByConnectorId;
+    private readonly _crossingRoutePointsByConnectorId;
+    invalidate(elementData?: Record<string, IBoardElementData>, invalidatedElementIds?: Iterable<string>): string[];
+    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 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;
+/**
+ * Resolves marker-facing endpoint tangents from the final rendered path.
+ *
+ * The start tangent points backward from the route into the start marker; the end tangent points forward from the
+ * route into the end marker. Repeated points and coincident Bézier handles are skipped so callers never need a
+ * routing-specific marker rule or an arbitrary axis fallback.
+ */
+export declare function resolveBoardConnectorPathGeometry(commands: readonly BoardConnectorPathCommand[]): IBoardConnectorPathGeometry | null;
 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[];
+export {};

package/lib/types/utils/board-container-membership-update.util.d.ts

@@ -6,5 +6,10 @@ export interface IResolveBoardContainerMembershipUpdateItemsOptions {
     updates: readonly IUpdateBoardElementsCommandItem[];
     forceCaptureElementIds?: readonly string[];
     spatialIndex?: IBoardElementSpatialIndex;
+    mode?: BoardContainerMembershipUpdateMode;
+}
+export declare enum BoardContainerMembershipUpdateMode {
+    Spatial = "spatial",
+    Preserve = "preserve"
 }
 export declare function resolveBoardContainerMembershipUpdateItems(options: IResolveBoardContainerMembershipUpdateItemsOptions): IUpdateBoardElementsCommandItem[];

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-selection-geometry.util.d.ts

@@ -6,17 +6,20 @@ export interface IBoardSelectionRect {
     width: number;
     height: number;
 }
+export type BoardElementBoundsResolver = (elementDataItem: IBoardElementData) => IBoardSelectionRect | null | undefined;
 export interface ISelectBoardElementsByRectOptions {
     elementData: Record<string, IBoardElementData>;
     elementOrder: string[];
     rect: IBoardSelectionRect;
     preciseSelection: boolean;
+    resolveElementBounds?: BoardElementBoundsResolver;
     spatialIndex?: IBoardElementSpatialIndex;
 }
 export interface IResolveBoardElementsBoundsOptions {
     elementData: Record<string, IBoardElementData>;
     elementOrder: string[];
     includeHidden?: boolean;
+    resolveElementBounds?: BoardElementBoundsResolver;
 }
 export interface IBoardElementSelectionResult {
     unitId: string;
@@ -25,7 +28,7 @@ export interface IBoardElementSelectionResult {
     element: IBoardElementData['element'];
     transform: IBoardElementData['transform'];
 }
-export declare function resolveBoardElementBounds(elementDataItem: IBoardElementData, elementData: Record<string, IBoardElementData>): IBoardSelectionRect;
+export declare function resolveBoardElementBounds(elementDataItem: IBoardElementData, elementData: Record<string, IBoardElementData>, resolveElementBounds?: BoardElementBoundsResolver): IBoardSelectionRect;
 export declare function isBoardElementVisibleInTree(elementData: Record<string, IBoardElementData>, elementDataItem: IBoardElementData | undefined): elementDataItem is IBoardElementData;
 export declare function selectBoardElementsByRect(options: ISelectBoardElementsByRectOptions): IBoardElementSelectionResult[];
 export declare function resolveBoardElementsBounds(options: IResolveBoardElementsBoundsOptions): IBoardSelectionRect | null;

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

@@ -5,8 +5,10 @@ export interface IHitTestBoardElementAtPointOptions {
     elementData: Record<string, IBoardElementData>;
     elementOrder: string[];
     point: IBoardSelectionPoint;
+    hitTestElement?: BoardElementHitTester;
     spatialIndex?: IBoardElementSpatialIndex;
 }
+export type BoardElementHitTester = (elementDataItem: IBoardElementData, point: IBoardSelectionPoint) => boolean | undefined;
 export interface IBoardElementHitTestResult {
     unitId: string;
     subUnitId: string;

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

@@ -1,6 +1,6 @@
 import type { IBoardElementData } from '@univerjs-pro/boards';
 import type { IBoardElementSpatialIndex } from './board-container-spatial-index.util';
-import type { IBoardSelectionRect } from './board-selection-geometry.util';
+import type { BoardElementBoundsResolver, IBoardSelectionRect } from './board-selection-geometry.util';
 export declare const BOARD_SELECTION_DRAG_THRESHOLD = 4;
 export interface IBoardSelectionPoint {
     x: number;
@@ -11,7 +11,9 @@ export interface IResolveBoardElementDragSelectionOptions {
     elementOrder: string[];
     start: IBoardSelectionPoint;
     end: IBoardSelectionPoint;
+    dragSelection: boolean;
     preciseSelection: boolean;
+    resolveElementBounds?: BoardElementBoundsResolver;
     spatialIndex?: IBoardElementSpatialIndex;
 }
 export interface IResolvedBoardDragSelection {

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

@@ -8,10 +8,9 @@ export interface IBoardElementSelectionMoveResult {
     element: IBoardElementData['element'];
     transform: IBoardElementData['transform'];
 }
-export type IBoardElementSelectionMoveDelta = IBoardSelectionMoveDelta;
 export interface IResolveBoardElementSelectionMoveOptions {
     selectedIds: string[];
     elementData: Record<string, IBoardElementData>;
-    delta: IBoardElementSelectionMoveDelta;
+    delta: IBoardSelectionMoveDelta;
 }
 export declare function resolveBoardElementSelectionMove(options: IResolveBoardElementSelectionMoveOptions): IBoardElementSelectionMoveResult[];