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

package/lib/types/utils/board-shape-outline.util.d.ts

@@ -0,0 +1,53 @@
+import type { IBoardConnectorPoint } from '@univerjs-pro/boards';
+import type { IBasicShapeData } from '@univerjs-pro/engine-shape';
+export interface IBoardShapeOutlineBounds {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface IBoardShapeOutlineSegment {
+    start: IBoardConnectorPoint;
+    end: IBoardConnectorPoint;
+}
+export interface IBoardShapeNearestBoundaryPoint {
+    outlineIndex?: number;
+    segmentIndex: number;
+    segmentT: number;
+    boundaryRatio?: number;
+    x: number;
+    y: number;
+    distance: number;
+    normal: IBoardConnectorPoint;
+}
+export interface IBoardShapePathOutlineSegment extends IBoardShapeOutlineSegment {
+    outlineIndex: number;
+    segmentIndex: number;
+    startLength: number;
+    length: number;
+}
+export interface IBoardShapePathOutline {
+    segments: IBoardShapePathOutlineSegment[];
+    totalLength: number;
+}
+export interface IResolveBoardShapePathOutlineOptions {
+    shapeType: string | undefined;
+    bounds: IBoardShapeOutlineBounds;
+    shapeData?: IBasicShapeData;
+}
+export interface IResolveBoardShapePathBoundaryPointOptions extends IResolveBoardShapePathOutlineOptions {
+    outlineIndex?: number;
+    segmentIndex: number;
+    segmentT: number;
+    boundaryRatio?: number;
+}
+export declare function normalizeBoardVector(vector: IBoardConnectorPoint): IBoardConnectorPoint;
+export declare function clampBoardValue(value: number, min: number, max: number): number;
+export declare function resolveBoardShapePathOutline(options: IResolveBoardShapePathOutlineOptions): IBoardShapePathOutline | null;
+export declare function resolveBoardShapePolygonOutlineVertices(shapeType: string | undefined, bounds: IBoardShapeOutlineBounds): IBoardConnectorPoint[] | null;
+export declare function resolveBoardPolygonBoundarySegment(vertices: readonly IBoardConnectorPoint[], segmentIndex: number): IBoardShapeOutlineSegment;
+export declare function resolveBoardPointOnSegment(start: IBoardConnectorPoint, end: IBoardConnectorPoint, t: number): IBoardConnectorPoint;
+export declare function resolveBoardClockwisePolygonSegmentNormal(start: IBoardConnectorPoint, end: IBoardConnectorPoint): IBoardConnectorPoint;
+export declare function resolveNearestBoardPolygonBoundaryPoint(point: IBoardConnectorPoint, vertices: readonly IBoardConnectorPoint[]): IBoardShapeNearestBoundaryPoint | null;
+export declare function resolveNearestBoardShapeBoundaryPoint(point: IBoardConnectorPoint, options: IResolveBoardShapePathOutlineOptions): IBoardShapeNearestBoundaryPoint | null;
+export declare function resolveBoardShapeBoundaryPoint(options: IResolveBoardShapePathBoundaryPointOptions): IBoardShapeNearestBoundaryPoint | null;

package/lib/types/utils/board-shape-text-document.util.d.ts

@@ -0,0 +1,20 @@
+import type { IShapeTextDataModel } from '@univerjs-pro/engine-shape';
+import type { IDocumentData, ITextStyle } from '@univerjs/core';
+import { HorizontalAlign, VerticalAlign, WrapStrategy } from '@univerjs/core';
+export interface IBoardPlainTextToDocumentOptions {
+    horizontalAlign?: HorizontalAlign;
+    id?: string;
+    textStyle?: ITextStyle;
+    verticalAlign?: VerticalAlign;
+    wrapStrategy?: WrapStrategy;
+}
+/**
+ * @deprecated Use `IShapeTextDataModel<IDocumentData, HorizontalAlign, VerticalAlign>`
+ * from `@univerjs-pro/engine-shape`. This alias remains for board UI
+ * compatibility while all products converge on the shared shape-text model.
+ */
+export type IBoardShapeTextModel = IShapeTextDataModel<IDocumentData, HorizontalAlign, VerticalAlign>;
+export declare function plainTextToBoardDocumentData(text: string, options?: IBoardPlainTextToDocumentOptions): IDocumentData;
+export declare function cloneBoardTextDocument(editorId: string, documentData: IDocumentData): IDocumentData;
+export declare function documentDataToBoardPlainText(documentData: IDocumentData): string;
+export declare function getBoardShapeTextModel(shapeText: unknown): IBoardShapeTextModel | null;

package/lib/types/utils/board-shape-theme.util.d.ts

@@ -0,0 +1,4 @@
+import type { IBoardElementData, IBoardPageElement, IBoardThemeData } from '@univerjs-pro/boards';
+export declare function resolveBoardUIThemePrimaryColor(themeData?: IBoardThemeData): string;
+export declare function resolveBoardUIShapeElementTheme(element: IBoardPageElement, themeData?: IBoardThemeData): IBoardPageElement;
+export declare function resolveBoardUIElementDataTheme(elementDataItem: IBoardElementData, themeData?: IBoardThemeData): IBoardElementData;

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

@@ -0,0 +1,3 @@
+import type { IContextService } from '@univerjs/core';
+import type { IBoardElementStateService } from '../services/board-element-state.service';
+export declare function isBoardShortcutAvailable(contextService: IContextService, elementStateService: IBoardElementStateService): boolean;

package/lib/types/utils/board-snap-session.util.d.ts

@@ -0,0 +1,62 @@
+export type BoardSnapAxis = 'x' | 'y';
+export interface IBoardSnapGuide {
+    id: string;
+    axis: BoardSnapAxis;
+    position: number;
+}
+export interface IBoardSnapSessionConfig {
+    enterThreshold?: number;
+    exitThreshold?: number;
+    breakawayThreshold?: number;
+    softThreshold?: number;
+    hardThreshold?: number;
+    softMaxStrength?: number;
+    cooldownMs?: number;
+}
+export interface IBoardSnapAxisOptions {
+    axis: BoardSnapAxis;
+    value: number;
+    guide: IBoardSnapGuide | null;
+    now?: number;
+}
+export interface IBoardSnapAxisResult {
+    snapped: boolean;
+    value: number;
+    guide: IBoardSnapGuide | null;
+}
+export interface IBoardConnectorAxisSnapOptions {
+    anchor: {
+        x: number;
+        y: number;
+    };
+    point: {
+        x: number;
+        y: number;
+    };
+    threshold: number;
+}
+export interface IBoardConnectorAxisSnapResult {
+    point: {
+        x: number;
+        y: number;
+    };
+    axis: 'horizontal' | 'vertical';
+    guide: IBoardSnapGuide;
+}
+export declare class BoardSnapSession {
+    private readonly _enterThreshold;
+    private readonly _exitThreshold;
+    private readonly _breakawayThreshold;
+    private readonly _softThreshold;
+    private readonly _hardThreshold;
+    private readonly _softMaxStrength;
+    private readonly _cooldownMs;
+    private _activeGuideId;
+    private _activeGuideStartValue;
+    private readonly _releasedGuideUntil;
+    constructor(config?: IBoardSnapSessionConfig);
+    reset(): void;
+    resolveAxisSnap(options: IBoardSnapAxisOptions): IBoardSnapAxisResult;
+    private _resolveSnappedValue;
+}
+export declare function resolveBoardConnectorAxisSnap(options: IBoardConnectorAxisSnapOptions): IBoardConnectorAxisSnapResult | null;

package/lib/types/utils/board-spacing-guides.util.d.ts

@@ -0,0 +1,24 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IBoardSelectionRect } from './board-selection-geometry.util';
+export type BoardSpacingGuideAxis = 'horizontal' | 'vertical';
+export interface IBoardSpacingGuidePoint {
+    x: number;
+    y: number;
+}
+export interface IBoardSpacingGuide {
+    axis: BoardSpacingGuideAxis;
+    distance: number;
+    sourceElementId: string;
+    sourceId: string;
+    start: IBoardSpacingGuidePoint;
+    end: IBoardSpacingGuidePoint;
+    label: IBoardSpacingGuidePoint;
+}
+export interface IResolveBoardElementSpacingGuidesOptions {
+    activeRect: IBoardSelectionRect;
+    activeIds: string[];
+    elementData: Record<string, IBoardElementData>;
+    elementOrder: string[];
+    maxDistance?: number;
+}
+export declare function resolveBoardElementSpacingGuides(options: IResolveBoardElementSpacingGuidesOptions): IBoardSpacingGuide[];

