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

package/lib/types/controllers/board-text-editing.render-controller.d.ts

@@ -20,9 +20,11 @@ export declare class BoardTextEditingRenderController extends RxDisposable imple
     private readonly _contextService;
     private readonly _inkStateService;
     private _attachScheduled;
+    private _attachAllObjectDoubleClicks;
     private _lastEditingShapeKey;
     private _ignoreFocusChangesUntil;
-    private _objectDblclickDisposables;
+    private _objectDblclickDisposablesByElementId;
+    private _pendingObjectDoubleClickElementIds;
     constructor(_renderContext: IRenderContext<UnitModel>, _instanceService: IUniverInstanceService, _boardElementService: IBoardElementService, _boardTextEditingService: BoardTextEditingService, _boardContainerRenameService: BoardContainerRenameService, _boardSwimlaneLaneRenameService: BoardSwimlaneLaneRenameService, _elementStateService: IBoardElementStateService, _uiStateService: IBoardUIStateService, _contextService: IContextService, _inkStateService: IInkUIStateService);
     private _shouldIgnoreFocusChanges;
     private _init;

package/lib/types/controllers/board-tool-shortcut.controller.d.ts

@@ -1,22 +1,11 @@
-import { ICommandService, IConfigService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import type { BoardToolShortcutAction } from '../common/board-shortcuts';
+import type { BoardShortcutRuntimeService } from '../services/board-shortcut-runtime.service';
+import { ICommandService, RxDisposable } from '@univerjs/core';
 import { IShortcutService } from '@univerjs/ui';
-import { IBoardElementStateService } from '../services/board-element-state.service';
-import { BoardToolService } from '../services/board-tool.service';
-import { IBoardUIStateService } from '../services/board-ui-state.service';
 export declare const BOARD_TOOL_SHORTCUT_OPERATION_ID = "board.operation.tool-shortcut";
+export declare function handleToolShortcut(runtime: BoardShortcutRuntimeService, action: BoardToolShortcutAction | undefined): boolean;
 export declare class BoardToolShortcutController extends RxDisposable {
-    private readonly _instanceService;
-    private readonly _configService;
-    private readonly _elementStateService;
-    private readonly _stateService;
-    private readonly _toolService;
     private readonly _commandService;
     private readonly _shortcutService;
-    constructor(_instanceService: IUniverInstanceService, _configService: IConfigService, _elementStateService: IBoardElementStateService, _stateService: IBoardUIStateService, _toolService: BoardToolService, _commandService: ICommandService, _shortcutService: IShortcutService);
-    private _init;
-    private _createToolShortcutOperation;
-    private _createShortcutItem;
-    private _handleShortcut;
-    private _canCancelTool;
-    private _getCurrentBoardModel;
+    constructor(_commandService: ICommandService, _shortcutService: IShortcutService);
 }

package/lib/types/controllers/board-unit-presence.controller.d.ts

@@ -0,0 +1,6 @@
+import { Disposable } from '@univerjs/core';
+import { IUnitPresenceUIAdapterRegistry } from '@univerjs/ui';
+import { BoardUnitPresenceUIAdapter } from '../services/board-unit-presence-ui-adapter.service';
+export declare class BoardUnitPresenceController extends Disposable {
+    constructor(adapterRegistry: IUnitPresenceUIAdapterRegistry, adapter: BoardUnitPresenceUIAdapter);
+}

package/lib/types/controllers/board-unit-presence.render-controller.d.ts

@@ -0,0 +1,37 @@
+import type { BoardModel } from '@univerjs-pro/boards';
+import type { IRenderContext, IRenderModule } from '@univerjs/engine-render';
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { ICommandService, RxDisposable, ThemeService } from '@univerjs/core';
+import { IBoardUIStateService } from '../services/board-ui-state.service';
+import { BoardUnitPresenceUIAdapter } from '../services/board-unit-presence-ui-adapter.service';
+export declare class BoardUnitPresenceRenderController extends RxDisposable implements IRenderModule {
+    private readonly _context;
+    private readonly _presenceAdapter;
+    private readonly _commandService;
+    private readonly _boardElementService;
+    private readonly _boardUIStateService;
+    private readonly _themeService;
+    private readonly _selectionShapes;
+    private readonly _pointerAnimations;
+    private _animationFrameId;
+    private _renderScheduled;
+    private _isApplyingOverlays;
+    private _pointersVisible;
+    private _latestPresences;
+    constructor(_context: IRenderContext<BoardModel>, _presenceAdapter: BoardUnitPresenceUIAdapter, _commandService: ICommandService, _boardElementService: IBoardElementService, _boardUIStateService: IBoardUIStateService, _themeService: ThemeService);
+    dispose(): void;
+    private _init;
+    private _scheduleRender;
+    private _render;
+    private _publishLocalPointer;
+    private _clearLocalPointer;
+    private _clearLocalPointerIfActive;
+    private _syncPointers;
+    private _startAnimation;
+    private _animate;
+    private _cancelAnimation;
+    private _removePointer;
+    private _removeAllPointers;
+    private _removeSelectionShapes;
+    private _getSceneObjectByKey;
+}

package/lib/types/controllers/board-view-shortcut.controller.d.ts

@@ -1,29 +1,8 @@
-import { IBoardElementService } from '@univerjs-pro/boards';
-import { ICommandService, IConfigService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
-import { IRenderManagerService } from '@univerjs/engine-render';
+import { ICommandService, RxDisposable } from '@univerjs/core';
 import { IShortcutService } from '@univerjs/ui';
-import { IBoardElementStateService } from '../services/board-element-state.service';
-import { IBoardUIStateService } from '../services/board-ui-state.service';
-import { BoardViewportService } from '../services/board-viewport.service';
 export declare const BOARD_VIEW_SHORTCUT_OPERATION_ID = "board.operation.view-shortcut";
 export declare class BoardViewShortcutController extends RxDisposable {
-    private readonly _instanceService;
-    private readonly _configService;
-    private readonly _renderManagerService;
-    private readonly _boardElementService;
-    private readonly _elementStateService;
-    private readonly _stateService;
-    private readonly _viewportService;
     private readonly _commandService;
     private readonly _shortcutService;
-    constructor(_instanceService: IUniverInstanceService, _configService: IConfigService, _renderManagerService: IRenderManagerService, _boardElementService: IBoardElementService, _elementStateService: IBoardElementStateService, _stateService: IBoardUIStateService, _viewportService: BoardViewportService, _commandService: ICommandService, _shortcutService: IShortcutService);
-    private _init;
-    private _createViewShortcutOperation;
-    private _createShortcutItem;
-    private _handleShortcut;
-    private _getCurrentBoardModel;
-    private _getCanvasElement;
-    private _resolveViewportSize;
-    private _resolveViewportCenterPoint;
-    private _resolveFullscreenTarget;
+    constructor(_commandService: ICommandService, _shortcutService: IShortcutService);
 }

package/lib/types/controllers/board-viewport-bar.render-controller.d.ts

@@ -0,0 +1,41 @@
+import type { UnitModel } from '@univerjs/core';
+import type { IRenderContext, IRenderModule } from '@univerjs/engine-render';
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { IConfigService, IUniverInstanceService, RxDisposable, ThemeService } from '@univerjs/core';
+import { IBoardUIStateService } from '../services/board-ui-state.service';
+export declare class BoardViewportBarRenderController extends RxDisposable implements IRenderModule {
+    private readonly _renderContext;
+    private readonly _instanceSrv;
+    private readonly _boardElementService;
+    private readonly _configService;
+    private readonly _stateService;
+    private readonly _themeService;
+    private _barObject;
+    private _contentBounds;
+    private _drag;
+    private _layout;
+    private _navigationBounds;
+    private _ownsCursor;
+    private _pendingContentRefresh;
+    private _scheduledFrameId;
+    private _viewportPointerActive;
+    private _horizontalEnabled;
+    private _verticalEnabled;
+    constructor(_renderContext: IRenderContext<UnitModel>, _instanceSrv: IUniverInstanceService, _boardElementService: IBoardElementService, _configService: IConfigService, _stateService: IBoardUIStateService, _themeService: ThemeService);
+    dispose(): void;
+    private _init;
+    private _createInitialObjectState;
+    private _syncTheme;
+    private _handleElementChanges;
+    private _scheduleLayoutSync;
+    private _syncLayout;
+    private _resolveViewportPixelSize;
+    private _resolveContentBounds;
+    private _toWorldRect;
+    private _resolveSafeArea;
+    private _handleBarPointerDown;
+    private _handlePointerMove;
+    private _handlePointerEnd;
+    private _getBoardPoint;
+    private _setCursor;
+}

package/lib/types/facade/f-board-layout.d.ts

@@ -0,0 +1,51 @@
+import type { IBoardLayoutAnalysisResult } from '@univerjs-pro/boards';
+import type { IBoardScreenshotOptions, IBoardScreenshotResult } from '@univerjs-pro/boards-ui';
+type AnalyzeBoardRenderedLayoutResult = IBoardLayoutAnalysisResult | false;
+type CaptureBoardScreenshotOptions = IBoardScreenshotOptions;
+type CaptureBoardScreenshotResult = IBoardScreenshotResult | false;
+declare module '@univerjs-pro/boards/facade' {
+    interface FBoard {
+        /**
+         * Detects layout conflicts using connector paths resolved by the current Board renderer.
+         * This browser-only API requires the Boards UI plugin and Facade extension to be registered.
+         * Use `analyzeModelLayout()` when no renderer is available.
+         *
+         * @param focusPadding Padding added to each issue's suggested screenshot bounds.
+         * @returns Structured rendered layout issues, or `false` when no Board scene is available.
+         * @example
+         * ```ts
+         * const board = univerAPI.getActiveBoard();
+         * if (!board) throw new Error('No active board');
+         * const analysis = board.analyzeRenderedLayout(48);
+         * if (!analysis) throw new Error('The active Board is not rendered');
+         * console.log(analysis.issues.map((issue) => ({
+         *     rule: issue.rule,
+         *     severity: issue.severity,
+         *     focusBounds: issue.focusBounds,
+         * })));
+         * ```
+         */
+        analyzeRenderedLayout(focusPadding?: number): AnalyzeBoardRenderedLayoutResult;
+        /**
+         * Captures resolved Board world bounds using the current Board renderer.
+         * This browser-only API requires the Boards UI plugin and Facade extension to be registered.
+         * Resolve selectors with `resolveCaptureBounds()` before calling this method.
+         *
+         * @param options Resolved world bounds and an optional world-to-CSS-pixel scale.
+         * @returns PNG evidence from the current renderer, or `false` when capture cannot run.
+         * @example
+         * ```ts
+         * const board = univerAPI.getActiveBoard();
+         * if (!board) throw new Error('No active board');
+         * const target = board.resolveCaptureBounds({ padding: 48 });
+         * if (!target) throw new Error('Cannot resolve Board capture bounds');
+         * if (!target.ok) throw new Error(`Cannot capture Board: ${target.code}`);
+         * const screenshot = await board.getScreenshot({ bounds: target.bounds, scale: 2 });
+         * if (!screenshot) throw new Error('Cannot capture the active Board renderer');
+         * console.log(screenshot.dataUrl, screenshot.width, screenshot.height);
+         * ```
+         */
+        getScreenshot(options: CaptureBoardScreenshotOptions): Promise<CaptureBoardScreenshotResult>;
+    }
+}
+export {};

package/lib/types/facade/f-board-ui.d.ts

@@ -0,0 +1,19 @@
+import type { IBoardElementFindResult, IBoardSettings, IBoardViewportPoint } from '@univerjs-pro/boards-ui';
+declare module '@univerjs-pro/boards/facade' {
+    interface FBoard {
+        /** Returns the effective settings for the current Board UI runtime. */
+        getSettings(): Required<IBoardSettings>;
+        /** Updates local settings for the current Board UI runtime. */
+        setSettings(settings: Partial<IBoardSettings>): boolean;
+        /** Returns whether the object-list panel is open for the active Board UI. */
+        getObjectListPanelOpen(): boolean;
+        /** Opens or closes the object-list panel after focusing this Board. */
+        setObjectListPanelOpen(open: boolean): boolean;
+        /** Searches the active page using the same text index as the top-right Find panel. */
+        findElementsByText(query: string): IBoardElementFindResult[];
+        /** Selects an element and pans the viewport so its center reaches the requested viewport point. */
+        focusElement(elementId: string, viewportPoint: IBoardViewportPoint): boolean;
+        /** Returns the element center in the current Board viewport coordinate system. */
+        getElementViewportPoint(elementId: string): IBoardViewportPoint | null;
+    }
+}

package/lib/types/facade/index.d.ts

@@ -0,0 +1,2 @@
+import './f-board-layout';
+import './f-board-ui';

package/lib/types/index.d.ts

@@ -1,10 +1,15 @@
 import './global.css';
+export { AnalyzeBoardRenderedLayoutCommand } from './commands/commands/analyze-board-rendered-layout.command';
+export type { IAnalyzeBoardRenderedLayoutCommandParams } from './commands/commands/analyze-board-rendered-layout.command';
+export { CaptureBoardScreenshotCommand } from './commands/commands/capture-board-screenshot.command';
+export type { ICaptureBoardScreenshotCommandParams } from './commands/commands/capture-board-screenshot.command';
 export { BOARD_INSERT_CHART_DIALOG_ID, BOARD_INSERT_CHART_PANEL_COMPONENT, OpenBoardInsertChartDialogOperation, } from './commands/operations/board-chart-dialog.operation';
 export type { IOpenBoardInsertChartDialogOperationParams } from './commands/operations/board-chart-dialog.operation';
 export { BoardCopySelectionOperation, BoardCutSelectionOperation, BoardDeleteSelectionOperation, } from './commands/operations/board-selection.operation';
+export { FindBoardElementsByTextOperation, FocusBoardElementOperation, GetBoardElementViewportPointOperation, GetBoardObjectListPanelOpenOperation, GetBoardSettingsOperation, SetBoardObjectListPanelOpenOperation, SetBoardSettingsOperation, } from './commands/operations/board-ui-control.operation';
 export { BOARD_SHORTCUT_BINDINGS } from './common/board-shortcuts';
-export { BOARDS_UI_PLUGIN_CONFIG_KEY } from './config/config';
-export type { BoardToolbarToolConfig, IUniverBoardsUIConfig, } from './config/config';
+export { BOARDS_UI_PLUGIN_CONFIG_KEY, DEFAULT_BOARD_COLLABORATOR_CURSOR_SHARE_INTERVAL, DEFAULT_BOARD_SETTINGS, resolveBoardCollaboratorCursorShareInterval, resolveBoardRenderAdapters, } from './config/config';
+export type { BoardToolbarToolConfig, IBoardSettings, IBoardViewportBarConfig, IBoardViewportBarPadding, IUniverBoardsUIConfig, } from './config/config';
 export { BOARD_RENDER_LAYER_INDEX, BOARD_RENDER_OBJECT_Z_INDEX, } from './const';
 export { BOARD_MAIN_VIEWPORT_KEY } from './controllers/board-render.controller';
 export { UniverBoardsUIPlugin } from './plugin';
@@ -26,22 +31,28 @@ export type { IBoardElementStateSnapshot } from './services/board-element-state.
 export { IBoardEmbedRuntimeFocusCoordinator } from './services/board-embed-integration.service';
 export { BoardImageInsertService } from './services/board-image-insert.service';
 export { BoardInteractionSurfaceService } from './services/board-interaction-surface.service';
+export { BOARD_SCREENSHOT_MAX_SCALE, BOARD_SCREENSHOT_MIN_SCALE, } from './services/board-screenshot.service';
+export type { IBoardScreenshotOptions, IBoardScreenshotResult, } from './services/board-screenshot.service';
 export { BoardSelectionService } from './services/board-selection.service';
 export { BoardShapeIntrinsicSizeService } from './services/board-shape-intrinsic-size.service';
 export type { IBoardShapeIntrinsicSizeHostUpdateContext, IBoardShapeIntrinsicSizeProvider, } from './services/board-shape-intrinsic-size.service';
 export { BoardSidePanelService, IBoardSidePanelService } from './services/board-side-panel.service';
 export type { BoardSidePanelCloseReason, IBoardSidePanelComponentDescriptor, IBoardSidePanelDescriptor, } from './services/board-side-panel.service';
-export { BoardTextEditingService } from './services/board-text-editing.service';
+export { areBoardShapeTextValuesEquivalent, BoardTextEditingService } from './services/board-text-editing.service';
 export { BoardToolService } from './services/board-tool.service';
 export { BoardToolbarContributionService, IBoardToolbarContributionService, } from './services/board-toolbar-contribution.service';
 export type { BoardToolbarContributionGroup, IBoardToolbarContribution, } from './services/board-toolbar-contribution.service';
 export { BoardUIStateService, IBoardUIStateService } from './services/board-ui-state.service';
 export { BoardViewportService } from './services/board-viewport.service';
+export type { IBoardElementFindResult } from './utils/board-find.util';
 export { resolveRotatedBoardObjectAnchorBound } from './utils/board-floating-toolbar-anchor.util';
 export { resolveBoardFloatingToolbarSelection } from './utils/board-floating-toolbar-selection.util';
 export type { BoardFloatingToolbarOwner, IBoardFloatingToolbarSelection, IResolveBoardFloatingToolbarSelectionOptions, } from './utils/board-floating-toolbar-selection.util';
 export { resolveBoardInteractionConfig } from './utils/board-interaction-config.util';
+export { resolveBoardElementBounds } from './utils/board-selection-geometry.util';
+export { resolveBoardWheelViewportAction } from './utils/board-viewport-input.util';
 export { getBoardPointFromClient } from './utils/board-viewport.util';
-export { BOARD_TOP_RIGHT_MENU_LEADING_PART } from './views/BoardSettingsMenu';
+export type { IBoardViewportPoint } from './utils/board-viewport.util';
+export { BOARD_SETTINGS_MENU_ACTIONS_PART, BOARD_TOP_RIGHT_MENU_LEADING_PART } from './views/BoardSettingsMenu';
 export { BoardShapeTextEditorContainer } from './views/BoardShapeTextEditorContainer';
 export { BoardWorkbench } from './views/BoardWorkbench';

package/lib/types/locale/en-US.d.ts

@@ -94,6 +94,7 @@ declare const locale: {
             collaboratorCursors: string;
             find: string;
             grid: string;
+            viewportBar: string;
             preciseSelection: string;
             quickAdd: string;
             theme: string;
@@ -109,8 +110,6 @@ declare const locale: {
             showDimensions: string;
             showToolbar: string;
             translateInto: string;
-            import: string;
-            export: string;
         };
         objectListPanel: {
             title: string;
@@ -195,7 +194,6 @@ declare const locale: {
             mindMap: string;
             resources: string;
             image: string;
-            import: string;
             wrapInContainer: string;
             addSwimlaneLane: string;
             swimlaneMenu: string;
@@ -208,38 +206,6 @@ declare const locale: {
             sendToBack: string;
             more: string;
         };
-        mermaidImport: {
-            cancel: string;
-            containerName: string;
-            defaultContainerName: string;
-            converting: string;
-            emptyPreview: string;
-            diagnostics: {
-                emptyDraft: string;
-                expandedBounds: string;
-                invalidElement: string;
-                renderElementFailed: string;
-                previewPaused: string;
-            };
-            errors: {
-                emptyCode: string;
-                exchangeUnavailable: string;
-                insertFailed: string;
-                invalidDraft: string;
-            };
-            help: string;
-            insert: string;
-            renderPreview: string;
-            inserting: string;
-            types: {
-                classDiagram: string;
-                erDiagram: string;
-                flowchart: string;
-                mindMap: string;
-                sequenceDiagram: string;
-                stateDiagram: string;
-            };
-        };
         shapePresets: {
             roundedRectangle: string;
             oval: string;

package/lib/types/plugin.d.ts

@@ -1,3 +1,4 @@
+import type { Dependency } from '@univerjs/core';
 import type { IUniverBoardsUIConfig } from './config/config';
 import { ICommandService, IConfigService, Injector, Plugin, UniverInstanceType } from '@univerjs/core';
 import { IRenderManagerService } from '@univerjs/engine-render';
@@ -15,7 +16,12 @@ export declare class UniverBoardsUIPlugin extends Plugin {
     static packageName: string;
     static version: string;
     static type: UniverInstanceType;
+    private static readonly _runtimeScopedDependencies;
+    private static _getRuntimeScopedDependencies;
+    static getRuntimeScopedDependencies(injector: Injector): readonly Dependency[];
+    static registerRuntimeScopedDependencies(injector: Injector, dependencies: readonly Dependency[]): void;
     constructor(_config: Partial<IUniverBoardsUIConfig> | undefined, _injector: Injector, _renderManagerService: IRenderManagerService, _uiPartsService: IUIPartsService, _commandService: ICommandService, _menuManagerService: IMenuManagerService, _configService: IConfigService);
     onStarting(): void;
     onReady(): void;
+    private _registerRenderModules;
 }

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

@@ -1,9 +1,12 @@
-import type { IShapeFormulaPresentation } from '@univerjs-pro/shape-editor';
-import type { BaseObject } from '@univerjs/engine-render';
 import type { IBoardElementData } from '@univerjs-pro/boards';
+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,8 +1,10 @@
 import type { IBoardConnectorElement, IBoardConnectorPoint, IBoardElementData } from '@univerjs-pro/boards';
 import type { IDocumentData, LocaleService } from '@univerjs/core';
-import { BaseObject } from '@univerjs/engine-render';
 import type { IObjectFullState, IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
 import type { IBoardConnectorLabelRect } from '../utils/board-connector-label.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 {
     left: number;
@@ -15,48 +17,83 @@ export interface IBoardConnectorObjectProps {
     evented?: boolean;
     element: IBoardConnectorElement;
     elementData?: Record<string, IBoardElementData>;
+    lineJumpCache?: BoardConnectorLineJumpCache;
+    routingCache?: BoardConnectorRoutingCache;
     localeService?: LocaleService;
 }
 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;
+    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>, options?: {
+        force?: boolean;
+    }): 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 _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;
     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-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: {