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

package/lib/types/utils/board-connector-waypoint.util.d.ts

@@ -0,0 +1,71 @@
+import type { IBoardConnectorElement, IBoardConnectorPoint, IBoardElementData } from '@univerjs-pro/boards';
+export type BoardConnectorEditableSegmentOrientation = 'horizontal' | 'vertical';
+export interface IBoardConnectorEditableSegment {
+    connectorId: string;
+    segmentIndex: number;
+    segmentEndIndex?: number;
+    orientation: BoardConnectorEditableSegmentOrientation;
+    start: IBoardConnectorPoint;
+    end: IBoardConnectorPoint;
+    point: IBoardConnectorPoint;
+}
+export interface IBoardConnectorManualWaypointHandle {
+    connectorId: string;
+    waypointId: string;
+    waypointIndex: number;
+    point: IBoardConnectorPoint;
+}
+export interface IBoardConnectorCurveAnchorHandle {
+    connectorId: string;
+    kind: 'anchor' | 'insert';
+    segmentIndex: number;
+    point: IBoardConnectorPoint;
+    anchorId?: string;
+    anchorIndex?: number;
+}
+export interface IResolveBoardConnectorEditableSegmentsOptions {
+    elementData?: Record<string, IBoardElementData>;
+    connectorId?: string;
+    minSegmentLength?: number;
+    routePoints?: readonly IBoardConnectorPoint[];
+}
+export interface IResolveBoardConnectorSegmentDragUpdateOptions extends IResolveBoardConnectorEditableSegmentsOptions {
+    element: IBoardConnectorElement;
+    segmentIndex: number;
+    segmentEndIndex?: number;
+    delta: IBoardConnectorPoint;
+}
+export interface IResolveBoardConnectorInsertWaypointUpdateOptions extends IResolveBoardConnectorEditableSegmentsOptions {
+    element: IBoardConnectorElement;
+    point: IBoardConnectorPoint;
+    tolerance: number;
+}
+export interface IResolveBoardConnectorWaypointDragUpdateOptions extends IResolveBoardConnectorEditableSegmentsOptions {
+    element: IBoardConnectorElement;
+    waypointId: string;
+    point: IBoardConnectorPoint;
+    cleanupCollinear?: boolean;
+}
+export interface IResolveBoardConnectorRemoveWaypointUpdateOptions extends IResolveBoardConnectorEditableSegmentsOptions {
+    element: IBoardConnectorElement;
+    waypointId: string;
+}
+export interface IResolveBoardConnectorCurveAnchorDragUpdateOptions extends IResolveBoardConnectorEditableSegmentsOptions {
+    element: IBoardConnectorElement;
+    handle: IBoardConnectorCurveAnchorHandle;
+    point: IBoardConnectorPoint;
+}
+export interface IResolveBoardConnectorRemoveCurveAnchorUpdateOptions extends IResolveBoardConnectorEditableSegmentsOptions {
+    element: IBoardConnectorElement;
+    anchorId: string;
+}
+export declare function cleanupBoardConnectorCollinearPoints(points: readonly IBoardConnectorPoint[]): IBoardConnectorPoint[];
+export declare function resolveBoardConnectorEditableSegments(element: IBoardConnectorElement, options?: IResolveBoardConnectorEditableSegmentsOptions): IBoardConnectorEditableSegment[];
+export declare function resolveBoardConnectorManualWaypointHandles(element: IBoardConnectorElement): IBoardConnectorManualWaypointHandle[];
+export declare function resolveBoardConnectorCurveAnchorHandles(element: IBoardConnectorElement, options?: IResolveBoardConnectorEditableSegmentsOptions): IBoardConnectorCurveAnchorHandle[];
+export declare function resolveBoardConnectorCurveAnchorDragUpdate(options: IResolveBoardConnectorCurveAnchorDragUpdateOptions): IBoardConnectorElement;
+export declare function resolveBoardConnectorRemoveCurveAnchorUpdate(options: IResolveBoardConnectorRemoveCurveAnchorUpdateOptions): IBoardConnectorElement;
+export declare function resolveBoardConnectorSegmentDragUpdate(options: IResolveBoardConnectorSegmentDragUpdateOptions): IBoardConnectorElement;
+export declare function resolveBoardConnectorInsertWaypointUpdate(options: IResolveBoardConnectorInsertWaypointUpdateOptions): IBoardConnectorElement | null;
+export declare function resolveBoardConnectorWaypointDragUpdate(options: IResolveBoardConnectorWaypointDragUpdateOptions): IBoardConnectorElement;
+export declare function resolveBoardConnectorRemoveWaypointUpdate(options: IResolveBoardConnectorRemoveWaypointUpdateOptions): IBoardConnectorElement;