package/lib/types/utils/board-swimlane-focus.util.d.ts

@@ -0,0 +1,11 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IBoardFocusedSwimlaneLane } from '../services/board-element-state.service';
+export interface IResolveBoardFocusedSwimlaneLaneAtPointOptions {
+    elementData: Record<string, IBoardElementData>;
+    containerId: string;
+    point: {
+        x: number;
+        y: number;
+    };
+}
+export declare function resolveBoardFocusedSwimlaneLaneAtPoint(options: IResolveBoardFocusedSwimlaneLaneAtPointOptions): IBoardFocusedSwimlaneLane | null;

package/lib/types/utils/board-swimlane-resize.util.d.ts

@@ -0,0 +1,25 @@
+import type { IBoardConnectorPoint, IBoardContainerElement, IBoardRect } from '@univerjs-pro/boards';
+export interface IBoardSwimlaneLaneResizeHandle {
+    containerId: string;
+    laneId: string;
+    nextLaneId: string;
+    orientation: 'horizontal' | 'vertical';
+    origin: IBoardConnectorPoint;
+    initialSize: number;
+    minSize: number;
+    line: {
+        start: IBoardConnectorPoint;
+        end: IBoardConnectorPoint;
+    };
+    hitBounds: IBoardRect;
+}
+export interface IResolveBoardSwimlaneLaneResizeHandlesOptions {
+    hitSlop?: number;
+}
+export interface IBoardSwimlaneLaneResizeDraft {
+    containerId: string;
+    laneId: string;
+    size: number;
+}
+export declare function resolveBoardSwimlaneLaneResizeHandles(container: IBoardContainerElement, outerBounds: IBoardRect, options?: IResolveBoardSwimlaneLaneResizeHandlesOptions): IBoardSwimlaneLaneResizeHandle[];
+export declare function resolveBoardSwimlaneLaneResizeDraft(handle: IBoardSwimlaneLaneResizeHandle, point: IBoardConnectorPoint): IBoardSwimlaneLaneResizeDraft;

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

