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

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

@@ -4,6 +4,7 @@ import type { IPopup } from '@univerjs/ui';
 import { Disposable } from '@univerjs/core';
 import { IRenderManagerService } from '@univerjs/engine-render';
 import { ICanvasPopupService } from '@univerjs/ui';
+import { IBoardUIStateService } from './board-ui-state.service';
 export interface IBoardCanvasPopup extends Pick<IPopup, 'componentKey' | 'direction' | 'excludeOutside' | 'hideOnInvisible' | 'offset' | 'onClickOutside'> {
     anchorBoundResolver?: (targetObject: BaseObject) => IBoundRectNoAngle;
     extraProps?: Record<string, unknown>;
@@ -12,7 +13,8 @@ export interface IBoardCanvasPopup extends Pick<IPopup, 'componentKey' | 'direct
 export declare class BoardCanvasPopManagerService extends Disposable {
     private readonly _globalPopupManagerService;
     private readonly _renderManagerService;
-    constructor(_globalPopupManagerService: ICanvasPopupService, _renderManagerService: IRenderManagerService);
+    private readonly _boardUIStateService;
+    constructor(_globalPopupManagerService: ICanvasPopupService, _renderManagerService: IRenderManagerService, _boardUIStateService: IBoardUIStateService);
     private _createObjectPositionObserver;
     attachPopupToObject(unitId: string, subUnitId: string, targetObject: BaseObject, popup: IBoardCanvasPopup): IDisposable;
     attachPopupToPoint(unitId: string, subUnitId: string, point: {

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-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-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,5 +1,5 @@
 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';
@@ -14,5 +14,6 @@ export declare class BoardViewportService {
     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-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-routing.util.d.ts

@@ -1,4 +1,4 @@
-import type { IBoardConnectorData, IBoardConnectorElement, IBoardConnectorEndpoint, IBoardConnectorPoint, IBoardElementData, IBoardElementTransform } from '@univerjs-pro/boards';
+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;
@@ -45,8 +45,10 @@ export interface IResolveBoardConnectorRoutePointsOptions extends IResolveBoardC
     };
     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;
 };
@@ -57,15 +59,22 @@ export declare function isBoardConnectorRouteAlignedWithEndpoints(connectorData:
 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;
@@ -78,8 +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-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;

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

@@ -1,8 +1,7 @@
-import type { IBoardPage, IBoardPageSize } from '@univerjs-pro/boards';
+import type { BoardBackgroundImageFit, IBoardPage, IBoardPageSize } from '@univerjs-pro/boards';
 import type { IUniverBoardsUIConfig } from '../config/config';
 export declare const BOARD_RENDER_SCENE_DEFAULT_MIN_SIZE: IBoardPageSize;
-export declare const BOARD_RENDER_SCENE_DEFAULT_FALLBACK_FILL = "#ffffff";
-export declare const BOARD_RENDER_SCENE_DARK_FALLBACK_FILL = "#fcfdff";
+export declare const BOARD_RENDER_SCENE_DEFAULT_FALLBACK_FILL = "gray.50";
 export interface IResolveBoardRenderSceneSizeOptions {
     engineWidth?: number;
     engineHeight?: number;
@@ -12,8 +11,14 @@ export interface IResolveBoardRenderSceneSizeOptions {
 }
 export interface IResolveBoardPageBackgroundFillOptions {
     darkMode?: boolean;
-    darkFallbackFill?: string;
 }
-export declare function resolveBoardPageBackgroundFill(page: Pick<IBoardPage, 'background'> | null | undefined, fallbackFill?: string, options?: IResolveBoardPageBackgroundFillOptions): string;
+export interface IBoardBackgroundImageDrawRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export declare function resolveBoardPageBackgroundFill(page: Pick<IBoardPage, 'background'> | null | undefined, options?: IResolveBoardPageBackgroundFillOptions): string;
+export declare function resolveBoardBackgroundImageDrawRect(frameWidth: number, frameHeight: number, imageWidth: number, imageHeight: number, fit?: BoardBackgroundImageFit): IBoardBackgroundImageDrawRect;
 export declare function resolveBoardRenderSceneMinSize(config?: Pick<IUniverBoardsUIConfig, 'scene'>): IBoardPageSize;
 export declare function resolveBoardRenderSceneSize({ engineWidth, engineHeight, sceneWidth, sceneHeight, minSize, }: IResolveBoardRenderSceneSizeOptions): IBoardPageSize;

package/lib/types/utils/board-shortcut-preconditions.util.d.ts

@@ -1,4 +1,6 @@
+import type { BoardModel } from '@univerjs-pro/boards';
 import type { IContextService, IUniverInstanceService } from '@univerjs/core';
-import type { IBoardElementStateService } from '../services/board-element-state.service';
+import type { BoardShortcutRuntimeService } from '../services/board-shortcut-runtime.service';
 export declare function isBoardKeyboardOwner(instanceService: IUniverInstanceService, boardUnitId: string): boolean;
-export declare function isBoardShortcutAvailable(contextService: IContextService, elementStateService: IBoardElementStateService, instanceService: IUniverInstanceService): boolean;
+export declare function isBoardShortcutAvailable(contextService: Pick<IContextService, 'getContextValue'>): boolean;
+export declare function resolveBoardShortcutModel(runtime: BoardShortcutRuntimeService): BoardModel | null;

package/lib/types/utils/board-viewport-bar.util.d.ts

@@ -0,0 +1,55 @@
+import type { IBoardViewportBarPadding } from '../config/config';
+export interface IBoardViewportBarRect {
+    height: number;
+    left: number;
+    top: number;
+    width: number;
+}
+export interface IBoardViewportBarNavigationBounds {
+    bottom: number;
+    left: number;
+    right: number;
+    top: number;
+}
+export interface IResolvedBoardViewportBarPadding {
+    bottom: number;
+    left: number;
+    right: number;
+    top: number;
+}
+export interface IBoardViewportBarSafeArea {
+    horizontalEnd?: number;
+    horizontalStart?: number;
+    verticalEnd?: number;
+    verticalStart?: number;
+}
+export interface IBoardViewportBarAxisLayout {
+    barRect: IBoardViewportBarRect;
+    maxViewportStart: number;
+    minViewportStart: number;
+    travelLength: number;
+    viewportStart: number;
+}
+export interface IBoardViewportBarLayout {
+    horizontal: IBoardViewportBarAxisLayout | null;
+    vertical: IBoardViewportBarAxisLayout | null;
+}
+export interface IResolveBoardViewportBarLayoutOptions {
+    barSize: number;
+    edgeOffset: number;
+    horizontal: boolean;
+    minBarLength: number;
+    navigationBounds: IBoardViewportBarNavigationBounds;
+    safeArea?: IBoardViewportBarSafeArea;
+    vertical: boolean;
+    viewport: IBoardViewportBarRect;
+    viewportPixelSize: {
+        height: number;
+        width: number;
+    };
+}
+export declare function resolveBoardViewportBarPadding(padding: number | IBoardViewportBarPadding | undefined): IResolvedBoardViewportBarPadding;
+export declare function resolveBoardViewportBarNavigationBounds(contentBounds: IBoardViewportBarRect | null | undefined, viewport: IBoardViewportBarRect, padding: IResolvedBoardViewportBarPadding): IBoardViewportBarNavigationBounds;
+export declare function expandBoardViewportBarNavigationBounds(current: IBoardViewportBarNavigationBounds, target: IBoardViewportBarNavigationBounds): IBoardViewportBarNavigationBounds;
+export declare function resolveBoardViewportBarLayout(options: IResolveBoardViewportBarLayoutOptions): IBoardViewportBarLayout;
+export declare function resolveBoardViewportStartFromBarDrag(layout: IBoardViewportBarAxisLayout, pointerDelta: number): number;

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

@@ -49,6 +49,7 @@ export declare function getBoardPointFromClient(element: HTMLElement, clientX: n
     x: number;
     y: number;
 };
+export declare function getBoardViewportPoint(boardPoint: IBoardViewportPoint, viewport: IBoardViewportTransform): IBoardViewportPoint;
 /**
  * Maps the board world coordinate system onto the DOM overlay in one
  * compositor-friendly transform. Children of this layer keep their unscaled

package/lib/types/views/BoardConnectorFloatingToolbarControls.d.ts

@@ -21,10 +21,16 @@ export declare function MarkerDropdown(props: {
 export declare function SettingsDropdown(props: {
     routing?: BoardConnectorRouting;
     style: IBoardConnectorStyle;
-    onRouting: (routing: BoardConnectorRouting) => void;
-    onStyle: (style: Partial<IBoardConnectorStyle>) => void;
+    onRouting: (routing: BoardConnectorRouting) => void | Promise<void>;
+    onStyle: (style: Partial<IBoardConnectorStyle>) => void | Promise<void>;
 }): import("react").JSX.Element;
+export declare function applyConnectorRoutingStyleOption(option: {
+    routing: BoardConnectorRouting;
+    cornerStyle?: IBoardConnectorStyle['cornerStyle'];
+}, onRouting: (routing: BoardConnectorRouting) => void | Promise<void>, onStyle: (style: Partial<IBoardConnectorStyle>) => void | Promise<void>): Promise<void>;
 export declare function createConnectorLabelRichTextBuilder(label: IBoardConnectorLabel): RichTextBuilder;
+export declare function isConnectorLabelSettingsNestedPopupTarget(target: EventTarget | null): boolean;
+export declare function shouldCloseConnectorLabelStylePanel(panel: Element, target: EventTarget | null): boolean;
 export declare function ConnectorLabelSettingsDropdown(props: {
     label: IBoardConnectorLabel;
     onEditText: () => void;

package/lib/types/views/BoardFloatingToolPanel.d.ts

@@ -41,6 +41,7 @@ interface IBoardMindMapTemplateGroup {
 }
 export declare const BOARD_MIND_MAP_TEMPLATE_GROUPS: IBoardMindMapTemplateGroup[];
 export declare function resolveMindMapPresetInsertTemplate(preset: IBoardMindMapInsertPreset, nodeText: string): {
+    rootText: string;
     structureKind: BoardMindMapPresetStructureKind;
     children: {
         text: string;

package/lib/types/views/BoardPageBackgroundView.d.ts

@@ -0,0 +1,8 @@
+import type { BoardModel, IBoardImageBackground } from '@univerjs-pro/boards';
+import type { CSSProperties } from 'react';
+export interface IBoardPageBackgroundViewProps {
+    boardModel?: BoardModel;
+    pageId?: string;
+}
+export declare function createBoardPageBackgroundImageStyle(background: IBoardImageBackground): CSSProperties;
+export declare const BoardPageBackgroundView: import("react").MemoExoticComponent<({ boardModel, pageId, }: IBoardPageBackgroundViewProps) => import("react").JSX.Element>;

package/lib/types/views/BoardSettingsMenu.d.ts

@@ -1,3 +1,17 @@
+import type { ComponentProps, ReactNode } from 'react';
+import { Button } from '@univerjs/design';
 export declare const BOARD_TOP_RIGHT_MENU_LEADING_PART = "board.top-right-menu.leading";
 export declare const BOARD_SETTINGS_MENU_ACTIONS_PART = "boards-ui.settings-menu.actions";
+type TopRightMenuButtonProps = ComponentProps<typeof Button> & {
+    children: ReactNode;
+    label: string;
+    tooltipVisible?: boolean;
+};
+interface IBoardFindResultTextProps {
+    query: string;
+    text: string;
+}
+export declare function BoardFindResultText(props: IBoardFindResultTextProps): string | (string | import("react").JSX.Element)[];
+export declare const TopRightMenuButton: import("react").ForwardRefExoticComponent<Omit<TopRightMenuButtonProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
 export declare function BoardSettingsMenu(): import("react").JSX.Element;
+export {};