package/lib/types/utils/board-container-membership-overlay.util.d.ts

@@ -0,0 +1,19 @@
+import type { IBoardElementData, IBoardElementTransform, IBoardRect } from '@univerjs-pro/boards';
+import type { IBoardElementSpatialIndex } from './board-container-spatial-index.util';
+export type BoardContainerMembershipOverlayState = 'retained' | 'capture' | 'expel' | 'autosize';
+export interface IBoardContainerMembershipOverlayItem {
+    elementId: string;
+    containerId: string;
+    state: BoardContainerMembershipOverlayState;
+    bounds: IBoardRect;
+    forced?: boolean;
+}
+export interface IResolveBoardContainerMembershipOverlayOptions {
+    elementData: Record<string, IBoardElementData>;
+    elementOrder?: readonly string[];
+    activeElementIds: readonly string[];
+    forceCaptureElementIds?: readonly string[];
+    previewWorldTransforms?: Record<string, IBoardElementTransform>;
+    spatialIndex?: IBoardElementSpatialIndex;
+}
+export declare function resolveBoardContainerMembershipOverlay(options: IResolveBoardContainerMembershipOverlayOptions): IBoardContainerMembershipOverlayItem[];

package/lib/types/utils/board-container-membership-update.util.d.ts

@@ -0,0 +1,10 @@
+import type { IBoardElementData, IUpdateBoardElementsOperationItem } from '@univerjs-pro/boards';
+import type { IBoardElementSpatialIndex } from './board-container-spatial-index.util';
+export interface IResolveBoardContainerMembershipUpdateItemsOptions {
+    elementData: Record<string, IBoardElementData>;
+    elementOrder?: readonly string[];
+    updates: readonly IUpdateBoardElementsOperationItem[];
+    forceCaptureElementIds?: readonly string[];
+    spatialIndex?: IBoardElementSpatialIndex;
+}
+export declare function resolveBoardContainerMembershipUpdateItems(options: IResolveBoardContainerMembershipUpdateItemsOptions): IUpdateBoardElementsOperationItem[];

package/lib/types/utils/board-container-spatial-index.util.d.ts

@@ -0,0 +1,16 @@
+import type { IBoardElementData, IBoardRect } from '@univerjs-pro/boards';
+export interface IBoardPoint {
+    x: number;
+    y: number;
+}
+export interface ICreateBoardElementSpatialIndexOptions {
+    unitId: string;
+    subUnitId: string;
+    elementData: Record<string, IBoardElementData>;
+}
+export interface IBoardElementSpatialIndex {
+    queryIntersecting(bounds: IBoardRect): string[];
+    queryContainersAtPoint(point: IBoardPoint): string[];
+    dispose(): void;
+}
+export declare function createBoardElementSpatialIndex(options: ICreateBoardElementSpatialIndexOptions): IBoardElementSpatialIndex;

package/lib/types/utils/board-container-target.util.d.ts

@@ -0,0 +1,17 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IBoardElementSpatialIndex, IBoardPoint } from './board-container-spatial-index.util';
+import { BoardElementType } from '@univerjs-pro/boards';
+export interface IBoardContainerTarget {
+    containerId: string;
+    depth: number;
+}
+export interface IResolveBoardContainerTargetAtPointOptions {
+    elementData: Record<string, IBoardElementData>;
+    elementOrder: readonly string[];
+    point: IBoardPoint;
+    activeElementIds?: readonly string[];
+    activeElementTypes?: Record<string, BoardElementType | string>;
+    allowCaptureFromParentedCandidateIds?: readonly string[];
+    spatialIndex?: IBoardElementSpatialIndex;
+}
+export declare function resolveBoardContainerTargetAtPoint(options: IResolveBoardContainerTargetAtPointOptions): IBoardContainerTarget | null;