@@ -0,0 +1,40 @@
+import type { BoardModel, IBoardElementData, IBoardElementService } from '@univerjs-pro/boards';
+import type { BoardViewShortcutAction } from '../common/board-shortcuts';
+import type { IResolvedBoardInteractionConfig } from './board-interaction-config.util';
+import type { IBoardViewportPoint, IBoardViewportSize, IBoardViewportTransform } from './board-viewport.util';
+interface IBoardViewShortcutContext {
+    unitId: string;
+    subUnitId: string;
+}
+interface IBoardViewShortcutStateService {
+    setZoomRatioAtViewportPoint: (zoomRatio: number, viewportPoint: IBoardViewportPoint) => void;
+    setViewportTransform: (viewport: IBoardViewportTransform) => void;
+}
+interface IBoardViewShortcutViewportService {
+    fitContent: (boardModel: BoardModel, options: {
+        viewportSize: IBoardViewportSize;
+        padding: number;
+        zoom: IResolvedBoardInteractionConfig;
+    }) => void;
+}
+export interface IApplyBoardViewShortcutOptions {
+    action: BoardViewShortcutAction;
+    boardModel: BoardModel;
+    boardContext?: IBoardViewShortcutContext | null;
+    selectedIds: string[];
+    boardElementService: Pick<IBoardElementService, 'getElementData'> | {
+        getElementData: (unitId: string, subUnitId: string) => Record<string, IBoardElementData>;
+    };
+    stateService: IBoardViewShortcutStateService;
+    viewportService: IBoardViewShortcutViewportService;
+    interactionConfig: IResolvedBoardInteractionConfig;
+    viewportSize: IBoardViewportSize;
+    viewportCenterPoint: IBoardViewportPoint;
+    preventDefault: () => void;
+    dispatchEvent?: (event: Event) => void;
+    requestFullscreen?: () => void | Promise<void>;
+    exitFullscreen?: () => void | Promise<void>;
+    getFullscreenElement?: () => unknown;
+}
+export declare function applyBoardViewShortcut(options: IApplyBoardViewShortcutOptions): boolean;
+export {};

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

