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

package/lib/types/common/toolbar-tools.d.ts

@@ -0,0 +1,17 @@
+import type { ComponentType } from 'react';
+import type { IUniverBoardsUIConfig } from '../config/config';
+import type { LocaleKey } from '../locale/types';
+import { BoardToolType } from '@univerjs-pro/boards';
+export interface IBoardToolbarToolDefinition {
+    type: BoardToolType;
+    labelKey: LocaleKey;
+    icon: ComponentType<{
+        className?: string;
+    }>;
+    enabledByDefault: boolean;
+}
+export interface IResolvedBoardToolbarTool extends Omit<IBoardToolbarToolDefinition, 'enabledByDefault'> {
+    disabled: boolean;
+}
+export declare const BOARD_TOOLBAR_TOOL_DEFINITIONS: IBoardToolbarToolDefinition[];
+export declare function resolveBoardToolbarTools(config?: Pick<IUniverBoardsUIConfig, 'toolbar'>): IResolvedBoardToolbarTool[];

package/lib/types/components/object-list-panel/board-object-list-state.d.ts

@@ -0,0 +1,27 @@
+import type { IBoardElementData, IBoardPageElement } from '@univerjs-pro/boards';
+export interface IBoardObjectListItem {
+    id: string;
+    name: string;
+    visible: boolean;
+    selectable: boolean;
+    disabled: boolean;
+    isGroup: boolean;
+    elementOrderIndex: number;
+    parentId?: string;
+    children: IBoardObjectListItem[];
+}
+export interface IBoardObjectListSelectionResult {
+    selectedIds: string[];
+    focusedId: string | null;
+}
+export declare function resolveBoardObjectListItems(map: {
+    data: Record<string, IBoardElementData>;
+    order: string[];
+} | null | undefined): IBoardObjectListItem[];
+export declare function collectBoardObjectListItemIds(items: IBoardObjectListItem[]): string[];
+export declare function resolveBoardObjectListVisibilityChangeIds(items: IBoardObjectListItem[], itemIds: string[], visible: boolean): string[];
+export declare function resolveBoardObjectListSelectionTargetId(items: IBoardObjectListItem[], itemId: string | null | undefined): string | null;
+export declare function resolveBoardObjectListSelectedIds(items: IBoardObjectListItem[], selectedIds: string[]): string[];
+export declare function resolveBoardObjectListFocusedId(items: IBoardObjectListItem[], focusedId: string | null | undefined, selectedIds?: string[]): string | null;
+export declare function resolveBoardObjectListNextSelection(items: IBoardObjectListItem[], selectedIds: string[], itemId: string, multiSelect: boolean): IBoardObjectListSelectionResult;
+export declare function getBoardElementDisplayName(element: IBoardPageElement): string;

package/lib/types/config/config.d.ts