package/lib/types/utils/board-container-title-label.util.d.ts

@@ -0,0 +1,20 @@
+import type { IBoardContainerElement, IBoardElementData, IBoardRect } from '@univerjs-pro/boards';
+export declare const BOARD_CONTAINER_TITLE_LABEL_HEIGHT = 18;
+export declare const BOARD_CONTAINER_TITLE_LABEL_GAP = 8;
+export declare const BOARD_CONTAINER_TITLE_LABEL_PADDING_X = 5;
+export declare const BOARD_CONTAINER_TITLE_LABEL_PADDING_Y = 3;
+export declare const BOARD_CONTAINER_TITLE_LABEL_FILL = "rgba(248, 250, 252, 0.98)";
+export declare const BOARD_CONTAINER_TITLE_LABEL_STROKE = "rgba(148, 163, 184, 0.95)";
+export declare const BOARD_CONTAINER_TITLE_LABEL_TEXT = "rgba(31, 41, 55, 0.92)";
+export declare const BOARD_CONTAINER_TITLE_LABEL_HIT_TEXT_WIDTH_FACTOR = 8;
+export declare const BOARD_CONTAINER_TITLE_LABEL_DEFAULT_FONT_SIZE = 12;
+export declare function resolveBoardGenericContainerTitleFontSize(element: IBoardElementData['element']): number;
+export declare function resolveBoardGenericContainerTitleLabelHeight(element: IBoardElementData['element']): number;
+export declare function isGenericBoardContainerElement(element: IBoardElementData['element']): element is IBoardContainerElement;
+export declare function resolveBoardGenericContainerTitle(element: IBoardElementData['element']): string;
+export declare function resolveBoardGenericContainerTitleLabelBounds(element: IBoardElementData['element'], bounds: Pick<IBoardRect, 'left' | 'top' | 'width'>, measuredTextWidth?: number): IBoardRect | null;
+export declare function resolveBoardGenericContainerTitleLabelWorldBounds(elementData: Record<string, IBoardElementData>, elementId: string): IBoardRect | null;
+export declare function containsBoardContainerTitleLabelPoint(bounds: IBoardRect | null, point: {
+    x: number;
+    y: number;
+}): boolean;

package/lib/types/utils/board-container-toolbar.util.d.ts

@@ -0,0 +1,40 @@
+import type { IBoardContainerElement, IBoardElementData, IBoardSwimlaneData } from '@univerjs-pro/boards';
+import type { IBoardFocusedSwimlaneLane } from '../services/board-element-state.service';
+export interface IBoardContainerToolbarSwimlaneActionOptions {
+    createId?: () => string;
+    insertIndex?: number;
+}
+export interface IBoardContainerToolbarSwimlaneAction {
+    containerId: string;
+    addLane: IBoardSwimlaneData['lanes'][number];
+    insertIndex: number;
+}
+export interface IBoardContainerToolbarSwimlaneLaneActionOptions {
+    defaultToFirstLane?: boolean;
+    elementData?: Record<string, IBoardElementData>;
+}
+export interface IBoardContainerToolbarSwimlaneLaneActions {
+    containerId: string;
+    laneId: string;
+    title: string;
+    index: number;
+    laneCount: number;
+    collapsed: boolean;
+    locked: boolean;
+    hasChildren: boolean;
+    canAddAfter: boolean;
+    canRemove: boolean;
+    canRemoveAndPromote: boolean;
+    canRemoveAndDeleteContent: boolean;
+    canMovePrevious: boolean;
+    canMoveNext: boolean;
+    canRename: boolean;
+    canToggleCollapsed: boolean;
+    removeAndMovePreviousLaneId?: string;
+    removeAndMoveNextLaneId?: string;
+    canRemoveAndMovePrevious: boolean;
+    canRemoveAndMoveNext: boolean;
+}
+export declare function canMoveSelectedElementsOutOfContainer(elementData: Record<string, IBoardElementData>, selectedIds: readonly string[]): boolean;
+export declare function resolveBoardContainerToolbarSwimlaneAction(container: IBoardContainerElement | null | undefined, options?: IBoardContainerToolbarSwimlaneActionOptions): IBoardContainerToolbarSwimlaneAction | null;
+export declare function resolveBoardContainerToolbarSwimlaneLaneActions(container: IBoardContainerElement | null | undefined, focusedLane: IBoardFocusedSwimlaneLane | null | undefined, options?: IBoardContainerToolbarSwimlaneLaneActionOptions): IBoardContainerToolbarSwimlaneLaneActions | null;