@@ -0,0 +1,35 @@
+import type { IResolvedBoardInteractionConfig } from './board-interaction-config.util';
+import type { IBoardViewportPoint } from './board-viewport.util';
+export declare const BOARD_WHEEL_LINE_HEIGHT = 16;
+export declare const BOARD_WHEEL_PAGE_HEIGHT = 800;
+export declare const BOARD_WHEEL_ZOOM_DELTA_BASE = 100;
+export interface IBoardWheelEventLike {
+    clientX: number;
+    clientY: number;
+    ctrlKey?: boolean;
+    deltaMode?: number;
+    deltaX: number;
+    deltaY: number;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+}
+export interface IBoardViewportInputRect {
+    left: number;
+    top: number;
+}
+export type IBoardWheelViewportAction = {
+    type: 'none';
+} | {
+    type: 'pan';
+    delta: IBoardViewportPoint;
+} | {
+    type: 'zoomAtPoint';
+    viewportPoint: IBoardViewportPoint;
+    zoomFactor: number;
+};
+export interface IResolveBoardWheelViewportActionOptions {
+    event: IBoardWheelEventLike;
+    interactionConfig: Pick<IResolvedBoardInteractionConfig, 'trackpadPanEnabled' | 'wheelPanFactor' | 'wheelZoomFactor' | 'wheelZoomWithModifier' | 'zoomWheelFactor'>;
+    viewportRect: IBoardViewportInputRect;
+}
+export declare function resolveBoardWheelViewportAction({ event, interactionConfig, viewportRect, }: IResolveBoardWheelViewportActionOptions): IBoardWheelViewportAction;

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

@@ -0,0 +1,45 @@
+import type { CSSProperties } from 'react';
+export declare const BOARD_MIN_ZOOM_RATIO = 0.1;
+export declare const BOARD_MAX_ZOOM_RATIO = 4;
+export interface IBoardViewportPoint {
+    x: number;
+    y: number;
+}
+export interface IBoardViewportTransform {
+    zoomRatio: number;
+    panOffset: IBoardViewportPoint;
+}
+export interface IBoardViewportRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface IBoardViewportSize {
+    width: number;
+    height: number;
+}
+export interface IBoardViewportZoomConfig {
+    maxZoomRatio?: number;
+    minZoomRatio?: number;
+}
+export interface IResolveBoardViewportZoomAtPointOptions {
+    viewport: IBoardViewportTransform;
+    nextZoomRatio: number;
+    viewportPoint: IBoardViewportPoint;
+    zoom?: IBoardViewportZoomConfig;
+}
+export interface IResolveBoardViewportFitRectOptions {
+    rect: IBoardViewportRect;
+    viewportSize: IBoardViewportSize;
+    padding?: number;
+    zoom?: IBoardViewportZoomConfig;
+}
+export declare function clampBoardZoomRatio(zoomRatio: number, config?: IBoardViewportZoomConfig): number;
+export declare function resolveBoardViewportZoomAtPoint(options: IResolveBoardViewportZoomAtPointOptions): IBoardViewportTransform;
+export declare function resolveBoardViewportFitRect(options: IResolveBoardViewportFitRectOptions): IBoardViewportTransform;
+export declare function getBoardPointFromClient(element: HTMLElement, clientX: number, clientY: number, viewport: IBoardViewportTransform, zoom?: IBoardViewportZoomConfig): {
+    x: number;
+    y: number;
+};
+export declare function createBoardViewportRectStyle(rect: IBoardViewportRect, viewport: IBoardViewportTransform, zoom?: IBoardViewportZoomConfig): CSSProperties;

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