@@ -0,0 +1,92 @@
+import type { BoardToolType, IBoardPageSize, IBoardSettings } from '@univerjs-pro/boards';
+import type { BoardSettingsActionConfig, BoardSettingsActionType } from '../common/settings-actions';
+import type { IBoardShapePreset } from '../common/shape-presets';
+import type { IBoardElementRenderAdapter } from '../render-adapters/board-element-render-adapter';
+export declare const BOARDS_UI_PLUGIN_CONFIG_KEY = "boards-ui.config";
+export declare const configSymbol: unique symbol;
+export type BoardToolbarToolConfig = boolean | {
+    enabled?: boolean;
+};
+export interface IBoardInteractionConfig {
+    alignmentGuideThreshold?: number;
+    maxZoomRatio?: number;
+    minElementSize?: number;
+    minZoomRatio?: number;
+    pendingInsertPreviewAlpha?: number;
+    resizeHandleHitPadding?: number;
+    resizeHandleSize?: number;
+    spacingGuideMaxDistance?: number;
+    trackpadPanEnabled?: boolean;
+    wheelPanFactor?: number;
+    wheelZoomFactor?: number;
+    wheelZoomWithModifier?: boolean;
+    zoomStep?: number;
+    zoomWheelFactor?: number;
+}
+export interface IBoardGridConfig {
+    gridSize?: number;
+    lineColor?: string;
+    majorGridSize?: number;
+    majorLineColor?: string;
+}
+export interface IBoardTableInsertConfig {
+    cellHeight?: number;
+    cellWidth?: number;
+    columns?: number;
+    height?: number;
+    minHeight?: number;
+    minWidth?: number;
+    rows?: number;
+    width?: number;
+}
+export interface IBoardChartInsertConfig {
+    height?: number;
+    width?: number;
+}
+export interface IBoardImageInsertConfig {
+    fallbackHeight?: number;
+    fallbackWidth?: number;
+    fitRatio?: number;
+    minEdge?: number;
+    minPositionOffset?: number;
+}
+export interface IBoardInsertConfig {
+    chart?: IBoardChartInsertConfig;
+    image?: IBoardImageInsertConfig;
+    table?: IBoardTableInsertConfig;
+}
+export interface IBoardShapeConfig {
+    commonCount?: number;
+    presets?: readonly IBoardShapePreset[];
+}
+export interface IBoardStickyConfig {
+    colors?: readonly string[];
+}
+export interface IBoardRenderSceneConfig {
+    minSize?: IBoardPageSize;
+}
+export interface IUniverBoardsUIConfig extends IBoardSettings {
+    additionalRenderAdapters?: readonly IBoardElementRenderAdapter[];
+    grid?: IBoardGridConfig;
+    insert?: IBoardInsertConfig;
+    interaction?: IBoardInteractionConfig;
+    renderAdapters?: readonly IBoardElementRenderAdapter[];
+    settingsMenu?: {
+        actions?: Partial<Record<BoardSettingsActionType, BoardSettingsActionConfig>>;
+    };
+    shape?: IBoardShapeConfig;
+    sticky?: IBoardStickyConfig;
+    toolbar?: {
+        tools?: Partial<Record<BoardToolType, BoardToolbarToolConfig>>;
+    };
+    scene?: IBoardRenderSceneConfig;
+    workbench?: {
+        content?: boolean;
+        footer?: boolean;
+        header?: boolean;
+        headerMenu?: boolean;
+        toolbar?: boolean;
+    };
+}
+export declare const defaultPluginConfig: IUniverBoardsUIConfig;
+export declare function resolveBoardRenderAdapters(config?: Pick<IUniverBoardsUIConfig, 'additionalRenderAdapters' | 'renderAdapters'>): readonly IBoardElementRenderAdapter[];

package/lib/types/const.d.ts

@@ -0,0 +1,26 @@
+export declare const BOARD_SHAPE_TEXT_EDITOR_ID: string;
+export declare const BOARD_DOM_LAYER_ROOT_Z_INDEX = 10;
+export declare const BOARD_DOM_LAYER_POPUP_Z_INDEX = 60;
+export declare const BOARD_RENDER_LAYER_INDEX: {
+    readonly background: 0;
+    readonly grid: 0;
+    readonly container: 1;
+    readonly element: 2;
+    readonly preview: 3;
+    readonly overlay: 4;
+    readonly connectorAffordance: 5;
+    readonly connectorHandle: 6;
+    readonly connectorSnap: 7;
+};
+export declare const BOARD_RENDER_OBJECT_Z_INDEX: {
+    readonly background: -1;
+    readonly default: 0;
+    readonly preview: 100;
+    readonly overlay: 200;
+    readonly transientPreview: 10000;
+    readonly transientPreviewForeground: 10001;
+    readonly transientControl: 10002;
+    readonly transientEditHandle: 10003;
+    readonly transientSnap: 10004;
+    readonly transientResize: 10005;
+};

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