package/lib/types/utils/board-draft-insert-position.util.d.ts

@@ -0,0 +1,13 @@
+export interface IBoardDraftInsertRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface IResolveBoardDraftInsertPositionOptions {
+    draftBounds?: Partial<IBoardDraftInsertRect> | null;
+    existingRects?: IBoardDraftInsertRect[];
+    preferredPosition?: Pick<IBoardDraftInsertRect, 'left' | 'top'>;
+    gap?: number;
+}
+export declare function resolveBoardDraftInsertPosition(options: IResolveBoardDraftInsertPositionOptions): Pick<IBoardDraftInsertRect, 'left' | 'top'>;

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

@@ -0,0 +1,25 @@
+import type { IBoardElementData, IBoardTableSearchEntry } from '@univerjs-pro/boards';
+export interface IFindBoardElementsOptions {
+    query: string;
+    elementData: Record<string, IBoardElementData>;
+    elementOrder: string[];
+    tableSearchEntries?: Record<string, readonly IBoardTableSearchEntry[]>;
+    localeTexts: IBoardFindLocaleTexts;
+}
+export interface IBoardElementFindResult {
+    resultId?: string;
+    elementId: string;
+    subId?: string;
+    kind?: BoardElementFindResultKind;
+    title: string;
+    description: string;
+}
+export type BoardElementFindResultKind = 'element' | 'connector-label' | 'container-title' | 'swimlane-lane-title' | 'table-cell';
+export interface IBoardFindLocaleTexts {
+    elementTypes: Record<string, string>;
+    shapePresets: Record<string, string>;
+    lanePositionLabels: Record<number, string>;
+    tableCellPositionLabels: Record<string, string>;
+}
+export declare function collectBoardFindStaticLocaleKeys(): string[];
+export declare function findBoardElements(options: IFindBoardElementsOptions): IBoardElementFindResult[];

package/lib/types/utils/board-floating-toolbar-anchor.util.d.ts

@@ -0,0 +1,2 @@
+import type { BaseObject, IBoundRectNoAngle } from '@univerjs/engine-render';
+export declare function resolveRotatedBoardObjectAnchorBound(targetObject: BaseObject): IBoundRectNoAngle;

package/lib/types/utils/board-free-polyline-draft.util.d.ts

@@ -0,0 +1,24 @@
+import type { BoardConnectorRouting, BoardConnectorRoutingMode, IBoardConnectorEndpoint, IBoardConnectorPoint, IBoardConnectorWaypoint } from '@univerjs-pro/boards';
+export interface IBoardResolvedConnectorEndpoint {
+    endpoint: IBoardConnectorEndpoint;
+    point: IBoardConnectorPoint;
+}
+export interface IBoardFreePolylineDraft {
+    startEndpoint: IBoardConnectorEndpoint;
+    startPoint: IBoardConnectorPoint;
+    currentEndpoint: IBoardConnectorEndpoint;
+    currentPoint: IBoardConnectorPoint;
+    points: IBoardConnectorPoint[];
+}
+export interface IBoardFreePolylineConnectorOptions {
+    start: IBoardConnectorEndpoint;
+    end: IBoardConnectorEndpoint;
+    routing: Extract<BoardConnectorRouting, 'freePolyline'>;
+    routingMode: BoardConnectorRoutingMode;
+    waypoints: IBoardConnectorWaypoint[];
+}
+export declare function createBoardFreePolylineDraft(resolved: IBoardResolvedConnectorEndpoint): IBoardFreePolylineDraft;
+export declare function updateBoardFreePolylineDraftCurrent(draft: IBoardFreePolylineDraft, resolved: IBoardResolvedConnectorEndpoint): IBoardFreePolylineDraft;
+export declare function appendBoardFreePolylineDraftPoint(draft: IBoardFreePolylineDraft, resolved: IBoardResolvedConnectorEndpoint, threshold: number): IBoardFreePolylineDraft;
+export declare function removeBoardFreePolylineDraftLastPoint(draft: IBoardFreePolylineDraft): IBoardFreePolylineDraft;
+export declare function resolveBoardFreePolylineConnectorOptions(draft: IBoardFreePolylineDraft, connectorId: string): IBoardFreePolylineConnectorOptions;

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