@@ -0,0 +1 @@
+export declare function BoardCanvasView(): import("react").JSX.Element;

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

@@ -0,0 +1,17 @@
+import type { IBoardConnectorStyle } from '@univerjs-pro/boards';
+import type { IShapeData } from '@univerjs-pro/engine-shape';
+export declare const BOARD_CONNECTOR_FLOATING_TOOLBAR_KEY = "board.connector.floating-toolbar";
+interface IBoardConnectorFloatingToolbarExtraProps {
+    unitId: string;
+    subUnitId: string;
+    elementId: string;
+}
+interface IBoardConnectorFloatingToolbarProps {
+    popup: {
+        extraProps?: IBoardConnectorFloatingToolbarExtraProps;
+    };
+}
+export declare function connectorStyleToShapeStrokeData(style: IBoardConnectorStyle): IShapeData;
+export declare function shapeStrokeToBoardConnectorStylePatch(shapeData?: IShapeData): Partial<IBoardConnectorStyle>;
+export declare function BoardConnectorFloatingToolbar({ popup }: IBoardConnectorFloatingToolbarProps): import("react").JSX.Element | null;
+export {};

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

@@ -0,0 +1,12 @@
+import type { BoardShapeType } from '@univerjs-pro/boards';
+export declare const BOARD_CONNECTOR_QUICK_SHAPE_MENU_KEY = "board.connector.quick-shape-menu";
+interface IBoardConnectorQuickShapeMenuExtraProps {
+    onSelect?: (shapeType: BoardShapeType | string) => void;
+}
+interface IBoardConnectorQuickShapeMenuProps {
+    popup: {
+        extraProps?: IBoardConnectorQuickShapeMenuExtraProps;
+    };
+}
+export declare function BoardConnectorQuickShapeMenu({ popup }: IBoardConnectorQuickShapeMenuProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+export interface IBoardContainerRenamePopupProps {
+    initialTitle: string;
+    onCancel: () => void;
+    onSubmit: (title: string) => void | Promise<void>;
+}
+export declare function BoardContainerRenamePopup(props: IBoardContainerRenamePopupProps): import("react").JSX.Element;

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

@@ -0,0 +1,8 @@
+import type { BoardModel } from '@univerjs-pro/boards';
+import type { IBoardViewportTransform, IBoardViewportZoomConfig } from '../utils/board-viewport.util';
+export interface IBoardDomLayerViewProps {
+    boardModel: BoardModel | null | undefined;
+    interactionConfig: IBoardViewportZoomConfig;
+    viewportTransform: IBoardViewportTransform;
+}
+export declare function BoardDomLayerView({ boardModel, interactionConfig, viewportTransform, }: IBoardDomLayerViewProps): import("react").JSX.Element | null;

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

@@ -0,0 +1 @@
+export declare function BoardFloatingPanelLayer(): import("react").JSX.Element;

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

@@ -0,0 +1,98 @@
+import type { LocaleKey } from '../locale/types';
+import type { BoardMindMapTemplateThumbnailVariant } from './BoardMindMapTemplateThumbnailIcon';
+import { BoardToolType } from '@univerjs-pro/boards';
+type BoardMindMapPresetStructureKind = 'mindmap-horizontal' | 'mindmap-vertical' | 'tree-right' | 'tree-left' | 'tree-alternate' | 'timeline-horizontal' | 'timeline-vertical';
+interface IBoardMindMapPresetChild {
+    text?: string;
+    orderKey?: string;
+    side?: 'left' | 'right' | 'top' | 'bottom';
+    collapsed?: boolean;
+    branchColorKey?: string;
+    foreignAttributes?: Record<string, string>;
+}
+interface IBoardMindMapPresetBlueprintNode {
+    text?: string;
+    orderKey?: string;
+    side?: 'left' | 'right' | 'top' | 'bottom';
+    collapsed?: boolean;
+    branchColorKey?: string;
+    foreignAttributes?: Record<string, string>;
+    children: IBoardMindMapPresetBlueprintNode[];
+}
+interface IResolvedBoardMindMapPresetBlueprintNode extends Omit<IBoardMindMapPresetBlueprintNode, 'children' | 'text'> {
+    text: string;
+    children: IResolvedBoardMindMapPresetBlueprintNode[];
+}
+interface IBoardMindMapInsertPreset {
+    key: string;
+    thumbnail: BoardMindMapTemplateThumbnailVariant;
+    labelKey: LocaleKey;
+    structureKind: BoardMindMapPresetStructureKind;
+    children: IBoardMindMapPresetChild[];
+    blueprint?: {
+        title?: string;
+        root: IBoardMindMapPresetBlueprintNode;
+    };
+}
+interface IBoardMindMapTemplateGroup {
+    key: string;
+    labelKey: LocaleKey;
+    presets: IBoardMindMapInsertPreset[];
+}
+export declare const BOARD_MIND_MAP_TEMPLATE_GROUPS: IBoardMindMapTemplateGroup[];
+export declare function resolveMindMapPresetInsertTemplate(preset: IBoardMindMapInsertPreset, nodeText: string): {
+    structureKind: BoardMindMapPresetStructureKind;
+    children: {
+        text: string;
+        orderKey?: string;
+        side?: "left" | "right" | "top" | "bottom";
+        collapsed?: boolean;
+        branchColorKey?: string;
+        foreignAttributes?: Record<string, string>;
+    }[];
+    blueprint: {
+        title: string | undefined;
+        root: IResolvedBoardMindMapPresetBlueprintNode;
+    } | undefined;
+};
+declare const BOARD_CONTAINER_PRESETS: readonly [{
+    readonly key: "custom";
+    readonly labelKey: "boards-ui.panel.customContainer";
+    readonly width: 720;
+    readonly height: 405;
+    readonly variant: "custom";
+}, {
+    readonly key: "16-9";
+    readonly labelKey: "boards-ui.panel.containerRatio16By9";
+    readonly width: 720;
+    readonly height: 405;
+    readonly variant: "wide";
+}, {
+    readonly key: "4-3";
+    readonly labelKey: "boards-ui.panel.containerRatio4By3";
+    readonly width: 630;
+    readonly height: 472.5;
+    readonly variant: "standard";
+}, {
+    readonly key: "1-1";
+    readonly labelKey: "boards-ui.panel.containerRatio1By1";
+    readonly width: 495;
+    readonly height: 495;
+    readonly variant: "square";
+}, {
+    readonly key: "a4";
+    readonly labelKey: "boards-ui.panel.containerA4";
+    readonly width: 472.5;
+    readonly height: 668.25;
+    readonly variant: "a4";
+}];
+export declare function ContainerPresetThumbnail({ variant }: {
+    variant: typeof BOARD_CONTAINER_PRESETS[number]['variant'];
+}): import("react").JSX.Element;
+export declare function SwimlanePresetIcon({ orientation }: {
+    orientation: 'vertical' | 'horizontal';
+}): import("react").JSX.Element;
+export declare function BoardFloatingToolPanelContent(props: {
+    activePanelTool: BoardToolType;
+}): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1 @@
+export declare function BoardLeftToolbar(): import("react").JSX.Element | null;

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

@@ -0,0 +1 @@
+export declare function BoardMermaidImportDialog(): import("react").JSX.Element | null;

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

@@ -0,0 +1,8 @@
+import type { SVGProps } from 'react';
+export declare const BOARD_MIND_MAP_TEMPLATE_THUMBNAIL_VARIANTS: readonly ["mindmap-right", "mindmap-left", "mindmap-vertical", "mindmap-horizontal", "tree-right", "tree-left", "tree-alternate", "timeline-horizontal", "timeline-vertical"];
+export type BoardMindMapTemplateThumbnailVariant = typeof BOARD_MIND_MAP_TEMPLATE_THUMBNAIL_VARIANTS[number];
+interface IBoardMindMapTemplateThumbnailIconProps extends SVGProps<SVGSVGElement> {
+    variant: BoardMindMapTemplateThumbnailVariant;
+}
+export declare function BoardMindMapTemplateThumbnailIcon(props: IBoardMindMapTemplateThumbnailIconProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1 @@
+export declare function BoardObjectListPanel(): import("react").JSX.Element | null;

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

@@ -0,0 +1,2 @@
+export declare const BOARD_TOP_RIGHT_MENU_LEADING_PART = "board.top-right-menu.leading";
+export declare function BoardSettingsMenu(): import("react").JSX.Element;

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

@@ -0,0 +1,16 @@
+import type { IShapeData, ShapeTypeEnum } from '@univerjs-pro/engine-shape';
+export declare const BOARD_SHAPE_FLOATING_TOOLBAR_KEY = "board.shape.floating-toolbar";
+interface IBoardShapeFloatingToolbarExtraProps {
+    unitId: string;
+    subUnitId: string;
+    elementId: string;
+    shapeType?: ShapeTypeEnum;
+    shapeData?: IShapeData;
+}
+interface IBoardShapeFloatingToolbarProps {
+    popup: {
+        extraProps?: IBoardShapeFloatingToolbarExtraProps;
+    };
+}
+export declare function BoardShapeFloatingToolbar(props: IBoardShapeFloatingToolbarProps): import("react").JSX.Element | null;
+export {};

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

@@ -0,0 +1 @@
+export declare function BoardShapePanel(): import("react").JSX.Element | null;

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

@@ -0,0 +1,24 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { ICustomShapeTextData, IShapeRect } from '@univerjs-pro/engine-shape';
+import type { ITransformState, Nullable } from '@univerjs/core';
+import { IRenderManagerService } from '@univerjs/engine-render';
+export declare const BoardShapeTextEditorContainer: import("react").MemoExoticComponent<() => import("react").JSX.Element>;
+export declare function resolveBoardShapeTextEditorTransform(options: {
+    elementData: IBoardElementData | undefined;
+    elementDataMap?: Record<string, IBoardElementData>;
+    renderManagerService: IRenderManagerService;
+    shapeId: string;
+    unitId: string;
+}): Nullable<ITransformState>;
+export declare function shouldAllowBoardShapeTextHostShrink(elementData: IBoardElementData | undefined): boolean;
+export declare function shouldDeferBoardShapeTextHostSizeUpdateDuringEditing(elementData: IBoardElementData | undefined): boolean;
+export declare function previewBoardShapeTextHostSize(options: {
+    elementData: IBoardElementData;
+    height: number;
+    renderManagerService: IRenderManagerService;
+    unitId: string;
+    width: number;
+}): boolean;
+export declare function getBoardShapeTextEditingContentStyle(_elementData: IBoardElementData | undefined): undefined;
+export declare function resolveBoardConnectorLabelTextEditorRect(rect: IShapeRect): IShapeRect;
+export declare function resolveBoardShapeTextData(elementData: IBoardElementData): ICustomShapeTextData;

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

@@ -0,0 +1 @@
+export declare function BoardShapeTextFloatToolbar(): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export declare function BoardShortcutHelpDrawer(): import("react").JSX.Element;

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

@@ -0,0 +1,6 @@
+export interface IBoardSwimlaneLaneRenamePopupProps {
+    initialTitle: string;
+    onCancel: () => void;
+    onSubmit: (title: string) => void | Promise<void>;
+}
+export declare function BoardSwimlaneLaneRenamePopup(props: IBoardSwimlaneLaneRenamePopupProps): import("react").JSX.Element;

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

@@ -0,0 +1,18 @@
+export interface IBoardTableSize {
+    rows: number;
+    columns: number;
+}
+export interface IBoardTableSizePickerProps {
+    initialRows?: number;
+    initialColumns?: number;
+    maxGridRows?: number;
+    maxGridColumns?: number;
+    minRows?: number;
+    minColumns?: number;
+    maxRows?: number;
+    maxColumns?: number;
+    direction?: 'ltr' | 'rtl';
+    onConfirm: (size: IBoardTableSize) => void;
+}
+export declare function normalizeBoardTableSizeValue(value: number, min: number, max: number): number;
+export declare function BoardTableSizePicker(props: IBoardTableSizePickerProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export declare function BoardWorkbench(): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export declare function BoardZoomControls(): import("react").JSX.Element;

package/lib/types/views/board-floating-panel-layout.d.ts

@@ -0,0 +1,33 @@
+export declare const BOARD_FLOATING_DRAWER_RIGHT = 20;
+export declare const BOARD_FLOATING_DRAWER_GAP = 20;
+export declare const BOARD_FLOATING_DRAWER_WIDTH = 388;
+export declare const BOARD_FLOATING_DRAWER_MIN_WIDTH = 320;
+export declare const BOARD_FLOATING_DRAWER_MAX_WIDTH = 420;
+export declare const BOARD_FLOATING_DRAWER_Z_INDEX = 19;
+export interface IBoardFloatingPanelReservedRect {
+    bottom: number;
+    left: number;
+    right: number;
+    top: number;
+}
+export interface IBoardFloatingPanelViewportRect {
+    height: number;
+    width: number;
+}
+export interface IBoardFloatingPanelLayoutInput {
+    bottomControlRect?: IBoardFloatingPanelReservedRect | null;
+    direction?: 'ltr' | 'rtl';
+    leftToolbarRect?: IBoardFloatingPanelReservedRect | null;
+    maxWidth?: number;
+    minWidth?: number;
+    preferredWidth?: number;
+    topControlRect?: IBoardFloatingPanelReservedRect | null;
+    viewportRect: IBoardFloatingPanelViewportRect;
+}
+export interface IBoardFloatingPanelLayout {
+    bottom: number;
+    right: number;
+    top: number;
+    width: number;
+}
+export declare function resolveBoardFloatingPanelLayout(input: IBoardFloatingPanelLayoutInput): IBoardFloatingPanelLayout;

package/lib/types/views/use-board-palette-pending-insert-drag.d.ts

@@ -0,0 +1,9 @@
+import type { MouseEvent, PointerEvent } from 'react';
+export interface IUseBoardPalettePendingInsertDragOptions {
+    beginDrag: () => void;
+    cancelDrag: () => void;
+}
+export declare function useBoardPalettePendingInsertDrag(options: IUseBoardPalettePendingInsertDragOptions): {
+    onClickCapture: (event: MouseEvent<HTMLElement>) => void;
+    onPointerDown: (event: PointerEvent<HTMLElement>) => void;
+};

package/lib/types/views/use-board-panel-outside-pointer-down.d.ts

@@ -0,0 +1,5 @@
+import type { RefObject } from 'react';
+export interface IBoardPanelOutsidePointerDownOptions {
+    ignoreSelectors?: string[];
+}
+export declare function useBoardPanelOutsidePointerDown(panelRef: RefObject<HTMLElement | null>, enabled: boolean, onOutsidePointerDown: () => void, options?: IBoardPanelOutsidePointerDownOptions): void;