@@ -0,0 +1,25 @@
+import { ICommandService, IConfigService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import { IRenderManagerService } from '@univerjs/engine-render';
+import { IShortcutService } from '@univerjs/ui';
+import { BoardClipboardService } from '../services/board-clipboard.service';
+import { BoardElementEditService } from '../services/board-element-edit.service';
+import { IBoardElementStateService } from '../services/board-element-state.service';
+import { IBoardUIStateService } from '../services/board-ui-state.service';
+export declare const BOARD_CLIPBOARD_SHORTCUT_OPERATION_ID = "board.operation.clipboard-shortcut";
+export declare class BoardClipboardShortcutController extends RxDisposable {
+    private readonly _instanceService;
+    private readonly _configService;
+    private readonly _renderManagerService;
+    private readonly _elementStateService;
+    private readonly _stateService;
+    private readonly _clipboardService;
+    private readonly _elementEditService;
+    private readonly _commandService;
+    private readonly _shortcutService;
+    constructor(_instanceService: IUniverInstanceService, _configService: IConfigService, _renderManagerService: IRenderManagerService, _elementStateService: IBoardElementStateService, _stateService: IBoardUIStateService, _clipboardService: BoardClipboardService, _elementEditService: BoardElementEditService, _commandService: ICommandService, _shortcutService: IShortcutService);
+    private _init;
+    private _createClipboardShortcutOperation;
+    private _createShortcutItem;
+    private _handleShortcut;
+    private _getCurrentBoardModel;
+}

package/lib/types/controllers/board-connector-floating-toolbar.render-controller.d.ts

@@ -0,0 +1,30 @@
+import type { UnitModel } from '@univerjs/core';
+import type { IRenderContext, IRenderModule } from '@univerjs/engine-render';
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { RxDisposable } from '@univerjs/core';
+import { ComponentManager } from '@univerjs/ui';
+import { BoardCanvasPopManagerService } from '../services/board-canvas-pop-manager.service';
+import { IBoardElementStateService } from '../services/board-element-state.service';
+import { BoardTextEditingService } from '../services/board-text-editing.service';
+export declare class BoardConnectorFloatingToolbarRenderController extends RxDisposable implements IRenderModule {
+    private readonly _renderContext;
+    private readonly _componentManager;
+    private readonly _boardCanvasPopManagerService;
+    private readonly _boardElementService;
+    private readonly _elementStateService;
+    private readonly _boardTextEditingService;
+    private _popupDisposable;
+    private _popupSelectionKey;
+    constructor(_renderContext: IRenderContext<UnitModel>, _componentManager: ComponentManager, _boardCanvasPopManagerService: BoardCanvasPopManagerService, _boardElementService: IBoardElementService, _elementStateService: IBoardElementStateService, _boardTextEditingService: BoardTextEditingService);
+    dispose(): void;
+    private _init;
+    private _clearPopup;
+    private _clearPopupIfSelectionChanged;
+    private _isPopupSelectionStillActive;
+    private _buildPopupSelectionKey;
+    private _showPopupForSelection;
+    private _resolvePopupAnchorMode;
+    private _resolveConnectorPopupAnchorMode;
+    private _getConnectorRenderObject;
+    private _isConnectorTextEditing;
+}

package/lib/types/controllers/board-connector-interaction.render-controller.d.ts

@@ -0,0 +1,158 @@
+import type { UnitModel } from '@univerjs/core';
+import type { IRenderContext, IRenderModule } from '@univerjs/engine-render';
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { ICommandService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import { ComponentManager } from '@univerjs/ui';
+import { BoardCanvasPopManagerService } from '../services/board-canvas-pop-manager.service';
+import { BoardElementEditService } from '../services/board-element-edit.service';
+import { BoardElementInsertService } from '../services/board-element-insert.service';
+import { IBoardElementStateService } from '../services/board-element-state.service';
+import { BoardTextEditingService } from '../services/board-text-editing.service';
+import { IBoardUIStateService } from '../services/board-ui-state.service';
+export declare class BoardConnectorInteractionRenderController extends RxDisposable implements IRenderModule {
+    private readonly _renderContext;
+    private readonly _instanceSrv;
+    private readonly _boardElementService;
+    private readonly _elementStateService;
+    private readonly _commandService;
+    private readonly _stateService;
+    private readonly _editService;
+    private readonly _insertService;
+    private readonly _componentManager;
+    private readonly _boardCanvasPopManagerService;
+    private readonly _boardTextEditingService;
+    private _attachObjectPointerScheduled;
+    private _objectPointerDisposables;
+    private _affordanceObject;
+    private _endpointObject;
+    private _waypointObject;
+    private _snapObject;
+    private _handledDblClickEvent;
+    private _lastWaypointInsertDblClick;
+    private _endpointDrag;
+    private _waypointDrag;
+    private _waypointPointDrag;
+    private _curveAnchorDrag;
+    private _focusedWaypoint;
+    private _focusedCurveAnchor;
+    private _focusedConnectorLabel;
+    private _connectorBodyDrag;
+    private _connectorLabelDrag;
+    private _connectorLabelResizeDrag;
+    private _committingConnectorPreview;
+    private _ownsConnectorHoverCursor;
+    private _quickShapePopupDisposable;
+    private _draft;
+    private _draftObject;
+    private _quickConnectHoverPreview;
+    private _quickConnectPointerDownPreview;
+    private _quickConnectPreviewConnectorObject;
+    private _quickConnectPreviewShapeObject;
+    constructor(_renderContext: IRenderContext<UnitModel>, _instanceSrv: IUniverInstanceService, _boardElementService: IBoardElementService, _elementStateService: IBoardElementStateService, _commandService: ICommandService, _stateService: IBoardUIStateService, _editService: BoardElementEditService, _insertService: BoardElementInsertService, _componentManager: ComponentManager, _boardCanvasPopManagerService: BoardCanvasPopManagerService, _boardTextEditingService: BoardTextEditingService);
+    private _init;
+    private _scheduleAttachObjectPointerHandlers;
+    private _scheduleAttachObjectPointerHandlersWithFollowUp;
+    private _attachObjectPointerHandlers;
+    private _subscribeToWindowConnectorInterruptions;
+    private _cancelActiveConnectorInteractions;
+    private _isLineToolActive;
+    private _isFreePolylineToolActive;
+    private _getBoardPointFromEvent;
+    private _handleKeyDown;
+    private _cancelActiveConnectorDrag;
+    private _syncSceneInputMode;
+    private _getElementData;
+    private _isConnectorTextEditing;
+    private _isTextEditing;
+    private _createAffordanceHandles;
+    private _getFocusedConnectorElement;
+    private _createEndpointHandles;
+    private _createWaypointSegments;
+    private _getConnectorVisibleRoutePoints;
+    private _syncAffordanceObject;
+    private _syncEndpointObject;
+    private _syncWaypointObject;
+    private _createWaypointHandles;
+    private _createConnectorLabelSelections;
+    private _createConnectorLabelObstacles;
+    private _createCurveAnchorHandles;
+    private _syncSnapObject;
+    private _resolveEndpoint;
+    private _resolveConnectorAxisSnapAnchor;
+    private _createConnectorElement;
+    private _createConnectorEndpointUpdate;
+    private _withShapeSiteFallbacksResolvedToSites;
+    private _createConnectorMoveUpdate;
+    private _getConnectorEditSelectionSnapshot;
+    private _syncConnectorEditHandles;
+    private _commitConnectorPreviewUpdate;
+    private _activateConnectorDrag;
+    private _finishFreePolylineDraft;
+    private _clearQuickShapePopup;
+    private _insertQuickConnectedShape;
+    private _insertQuickConnectedConnector;
+    private _resolveQuickConnectSourceShape;
+    private _resolveQuickConnectShapeType;
+    private _resolveQuickConnectSourceSize;
+    private _resolveQuickConnectHoverTarget;
+    private _createQuickConnectHoverPreview;
+    private _getQuickConnectPreviewElementData;
+    private _syncQuickConnectHoverPreview;
+    private _clearQuickConnectHoverPreview;
+    private _commitQuickConnectPreview;
+    private _getElementDataWithElement;
+    private _createQuickConnectorTargetUpdate;
+    private _insertQuickConnectedShapeForConnector;
+    private _showQuickShapeMenu;
+    private _previewConnectorElement;
+    private _isSelectionToolActive;
+    private _syncActiveConnectorInteractionState;
+    private _resolveFocusedConnectorBodyHit;
+    private _isConnectorPathHit;
+    private _resolveFocusedConnectorLabelHit;
+    private _createConnectorLabelMoveUpdate;
+    private _createConnectorLabelResizeUpdate;
+    private _addConnectorLabelAtPoint;
+    private _removeFocusedConnectorLabel;
+    private _resolveConnectorLabelPathPoints;
+    private _resolveConnectorLabelRect;
+    private _getSceneObject;
+    private _handlePointerDown;
+    private _handleDblClick;
+    private _isSequenceActivationHit;
+    private _resolveSequenceLifelineHit;
+    private _insertSequenceActivationBar;
+    private _handleAffordancePointerDown;
+    private _handleEndpointPointerDown;
+    private _handleConnectorLabelResizePointerDown;
+    private _handleWaypointPointerDown;
+    private _removeFocusedWaypoint;
+    private _removeFocusedCurveAnchor;
+    private _handlePointerMove;
+    private _handlePointerUp;
+    private _handleEndpointPointerMove;
+    private _handleEndpointPointerUp;
+    private _clearEndpointDrag;
+    private _handleWaypointPointerMove;
+    private _syncConnectorHoverCursor;
+    private _setConnectorHoverCursor;
+    private _handleWaypointPointerUp;
+    private _clearWaypointDrag;
+    private _handleWaypointPointPointerMove;
+    private _handleWaypointPointPointerUp;
+    private _clearWaypointPointDrag;
+    private _handleCurveAnchorPointerMove;
+    private _handleCurveAnchorPointerUp;
+    private _clearCurveAnchorDrag;
+    private _handleConnectorBodyPointerMove;
+    private _handleConnectorBodyPointerUp;
+    private _clearConnectorBodyDrag;
+    private _handleConnectorLabelPointerMove;
+    private _handleConnectorLabelPointerUp;
+    private _handleConnectorLabelResizePointerMove;
+    private _handleConnectorLabelResizePointerUp;
+    private _clearConnectorLabelDrag;
+    private _clearConnectorLabelResizeDrag;
+    private _syncDraftObject;
+    private _clearDraft;
+}

package/lib/types/controllers/board-container-membership.render-controller.d.ts

@@ -0,0 +1,27 @@
+import type { UnitModel } from '@univerjs/core';
+import type { IRenderContext, IRenderModule } from '@univerjs/engine-render';
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import { IBoardUIStateService } from '../services/board-ui-state.service';
+export declare class BoardContainerMembershipRenderController extends RxDisposable implements IRenderModule {
+    private readonly _renderContext;
+    private readonly _instanceSrv;
+    private readonly _stateService;
+    private readonly _boardElementService;
+    private _membershipObject;
+    private _spatialIndex;
+    private _spatialIndexPageId;
+    private _previewSource;
+    private _isForceCaptureModifierActive;
+    constructor(_renderContext: IRenderContext<UnitModel>, _instanceSrv: IUniverInstanceService, _stateService: IBoardUIStateService, _boardElementService: IBoardElementService);
+    private _init;
+    private _subscribeToElementChanges;
+    private _subscribeToPendingInsert;
+    private _subscribeToTransformer;
+    private _syncPreview;
+    private _syncPendingInsertPreview;
+    private _clearPreview;
+    private _subscribeToForceCaptureModifier;
+    private _getSpatialIndex;
+    private _disposeSpatialIndex;
+}

package/lib/types/controllers/board-element-selection.controller.d.ts

@@ -0,0 +1,63 @@
+import type { UnitModel } from '@univerjs/core';
+import type { IRenderContext, IRenderModule } from '@univerjs/engine-render';
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { IInkUIStateService } from '@univerjs-pro/ink-ui';
+import { IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import { IContextMenuService } from '@univerjs/ui';
+import { IBoardElementStateService } from '../services/board-element-state.service';
+import { IBoardInkEditService } from '../services/board-ink-edit.service';
+import { BoardSelectionOverlayService } from '../services/board-selection-overlay.service';
+import { BoardSelectionService } from '../services/board-selection.service';
+import { BoardTextEditingService } from '../services/board-text-editing.service';
+import { IBoardUIStateService } from '../services/board-ui-state.service';
+export declare class BoardElementSelectionController extends RxDisposable implements IRenderModule {
+    private readonly _renderContext;
+    private readonly _instanceSrv;
+    private readonly _boardElementService;
+    private readonly _stateSrv;
+    private readonly _selectionService;
+    private readonly _selectionOverlayService;
+    private readonly _uiStateService;
+    private readonly _contextMenuService;
+    private readonly _inkStateService;
+    private readonly _inkEditService;
+    private readonly _boardTextEditingService;
+    private _attachScheduled;
+    private _handledElementPointerDownEvent;
+    private _isSyncingTransformer;
+    private _objectPointerDisposables;
+    private _restoreTransformerScheduled;
+    private _selectionDraft;
+    constructor(_renderContext: IRenderContext<UnitModel>, _instanceSrv: IUniverInstanceService, _boardElementService: IBoardElementService, _stateSrv: IBoardElementStateService, _selectionService: BoardSelectionService, _selectionOverlayService: BoardSelectionOverlayService, _uiStateService: IBoardUIStateService, _contextMenuService: IContextMenuService, _inkStateService: IInkUIStateService, _inkEditService: IBoardInkEditService, _boardTextEditingService: BoardTextEditingService);
+    private _init;
+    private _subscribeToTextEditing;
+    private _wireScenePointerSelection;
+    private _subscribeToWindowSelectionInterruptions;
+    private _clearSelectionDraft;
+    private _clearSelectionDraftIfInkInteractionActive;
+    private _wireTransformerToState;
+    private _syncFromTransformer;
+    private _scheduleAttachObjectTransformers;
+    private _scheduleAttachObjectTransformersWithFollowUp;
+    private _attachObjectTransformers;
+    private _handleElementPointerDown;
+    private _handleContextMenuPointerDown;
+    private _resolveDeepSelectElementId;
+    private _openContextMenu;
+    private _resolveFocusedSwimlaneLane;
+    private _syncToTransformer;
+    private _scheduleTransformerRestoreAfterTextEditingExit;
+    private _canSelectElement;
+    private _isStructuralContainer;
+    private _canAttachTransformer;
+    private _resolveTransformerConfig;
+    private _shouldDisableTransformerRotation;
+    private _isSelectPointerEvent;
+    private _isContextMenuPointerEvent;
+    private _isSelectionToolActive;
+    private _isTextEditingActive;
+    private _isInkInteractionActive;
+    private _isHandledElementPointerDown;
+    private _getBoardPointFromEvent;
+    private _createContextMenuEvent;
+}

package/lib/types/controllers/board-element-transform.controller.d.ts

@@ -0,0 +1,52 @@
+import type { UnitModel } from '@univerjs/core';
+import type { IRenderContext, IRenderModule } from '@univerjs/engine-render';
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import { BoardElementEditService } from '../services/board-element-edit.service';
+import { IBoardElementStateService } from '../services/board-element-state.service';
+export declare class BoardElementTransformController extends RxDisposable implements IRenderModule {
+    private readonly _renderContext;
+    private readonly _instanceSrv;
+    private readonly _boardElementService;
+    private readonly _stateSrv;
+    private readonly _editService;
+    private _isForceCaptureModifierActive;
+    private _shiftTransformStartRects;
+    private _areTransformerControlsHiddenForTransform;
+    private _xSnapSession;
+    private _ySnapSession;
+    constructor(_renderContext: IRenderContext<UnitModel>, _instanceSrv: IUniverInstanceService, _boardElementService: IBoardElementService, _stateSrv: IBoardElementStateService, _editService: BoardElementEditService);
+    private _init;
+    private _subscribeToTransformer;
+    private _keepTransformerControlsHiddenForTransform;
+    private _hideTransformerControls;
+    private _restoreTransformerControlsAfterTransform;
+    private _captureShiftTransformStartRects;
+    private _resetAlignmentSnapSessions;
+    private _applyShiftTransformModifier;
+    private _applyAlignmentSnapModifier;
+    private _resolveAlignmentSnapDelta;
+    private _applySequenceActivationSnapModifier;
+    private _applyProportionalResize;
+    private _syncRealtimeTransformPreview;
+    private _syncContainerDescendantPreviews;
+    private _createRealtimePreviewElementData;
+    private _syncShapeBoundConnectorPreviews;
+    private _withPreviewConnectorTransform;
+    private _syncTransformToData;
+    private _subscribeToForceCaptureModifier;
+    private _resolveSingleContainerTransformUpdate;
+    private _resolveContainerTransformInteraction;
+    private _appendShapeBoundConnectorFallbackUpdates;
+    private _createCommittedElementData;
+    private _refreshConnectorDataForElementData;
+    private _refreshConnectorFallbackPointsForElementData;
+    private _updateEndpointFallbackPoint;
+    private _resolveLaneIdForTransform;
+    private _createTransformUpdate;
+    private _applyTextBoxResizePolicy;
+    private _resolveSequenceActivationSnap;
+    private _withSequenceActivationData;
+    private _resolveValidParentId;
+    private _createSelectionSnapshot;
+}

package/lib/types/controllers/board-element-transformer-config.util.d.ts

@@ -0,0 +1,27 @@
+export declare const BOARD_TRANSFORMER_CONFIG: {
+    readonly borderEnabled: true;
+    readonly borderStroke: "#4086f4";
+    readonly borderStrokeWidth: 1;
+    readonly borderSpacing: 2;
+    readonly anchorFill: "#ffffff";
+    readonly anchorStroke: "#4086f4";
+    readonly anchorStrokeWidth: 1.5;
+    readonly anchorSize: 8;
+    readonly anchorCornerRadius: 2;
+    readonly anchorStyle: "canva";
+    readonly rotateEnabled: true;
+    readonly rotateSize: 18;
+    readonly rotateCornerRadius: 9;
+    readonly rotateAnchorOffset: 28;
+    readonly rotateAnchorPosition: "bottom";
+    readonly rotateLineEnabled: false;
+    readonly rotateFill: "#ffffff";
+    readonly rotateStroke: "#4086f4";
+    readonly rotateStrokeWidth: 1;
+    readonly rotateIconEnabled: true;
+    readonly rotateIconStroke: "#4086f4";
+    readonly rotateIconStrokeWidth: 1.25;
+    readonly resizeEnabled: true;
+    readonly keepRatio: false;
+    readonly moveBoundaryEnabled: false;
+};

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

@@ -0,0 +1,14 @@
+import type { UnitModel } from '@univerjs/core';
+import type { IRenderContext, IRenderModule } from '@univerjs/engine-render';
+import { IConfigService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import { IBoardUIStateService } from '../services/board-ui-state.service';
+export declare class BoardGridRenderController extends RxDisposable implements IRenderModule {
+    private readonly _renderContext;
+    private readonly _instanceSrv;
+    private readonly _configService;
+    private readonly _boardUIStateService;
+    private _gridObject;
+    constructor(_renderContext: IRenderContext<UnitModel>, _instanceSrv: IUniverInstanceService, _configService: IConfigService, _boardUIStateService: IBoardUIStateService);
+    private _init;
+    private _syncGridObject;
+}

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

@@ -0,0 +1,20 @@
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { ICommandService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import { IShortcutService } from '@univerjs/ui';
+import { BoardElementEditService } from '../services/board-element-edit.service';
+import { IBoardElementStateService } from '../services/board-element-state.service';
+export declare const BOARD_GROUPING_SHORTCUT_OPERATION_ID = "board.operation.grouping-shortcut";
+export declare class BoardGroupingShortcutController extends RxDisposable {
+    private readonly _instanceService;
+    private readonly _boardElementService;
+    private readonly _elementStateService;
+    private readonly _elementEditService;
+    private readonly _commandService;
+    private readonly _shortcutService;
+    constructor(_instanceService: IUniverInstanceService, _boardElementService: IBoardElementService, _elementStateService: IBoardElementStateService, _elementEditService: BoardElementEditService, _commandService: ICommandService, _shortcutService: IShortcutService);
+    private _init;
+    private _createGroupingShortcutOperation;
+    private _createShortcutItem;
+    private _handleShortcut;
+    private _getCurrentBoardModel;
+}

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

@@ -0,0 +1,16 @@
+import { ICommandService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import { IShortcutService } from '@univerjs/ui';
+import { IBoardElementStateService } from '../services/board-element-state.service';
+export declare const BOARD_HISTORY_SHORTCUT_OPERATION_ID = "board.operation.history-shortcut";
+export declare class BoardHistoryShortcutController extends RxDisposable {
+    private readonly _instanceService;
+    private readonly _elementStateService;
+    private readonly _commandService;
+    private readonly _shortcutService;
+    constructor(_instanceService: IUniverInstanceService, _elementStateService: IBoardElementStateService, _commandService: ICommandService, _shortcutService: IShortcutService);
+    private _init;
+    private _createHistoryShortcutOperation;
+    private _createShortcutItem;
+    private _handleShortcut;
+    private _getCurrentBoardModel;
+}