@@ -0,0 +1,21 @@
+import type { IUniverBoardsUIConfig } from '../config/config';
+export interface IResolvedBoardGridConfig {
+    gridSize: number;
+    lineColor: string;
+    majorGridSize: number;
+    majorLineColor: string;
+}
+export interface IBoardGridRenderStep {
+    worldStep: number;
+    screenStep: number;
+    majorEvery: number;
+}
+export declare const BOARD_GRID_DEFAULT_CONFIG: IResolvedBoardGridConfig;
+export declare function resolveBoardGridConfig(config?: Pick<IUniverBoardsUIConfig, 'grid'>): IResolvedBoardGridConfig;
+export declare function resolveBoardGridRenderStep(options: {
+    gridSize: number;
+    majorGridSize: number;
+    zoomRatio: number;
+    minScreenStep?: number;
+    maxScreenStep?: number;
+}): IBoardGridRenderStep;

package/lib/types/utils/board-image-file.util.d.ts

@@ -0,0 +1,11 @@
+export interface IBoardImageLikeFile {
+    type?: string;
+}
+export interface IBoardDataTransferLikeItem {
+    kind?: string;
+    type?: string;
+    getAsFile?: () => IBoardImageLikeFile | null;
+}
+export declare function isBoardImageFile(file: IBoardImageLikeFile | null | undefined): file is IBoardImageLikeFile;
+export declare function getFirstBoardImageFile<T extends IBoardImageLikeFile>(files: Iterable<T | null | undefined>): T | null;
+export declare function getFirstBoardImageFileFromItems<T extends IBoardImageLikeFile = IBoardImageLikeFile>(items: Iterable<IBoardDataTransferLikeItem>): T | null;

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

