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

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

@@ -2,7 +2,8 @@ import type { IBoardConnectorElement, IBoardConnectorPoint, IBoardElementData }
 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 type { IBoardConnectorRenderGeometry } from '../utils/board-connector-render-geometry.util';
+import type { BoardConnectorPathCommand, 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 {
@@ -24,6 +25,12 @@ export interface IBoardConnectorRouteCache {
     routePoints: ReturnType<typeof resolveBoardConnectorRoutePoints>;
     pathCommands: ReturnType<typeof resolveBoardConnectorPathCommands>;
     bounds: ReturnType<typeof resolveBoardConnectorPathBounds>;
+    renderGeometry: IBoardConnectorRenderGeometry | null;
+}
+export interface IBoardConnectorObjectUpdateOptions {
+    preserveLineJumpCache?: boolean;
+    routeCache?: IBoardConnectorRouteCache;
+    skipLineJumps?: boolean;
 }
 interface IBoardConnectorLineJump {
     x: number;
@@ -37,7 +44,9 @@ export declare class BoardConnectorLineJumpCache {
     private readonly _routePointsByConnectorId;
     private readonly _lineJumpsByConnectorId;
     constructor(_resolveRoutePoints?: BoardConnectorRouteResolver);
-    invalidate(elementData?: Record<string, IBoardElementData>): void;
+    invalidate(elementData?: Record<string, IBoardElementData>, options?: {
+        force?: boolean;
+    }): void;
     resolveLineJumpsForRoute(connectorId: string, routePoints: readonly IBoardConnectorPoint[]): readonly IBoardConnectorLineJump[][];
     private _clear;
     private _getRoutePoints;
@@ -51,28 +60,32 @@ export declare class BoardConnectorObject extends BaseObject {
     private readonly _routingCache?;
     private readonly _documentTextRenderCache;
     private _routeCache;
+    private _labelGeometryCache;
     private _routeStabilityHint;
     private _isEditingLabel;
+    private _skipLineJumps;
     isDrawingObject: boolean;
     constructor(key: string, props: IBoardConnectorObjectProps);
-    updateElement(element: IBoardConnectorElement, elementData?: Record<string, IBoardElementData>): void;
+    updateElement(element: IBoardConnectorElement, elementData?: Record<string, IBoardElementData>, options?: IBoardConnectorObjectUpdateOptions): void;
     getElement(): IBoardConnectorElement;
     setEditing(isEditing: boolean): void;
     getRoutePoints(): IBoardConnectorPoint[];
     getCachedRoutePoints(): readonly IBoardConnectorPoint[] | null;
-    getPathCommands(): import("../utils/board-connector-routing.util").BoardConnectorPathCommand[];
+    getPathCommands(): BoardConnectorPathCommand[];
     getRenderBounds(): ReturnType<typeof resolveBoardConnectorPathBounds>;
     getLabelPathPoints(): IBoardConnectorPoint[];
     getLabelRect(): IBoardConnectorLabelRect | null;
     measureLabelNaturalHeight(width: number, documentData?: IDocumentData): number | null;
     isLabelHit(point: IBoardConnectorPoint): boolean;
     private _getRouteCache;
+    private _getLabelGeometry;
     private _getRenderBounds;
     private _getCurrentRouteStabilityHint;
     private _shouldUseRouteStabilityHint;
     transformByState(option: IObjectFullState): this;
     isHit(coord: Vector2): boolean;
     hitTest(point: IBoardConnectorPoint): boolean;
+    getRenderGeometry(): IBoardConnectorRenderGeometry | null;
     render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
     private _clipRouteAroundLabel;
     private _drawRoute;
@@ -80,7 +93,6 @@ export declare class BoardConnectorObject extends BaseObject {
     private _drawRouteWithLineJumps;
     private _drawPathCommands;
     private _drawMarkers;
-    private _resolveEndpointVisualGap;
     private _drawLabel;
     private _drawLabelFrame;
 }

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

@@ -60,6 +60,7 @@ export declare class BoardShapeObject extends Shape<IBoardShapeObjectProps> {
     transformByState(option: IObjectFullState): this;
     setEditing(isEditing: boolean): void;
     setFillImage(image?: HTMLImageElement): void;
+    isImageFillLoaded(): boolean;
     private _refreshFillImage;
     getTextRect(width: number, height: number): IShapeRect;
     _draw(ctx: UniverRenderingContext, _bounds?: IViewportInfo, renderWidth?: number, renderHeight?: number): void;

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

@@ -0,0 +1,33 @@
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import type { IBoardViewportBarRect } from '../utils/board-viewport-bar.util';
+import { BaseObject } from '@univerjs/engine-render';
+export type BoardViewportBarAxis = 'horizontal' | 'vertical';
+export interface IBoardViewportBarObjectState {
+    activeAxis: BoardViewportBarAxis | null;
+    activeColor: string;
+    activeOpacity: number;
+    barSize: number;
+    hitSize: number;
+    horizontalRect: IBoardViewportBarRect | null;
+    hoverAxis: BoardViewportBarAxis | null;
+    hoverColor: string;
+    hoverOpacity: number;
+    idleColor: string;
+    idleOpacity: number;
+    verticalRect: IBoardViewportBarRect | null;
+    zoomRatio: number;
+}
+export declare const BOARD_VIEWPORT_BAR_OBJECT_KEY = "board-viewport-bar-object";
+export declare const BOARD_VIEWPORT_BAR_OBJECT_LAYER_INDEX: 8;
+type BoardViewportBarPoint = Pick<Vector2, 'x' | 'y'>;
+export declare class BoardViewportBarObject extends BaseObject {
+    private _state;
+    constructor(key: string | undefined, state: IBoardViewportBarObjectState);
+    getBarState(): IBoardViewportBarObjectState;
+    updateState(state: Partial<IBoardViewportBarObjectState>): void;
+    resolveHitAxis(coord: BoardViewportBarPoint): BoardViewportBarAxis | null;
+    isHit(coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+    private _syncVisibility;
+}
+export {};

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

@@ -2,6 +2,7 @@ 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 { IUniverInstanceService } from '@univerjs/core';
 import { IRenderManagerService } from '@univerjs/engine-render';
 import { IBoardElementStateService } from './board-element-state.service';
 import { IBoardUIStateService } from './board-ui-state.service';
@@ -27,7 +28,8 @@ export declare class BoardScreenshotService {
     private readonly _renderManagerService;
     private readonly _shapeHostAdapterRegistry;
     private readonly _shapeFormulaService;
-    constructor(_boardElementService: IBoardElementService, _boardElementStateService: IBoardElementStateService, _boardUIStateService: IBoardUIStateService, _renderManagerService: IRenderManagerService, _shapeHostAdapterRegistry: IShapeHostAdapterRegistry, _shapeFormulaService: ShapeFormulaService);
+    private readonly _univerInstanceService;
+    constructor(_boardElementService: IBoardElementService, _boardElementStateService: IBoardElementStateService, _boardUIStateService: IBoardUIStateService, _renderManagerService: IRenderManagerService, _shapeHostAdapterRegistry: IShapeHostAdapterRegistry, _shapeFormulaService: ShapeFormulaService, _univerInstanceService: IUniverInstanceService);
     capture(unitId: string, subUnitId: string, options: IBoardScreenshotOptions): Promise<IBoardScreenshotResult | false>;
     private _prepareCaptureState;
     private _restoreCaptureState;

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

@@ -0,0 +1,37 @@
+import type { ICommandService, IDisposable } from '@univerjs/core';
+import type { ComponentType } from 'react';
+import type { Observable } from 'rxjs';
+import { Disposable } from '@univerjs/core';
+export type BoardSettingsMenuContributionGroup = 'import' | 'output';
+export declare enum BoardSettingsMenuContributionSubmenu {
+    SaveAs = "save-as"
+}
+export interface IBoardSettingsMenuContribution {
+    id: string;
+    icon: ComponentType<{
+        className?: string;
+    }>;
+    label: () => string;
+    order: number;
+    group: BoardSettingsMenuContributionGroup;
+    submenu?: BoardSettingsMenuContributionSubmenu;
+    menuItemId?: string;
+    enabled?: boolean | (() => boolean);
+    onClick: (commandService: ICommandService) => void | Promise<void>;
+}
+export interface IBoardSettingsMenuContributionService {
+    readonly contributions$: Observable<readonly IBoardSettingsMenuContribution[]>;
+    register(contribution: IBoardSettingsMenuContribution): IDisposable;
+    getAll(): readonly IBoardSettingsMenuContribution[];
+}
+export declare const IBoardSettingsMenuContributionService: import("@wendellhu/redi").IdentifierDecorator<IBoardSettingsMenuContributionService>;
+export declare class BoardSettingsMenuContributionService extends Disposable implements IBoardSettingsMenuContributionService {
+    private readonly _registrations;
+    private readonly _contributions$;
+    private _registrationIndex;
+    readonly contributions$: Observable<readonly IBoardSettingsMenuContribution[]>;
+    register(contribution: IBoardSettingsMenuContribution): IDisposable;
+    getAll(): readonly IBoardSettingsMenuContribution[];
+    dispose(): void;
+    private _publish;
+}

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

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

package/lib/types/services/board-shortcut-runtime.service.d.ts

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

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

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

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

@@ -3,6 +3,7 @@ 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';
+import { BoardViewportService } from './board-viewport.service';
 export interface IBoardTableInsertOptions {
     rows?: number;
     columns?: number;
@@ -29,7 +30,8 @@ export declare class BoardToolService {
     private readonly _commandService;
     private readonly _instanceService;
     private readonly _configService;
-    constructor(_stateService: IBoardUIStateService, _commandService: ICommandService, _instanceService: IUniverInstanceService, _configService: IConfigService);
+    private readonly _viewportService;
+    constructor(_stateService: IBoardUIStateService, _commandService: ICommandService, _instanceService: IUniverInstanceService, _configService: IConfigService, _viewportService: BoardViewportService);
     private _getInsertConfig;
     private _isToolbarAvailable;
     private _collapseInsertTools;

package/lib/types/services/board-toolbar-contribution.service.d.ts

@@ -1,4 +1,4 @@
-import type { IDisposable } from '@univerjs/core';
+import type { ICommandService, IDisposable } from '@univerjs/core';
 import type { ComponentType } from 'react';
 import type { Observable } from 'rxjs';
 import { Disposable } from '@univerjs/core';
@@ -11,9 +11,10 @@ export interface IBoardToolbarContribution {
     label: () => string;
     order: number;
     group: BoardToolbarContributionGroup;
+    menuItemId?: string;
     enabled?: boolean | (() => boolean);
     active?: () => boolean;
-    onClick: () => void;
+    onClick: (commandService: ICommandService) => void | Promise<void>;
 }
 export interface IBoardToolbarContributionService {
     readonly contributions$: Observable<readonly IBoardToolbarContribution[]>;

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;