@@ -0,0 +1,31 @@
+import type { IUniverBoardsUIConfig } from '../config/config';
+export declare const BOARD_IMAGE_INSERT_DEFAULT: {
+    fallbackWidth: number;
+    fallbackHeight: number;
+    minEdge: number;
+    fitRatio: number;
+    minPositionOffset: number;
+};
+export type IResolvedBoardImageInsertConfig = typeof BOARD_IMAGE_INSERT_DEFAULT;
+export interface IBoardImageSize {
+    width: number;
+    height: number;
+}
+export interface IBoardImageInsertPoint {
+    x: number;
+    y: number;
+}
+export declare function fitBoardImageSize(width: number, height: number, maxWidth: number, maxHeight: number, config?: IResolvedBoardImageInsertConfig): IBoardImageSize;
+export declare function resolveBoardImageInsertConfig(config?: Pick<IUniverBoardsUIConfig, 'insert'>): IResolvedBoardImageInsertConfig;
+export declare function createBoardCenteredImageTransform(pageWidth: number, pageHeight: number, size: IBoardImageSize, config?: IResolvedBoardImageInsertConfig): {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+export declare function createBoardImageTransformAtPoint(point: IBoardImageInsertPoint, size: IBoardImageSize): {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};

package/lib/types/utils/board-insert-config.util.d.ts

@@ -0,0 +1,32 @@
+import type { IUniverBoardsUIConfig } from '../config/config';
+export interface IResolvedBoardInsertConfig {
+    chart: {
+        height: number;
+        width: number;
+    };
+    table: {
+        cellHeight: number;
+        cellWidth: number;
+        columns: number;
+        height?: number;
+        minHeight: number;
+        minWidth: number;
+        rows: number;
+        width?: number;
+    };
+}
+export declare const BOARD_INSERT_DEFAULT_CONFIG: IResolvedBoardInsertConfig;
+export declare function resolveBoardInsertConfig(config?: Pick<IUniverBoardsUIConfig, 'insert'>): IResolvedBoardInsertConfig;
+export declare function resolveBoardTableInsertSize(options: {
+    cellHeight?: number;
+    cellWidth?: number;
+    columns: number;
+    height?: number;
+    minHeight?: number;
+    minWidth?: number;
+    rows: number;
+    width?: number;
+}): {
+    height: number;
+    width: number;
+};

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

@@ -0,0 +1,23 @@
+import type { IBoardPageElement } from '@univerjs-pro/boards';
+import type { IBoardPendingInsert } from '../services/board-ui-state.service';
+export interface IBoardInsertPoint {
+    x: number;
+    y: number;
+}
+export interface IBoardInsertRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export declare function resolveBoardContainerDragInsertRect(start: IBoardInsertPoint, end: IBoardInsertPoint): IBoardInsertRect;
+export declare function createBoardElementFromPendingInsert(options: {
+    pendingInsert: IBoardPendingInsert | null;
+    point: IBoardInsertPoint;
+    rect?: IBoardInsertRect | null;
+}): IBoardPageElement | null;
+export declare function resolveBoardPendingInsertPreviewRect(options: {
+    pendingInsert: IBoardPendingInsert | null;
+    point: IBoardInsertPoint;
+    rect?: IBoardInsertRect | null;
+}): IBoardInsertRect | null;

package/lib/types/utils/board-interaction-config.util.d.ts

@@ -0,0 +1,19 @@
+import type { IUniverBoardsUIConfig } from '../config/config';
+export interface IResolvedBoardInteractionConfig {
+    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 declare const BOARD_INTERACTION_DEFAULT_CONFIG: IResolvedBoardInteractionConfig;
+export declare function resolveBoardInteractionConfig(config?: Pick<IUniverBoardsUIConfig, 'interaction'>): IResolvedBoardInteractionConfig;

package/lib/types/utils/board-mermaid-preview.util.d.ts

@@ -0,0 +1,4 @@
+import type { IBoardImportDiagnostic, IBoardImportDraft } from '@univerjs-pro/boards';
+export declare const MAX_AUTO_MERMAID_PREVIEW_ELEMENTS = 300;
+export declare function shouldAutoRenderMermaidPreview(draft: IBoardImportDraft | null): boolean;
+export declare function areImportDiagnosticsEqual(left: IBoardImportDiagnostic[], right: IBoardImportDiagnostic[]): boolean;

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

@@ -0,0 +1,8 @@
+import type { IBoardElementData, IBoardElementSearch } from '@univerjs-pro/boards';
+export interface IResolveBoardRenderDirtyElementIdsOptions {
+    unitId: string;
+    subUnitId: string;
+    elementData: Record<string, IBoardElementData>;
+    updates: readonly IBoardElementSearch[];
+}
+export declare function resolveBoardRenderDirtyElementIds({ unitId, subUnitId, elementData, updates, }: IResolveBoardRenderDirtyElementIdsOptions): string[];

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

@@ -0,0 +1,19 @@
+import type { IBoardPage, IBoardPageSize } from '@univerjs-pro/boards';
+import type { IUniverBoardsUIConfig } from '../config/config';
+export declare const BOARD_RENDER_SCENE_DEFAULT_MIN_SIZE: IBoardPageSize;
+export declare const BOARD_RENDER_SCENE_DEFAULT_FALLBACK_FILL = "#ffffff";
+export declare const BOARD_RENDER_SCENE_DARK_FALLBACK_FILL = "#fcfdff";
+export interface IResolveBoardRenderSceneSizeOptions {
+    engineWidth?: number;
+    engineHeight?: number;
+    sceneWidth?: number;
+    sceneHeight?: number;
+    minSize?: IBoardPageSize;
+}
+export interface IResolveBoardPageBackgroundFillOptions {
+    darkMode?: boolean;
+    darkFallbackFill?: string;
+}
+export declare function resolveBoardPageBackgroundFill(page: Pick<IBoardPage, 'background'> | null | undefined, fallbackFill?: string, options?: IResolveBoardPageBackgroundFillOptions): string;
+export declare function resolveBoardRenderSceneMinSize(config?: Pick<IUniverBoardsUIConfig, 'scene'>): IBoardPageSize;
+export declare function resolveBoardRenderSceneSize({ engineWidth, engineHeight, sceneWidth, sceneHeight, minSize, }: IResolveBoardRenderSceneSizeOptions): IBoardPageSize;

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

@@ -0,0 +1,7 @@
+interface IBoardSceneObjectsEventAdapter {
+    disableObjectsEvent: () => void;
+    enableObjectsEvent: () => void;
+}
+export declare function setBoardSceneObjectsEventLock(scene: IBoardSceneObjectsEventAdapter, owner: string, locked: boolean): void;
+export declare function releaseBoardSceneObjectsEventLock(scene: IBoardSceneObjectsEventAdapter, owner: string): void;
+export {};

package/lib/types/utils/board-selection-delete.util.d.ts

@@ -0,0 +1,20 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+export interface IResolveBoardElementSelectionDeleteParamsOptions {
+    unitId: string;
+    subUnitId: string;
+    selectedIds: string[];
+    elementData: Record<string, IBoardElementData>;
+}
+export interface IBoardElementSelectionDeleteParam {
+    unitId: string;
+    subUnitId: string;
+    elementId: string;
+}
+export interface IBoardDeleteKeyboardEventLike {
+    key: string;
+    target: EventTarget | null;
+    defaultPrevented?: boolean;
+}
+export declare function isBoardEditableKeyboardTarget(target: EventTarget | null): boolean;
+export declare function isBoardDeleteKeyboardEvent(event: IBoardDeleteKeyboardEventLike): boolean;
+export declare function resolveBoardElementSelectionDeleteParams(options: IResolveBoardElementSelectionDeleteParamsOptions): IBoardElementSelectionDeleteParam[];

package/lib/types/utils/board-selection-geometry.util.d.ts

@@ -0,0 +1,31 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IBoardElementSpatialIndex } from './board-container-spatial-index.util';
+export interface IBoardSelectionRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface ISelectBoardElementsByRectOptions {
+    elementData: Record<string, IBoardElementData>;
+    elementOrder: string[];
+    rect: IBoardSelectionRect;
+    preciseSelection: boolean;
+    spatialIndex?: IBoardElementSpatialIndex;
+}
+export interface IResolveBoardElementsBoundsOptions {
+    elementData: Record<string, IBoardElementData>;
+    elementOrder: string[];
+    includeHidden?: boolean;
+}
+export interface IBoardElementSelectionResult {
+    unitId: string;
+    subUnitId: string;
+    elementId: string;
+    element: IBoardElementData['element'];
+    transform: IBoardElementData['transform'];
+}
+export declare function resolveBoardElementBounds(elementDataItem: IBoardElementData, elementData: Record<string, IBoardElementData>): IBoardSelectionRect;
+export declare function isBoardElementVisibleInTree(elementData: Record<string, IBoardElementData>, elementDataItem: IBoardElementData | undefined): elementDataItem is IBoardElementData;
+export declare function selectBoardElementsByRect(options: ISelectBoardElementsByRectOptions): IBoardElementSelectionResult[];
+export declare function resolveBoardElementsBounds(options: IResolveBoardElementsBoundsOptions): IBoardSelectionRect | null;

package/lib/types/utils/board-selection-hit-test.util.d.ts

@@ -0,0 +1,17 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IBoardElementSpatialIndex } from './board-container-spatial-index.util';
+import type { IBoardSelectionPoint } from './board-selection-interaction.util';
+export interface IHitTestBoardElementAtPointOptions {
+    elementData: Record<string, IBoardElementData>;
+    elementOrder: string[];
+    point: IBoardSelectionPoint;
+    spatialIndex?: IBoardElementSpatialIndex;
+}
+export interface IBoardElementHitTestResult {
+    unitId: string;
+    subUnitId: string;
+    elementId: string;
+    element: IBoardElementData['element'];
+    transform: IBoardElementData['transform'];
+}
+export declare function hitTestBoardElementAtPoint(options: IHitTestBoardElementAtPointOptions): IBoardElementHitTestResult | null;

package/lib/types/utils/board-selection-interaction.util.d.ts

@@ -0,0 +1,23 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IBoardElementSpatialIndex } from './board-container-spatial-index.util';
+import type { IBoardSelectionRect } from './board-selection-geometry.util';
+export declare const BOARD_SELECTION_DRAG_THRESHOLD = 4;
+export interface IBoardSelectionPoint {
+    x: number;
+    y: number;
+}
+export interface IResolveBoardElementDragSelectionOptions {
+    elementData: Record<string, IBoardElementData>;
+    elementOrder: string[];
+    start: IBoardSelectionPoint;
+    end: IBoardSelectionPoint;
+    preciseSelection: boolean;
+    spatialIndex?: IBoardElementSpatialIndex;
+}
+export interface IResolvedBoardDragSelection {
+    rect: IBoardSelectionRect;
+    selectedIds: string[];
+}
+export declare function createBoardSelectionRect(start: IBoardSelectionPoint, end: IBoardSelectionPoint): IBoardSelectionRect;
+export declare function isBoardDragSelection(start: IBoardSelectionPoint, end: IBoardSelectionPoint): boolean;
+export declare function resolveBoardDragSelection(options: IResolveBoardElementDragSelectionOptions): IResolvedBoardDragSelection | null;

package/lib/types/utils/board-selection-move.util.d.ts

@@ -0,0 +1,17 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+export interface IBoardSelectionMoveDelta {
+    x: number;
+    y: number;
+}
+export interface IBoardElementSelectionMoveResult {
+    elementId: string;
+    element: IBoardElementData['element'];
+    transform: IBoardElementData['transform'];
+}
+export type IBoardElementSelectionMoveDelta = IBoardSelectionMoveDelta;
+export interface IResolveBoardElementSelectionMoveOptions {
+    selectedIds: string[];
+    elementData: Record<string, IBoardElementData>;
+    delta: IBoardElementSelectionMoveDelta;
+}
+export declare function resolveBoardElementSelectionMove(options: IResolveBoardElementSelectionMoveOptions): IBoardElementSelectionMoveResult[];

package/lib/types/utils/board-selection-normalize.util.d.ts

@@ -0,0 +1,3 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+export declare function hasSelectedBoardContainerAncestor(elementData: Record<string, IBoardElementData>, elementId: string, selectedIds: ReadonlySet<string>): boolean;
+export declare function resolveBoardSelectionRootElementIds(elementData: Record<string, IBoardElementData>, selectedIds: readonly string[]): string[];

package/lib/types/utils/board-selection-overlay.util.d.ts

@@ -0,0 +1,15 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IBoardSelectionRect } from './board-selection-geometry.util';
+export interface IBoardElementSelectionOverlayItem {
+    elementId: string;
+    rect: IBoardSelectionRect;
+}
+export interface IBoardElementSelectionOverlay {
+    items: IBoardElementSelectionOverlayItem[];
+    bounds: IBoardSelectionRect;
+}
+export interface IResolveBoardElementSelectionOverlayOptions {
+    selectedIds: string[];
+    elementData: Record<string, IBoardElementData>;
+}
+export declare function resolveBoardElementSelectionOverlay(options: IResolveBoardElementSelectionOverlayOptions): IBoardElementSelectionOverlay | null;

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

@@ -0,0 +1,6 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+export interface IBoardElementSelectionResizeResult {
+    elementId: string;
+    element: IBoardElementData['element'];
+    transform: IBoardElementData['transform'];
+}

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

@@ -0,0 +1,9 @@
+import type { IBoardElementData, IBoardPageElement, IBoardTextElement } from '@univerjs-pro/boards';
+import type { IShapeData } from '@univerjs-pro/engine-shape';
+import type { IDocumentData } from '@univerjs/core';
+export declare function isBoardShapeEditableElement(element: IBoardPageElement): boolean;
+export declare function isManagedBoardMindMapNode(elementData: IBoardElementData | undefined): boolean;
+export declare function getBoardElementShapeData(element: IBoardPageElement): IShapeData | null;
+export declare function createBoardTextShapeData(element: IBoardTextElement): IShapeData;
+export declare function applyBoardShapeDataPatchToElement(element: IBoardPageElement, patch: IShapeData): IBoardPageElement;
+export declare function documentDataToPlainText(documentData: IDocumentData): string;