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

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

@@ -1,6 +1,7 @@
 import type { BoardModel } from '@univerjs-pro/boards';
 import type { IBoardSelectionPoint } from '../utils/board-selection-interaction.util';
 import { IBoardElementService } from '@univerjs-pro/boards';
+import { IRenderManagerService } from '@univerjs/engine-render';
 import { IBoardElementStateService } from './board-element-state.service';
 export interface IBoardPointerSelectionOptions {
     boardModel: BoardModel | null | undefined;
@@ -13,7 +14,10 @@ export interface IBoardPointerSelectionOptions {
 export declare class BoardSelectionService {
     private readonly _boardElementService;
     private readonly _elementStateService;
-    constructor(_boardElementService: IBoardElementService, _elementStateService: IBoardElementStateService);
+    private readonly _renderManagerService;
+    constructor(_boardElementService: IBoardElementService, _elementStateService: IBoardElementStateService, _renderManagerService: Pick<IRenderManagerService, 'getRenderUnitById'>);
     selectByPointerGesture(options: IBoardPointerSelectionOptions): boolean;
+    private _createRenderBoundsResolver;
+    private _createRenderHitTester;
     private _resolveInvertedSelection;
 }

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

@@ -71,7 +71,6 @@ export declare class BoardToolService {
             root: IBoardToolMindMapBlueprintNode;
         };
     }): void;
-    private _beginImport;
     private _resolveShapePendingInsert;
     beginShapeInsert(shapeType: BoardShapeType | string, options?: IBoardShapeInsertOptions): void;
     beginShapeInsertDrag(shapeType: BoardShapeType | string, options?: IBoardShapeInsertOptions): void;

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

@@ -1,6 +1,7 @@
 import type { BoardModel } from '@univerjs-pro/boards';
 import type { IBoardViewportSize, IBoardViewportZoomConfig } from '../utils/board-viewport.util';
 import { IBoardElementService } from '@univerjs-pro/boards';
+import { IRenderManagerService } from '@univerjs/engine-render';
 import { IBoardUIStateService } from './board-ui-state.service';
 export interface IBoardViewportFitContentOptions {
     viewportSize: IBoardViewportSize;
@@ -10,6 +11,8 @@ export interface IBoardViewportFitContentOptions {
 export declare class BoardViewportService {
     private readonly _boardElementService;
     private readonly _uiStateService;
-    constructor(_boardElementService: IBoardElementService, _uiStateService: IBoardUIStateService);
+    private readonly _renderManagerService;
+    constructor(_boardElementService: IBoardElementService, _uiStateService: IBoardUIStateService, _renderManagerService: Pick<IRenderManagerService, 'getRenderUnitById'>);
     fitContent(boardModel: BoardModel | null | undefined, options: IBoardViewportFitContentOptions): boolean;
+    private _createRenderBoundsResolver;
 }

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

@@ -1,4 +1,5 @@
 import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IBoardGuideCandidate } from './board-guide-candidates.util';
 import type { IBoardSelectionRect } from './board-selection-geometry.util';
 export interface IBoardAlignmentGuide {
     position: number;
@@ -15,6 +16,7 @@ export interface IResolveBoardElementAlignmentGuidesOptions {
     elementData: Record<string, IBoardElementData>;
     elementOrder: string[];
     threshold: number;
+    candidates?: readonly IBoardGuideCandidate[];
 }
 export interface IBoardAlignmentSnap {
     delta: {

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

@@ -56,6 +56,7 @@ export interface IResolveBoardOrthogonalObstacleRouteOptions {
     };
     fallbackRoute?: () => IBoardConnectorPoint[];
 }
+export declare function createBoardConnectorRoutingObstaclesForElementIds(elementData: Record<string, IBoardElementData>, elementIds: Iterable<string>, clearance?: number): IBoardRoutingObstacle[];
 export declare function createBoardConnectorRoutingObstacleIndex(elementData: Record<string, IBoardElementData> | undefined, options?: ICreateBoardConnectorRoutingObstaclesOptions): IBoardRoutingObstacleIndex;
 export declare function isBoardRoutingPointInsideObstacle(point: IBoardConnectorPoint, obstacle: IBoardRoutingObstacle): boolean;
 export declare function doesBoardRoutingSegmentIntersectObstacle(segment: IBoardRoutingSegment, obstacle: IBoardRoutingObstacle): boolean;

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

@@ -1,5 +1,5 @@
-import type { IBoardConnectorData, IBoardConnectorEndpoint, IBoardConnectorPoint, IBoardElementData, IBoardElementTransform } from '@univerjs-pro/boards';
-import type { IBoardRoutingSegment } from './board-connector-router.util';
+import type { IBoardConnectorData, IBoardConnectorElement, IBoardConnectorEndpoint, IBoardConnectorPoint, IBoardElementData, IBoardElementTransform } from '@univerjs-pro/boards';
+import type { IBoardRoutingObstacleIndex, IBoardRoutingSegment } from './board-connector-router.util';
 export interface IBoardConnectorRouteBounds {
     left: number;
     top: number;
@@ -44,13 +44,28 @@ export interface IResolveBoardConnectorRoutePointsOptions extends IResolveBoardC
         tolerance?: number;
     };
     resolvedRoutePoints?: readonly IBoardConnectorPoint[];
+    routingCache?: BoardConnectorRoutingCache;
 }
 export declare const BOARD_CONNECTOR_MIN_BOUNDS_SIZE = 1;
+type IBoardConnectorElementData = IBoardElementData & {
+    element: IBoardConnectorElement;
+};
 export declare function resolveBoardConnectorEndpointPoint(endpoint: IBoardConnectorEndpoint, options?: IResolveBoardConnectorEndpointPointOptions): IBoardConnectorPoint | null;
 export declare function resolveBoardConnectorEndpoint(endpoint: IBoardConnectorEndpoint, options?: IResolveBoardConnectorEndpointOptions): IBoardConnectorResolvedEndpoint | null;
 export declare function isBoardConnectorTerminalSegmentAlignedWithEndpointNormal(segment: IBoardRoutingSegment, endpoint: IBoardConnectorResolvedEndpoint, terminal: 'start' | 'end'): boolean;
 export declare function isBoardConnectorRouteAlignedWithEndpoints(connectorData: IBoardConnectorData, routePoints: readonly IBoardConnectorPoint[] | undefined, options?: IResolveBoardConnectorEndpointPointOptions): routePoints is readonly IBoardConnectorPoint[];
 export declare function normalizeBoardConnectorEndpointManualRoutePoints(connectorData: IBoardConnectorData, options?: IResolveBoardConnectorEndpointOptions): IBoardConnectorData;
+export declare class BoardConnectorRoutingCache {
+    private _elementData?;
+    private readonly _obstacleIndexesByExclusion;
+    private readonly _routePointsByConnectorId;
+    private readonly _crossingRoutePointsByConnectorId;
+    invalidate(elementData?: Record<string, IBoardElementData>, invalidatedElementIds?: Iterable<string>): string[];
+    getObstacleIndex(elementData: Record<string, IBoardElementData> | undefined, excludeElementIds: readonly string[]): IBoardRoutingObstacleIndex;
+    resolveRoutePoints(connectorData: IBoardConnectorData, options?: IResolveBoardConnectorRoutePointsOptions): IBoardConnectorPoint[];
+    private _resolveRouteDependency;
+    resolveCrossingRoutePoints(item: IBoardConnectorElementData, elementData: Record<string, IBoardElementData>): IBoardConnectorPoint[];
+}
 export declare function resolveBoardConnectorRoutePoints(connectorData: IBoardConnectorData, options?: IResolveBoardConnectorRoutePointsOptions): IBoardConnectorPoint[];
 export declare function resolveBoardConnectorPathCommands(connectorData: IBoardConnectorData, options?: IResolveBoardConnectorRoutePointsOptions): BoardConnectorPathCommand[];
 export declare function resolveBoardConnectorPathBounds(commands: readonly BoardConnectorPathCommand[], fallbackTransform?: IBoardElementTransform): IBoardConnectorRouteBounds;
@@ -67,3 +82,4 @@ export declare function hitTestBoardConnectorPath(point: IBoardConnectorPoint, c
 export declare function resolveBoardConnectorRouteBounds(points: readonly IBoardConnectorPoint[], fallbackTransform?: IBoardElementTransform): IBoardConnectorRouteBounds;
 export declare function distanceToBoardConnectorSegment(point: IBoardConnectorPoint, start: IBoardConnectorPoint, end: IBoardConnectorPoint): number;
 export declare function trimBoardConnectorRoute(points: readonly IBoardConnectorPoint[], startTrim: number, endTrim: number): IBoardConnectorPoint[];
+export {};

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

@@ -1,4 +1,5 @@
 import type { IBoardElementData, IBoardRect } from '@univerjs-pro/boards';
+import { resolveBoardElementBounds } from './board-selection-geometry.util';
 export interface IBoardPoint {
     x: number;
     y: number;
@@ -7,6 +8,7 @@ export interface ICreateBoardElementSpatialIndexOptions {
     unitId: string;
     subUnitId: string;
     elementData: Record<string, IBoardElementData>;
+    resolveElementBounds?: Parameters<typeof resolveBoardElementBounds>[2];
 }
 export interface IBoardElementSpatialIndex {
     queryIntersecting(bounds: IBoardRect): string[];

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

@@ -1,5 +1,8 @@
-import type { BoardConnectorRouting, IBoardConnectorStyle, IBoardElementData } from '@univerjs-pro/boards';
+import type { BoardConnectorRouting, IBoardConnectorStyle, IBoardContainerElement, IBoardElementData, IBoardSwimlaneLane, IBoardTextStyle } from '@univerjs-pro/boards';
 import type { IShapeData } from '@univerjs-pro/engine-shape';
+import type { buildShapeTextDataUpdate } from '@univerjs-pro/shape-editor-ui';
+import type { ITextStyle } from '@univerjs/core';
+import { HorizontalAlign, VerticalAlign } from '@univerjs/core';
 export type BoardFloatingToolbarOwner = 'common' | 'connector' | 'mind-map' | 'none' | 'shape' | 'table';
 export interface IBoardFloatingToolbarSelection {
     elements: IBoardElementData[];
@@ -13,6 +16,24 @@ export interface IResolveBoardFloatingToolbarSelectionOptions {
     selectedIds: readonly string[];
     getElementById: (unitId: string, subUnitId: string, elementId: string) => IBoardElementData | null | undefined;
 }
+export interface IBoardSwimlaneLaneTypographyTarget {
+    container: IBoardContainerElement;
+    lane: IBoardSwimlaneLane;
+}
+export declare function boardTextStyleToToolbarTextStyle(style: IBoardTextStyle | undefined, fallbackFontSize: number): ITextStyle;
+export declare function getContainerTitleStyle(element: IBoardContainerElement | undefined): IBoardTextStyle | undefined;
+export declare function getSwimlaneLaneTypographyTarget(element: IBoardContainerElement | undefined, laneId: string | undefined): IBoardSwimlaneLaneTypographyTarget | null;
+export declare function getSwimlaneLaneTitleTextModel(target: IBoardSwimlaneLaneTypographyTarget | null): {
+    ha?: HorizontalAlign;
+    va?: VerticalAlign;
+} | null;
+export declare function getSwimlaneContainerTitleTextModel(element: IBoardContainerElement | undefined): {
+    ha?: HorizontalAlign;
+    va?: VerticalAlign;
+} | null;
+export declare function isUnfocusedSwimlaneTypographyTarget(element: IBoardContainerElement, laneTarget: IBoardSwimlaneLaneTypographyTarget | null): boolean;
+export declare function buildTitleStyleUpdate(currentStyle: IBoardTextStyle | undefined, params: Parameters<typeof buildShapeTextDataUpdate>[1]): IBoardTextStyle;
+export declare function buildContainerTitleStyleUpdate(element: IBoardContainerElement, params: Parameters<typeof buildShapeTextDataUpdate>[1]): IBoardTextStyle;
 /**
  * Resolves one owner for the selection-level floating toolbar.
  *

package/lib/types/utils/board-guide-candidates.util.d.ts

@@ -0,0 +1,13 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IBoardSelectionRect } from './board-selection-geometry.util';
+export interface IBoardGuideCandidate {
+    elementId: string;
+    rect: IBoardSelectionRect;
+}
+export interface ICreateBoardGuideCandidatesOptions {
+    activeIds: readonly string[];
+    bounds?: IBoardSelectionRect;
+    elementData: Record<string, IBoardElementData>;
+    elementOrder: readonly string[];
+}
+export declare function createBoardGuideCandidates(options: ICreateBoardGuideCandidatesOptions): IBoardGuideCandidate[];

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

@@ -6,17 +6,20 @@ export interface IBoardSelectionRect {
     width: number;
     height: number;
 }
+export type BoardElementBoundsResolver = (elementDataItem: IBoardElementData) => IBoardSelectionRect | null | undefined;
 export interface ISelectBoardElementsByRectOptions {
     elementData: Record<string, IBoardElementData>;
     elementOrder: string[];
     rect: IBoardSelectionRect;
     preciseSelection: boolean;
+    resolveElementBounds?: BoardElementBoundsResolver;
     spatialIndex?: IBoardElementSpatialIndex;
 }
 export interface IResolveBoardElementsBoundsOptions {
     elementData: Record<string, IBoardElementData>;
     elementOrder: string[];
     includeHidden?: boolean;
+    resolveElementBounds?: BoardElementBoundsResolver;
 }
 export interface IBoardElementSelectionResult {
     unitId: string;
@@ -25,7 +28,7 @@ export interface IBoardElementSelectionResult {
     element: IBoardElementData['element'];
     transform: IBoardElementData['transform'];
 }
-export declare function resolveBoardElementBounds(elementDataItem: IBoardElementData, elementData: Record<string, IBoardElementData>): IBoardSelectionRect;
+export declare function resolveBoardElementBounds(elementDataItem: IBoardElementData, elementData: Record<string, IBoardElementData>, resolveElementBounds?: BoardElementBoundsResolver): 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

@@ -5,8 +5,10 @@ export interface IHitTestBoardElementAtPointOptions {
     elementData: Record<string, IBoardElementData>;
     elementOrder: string[];
     point: IBoardSelectionPoint;
+    hitTestElement?: BoardElementHitTester;
     spatialIndex?: IBoardElementSpatialIndex;
 }
+export type BoardElementHitTester = (elementDataItem: IBoardElementData, point: IBoardSelectionPoint) => boolean | undefined;
 export interface IBoardElementHitTestResult {
     unitId: string;
     subUnitId: string;

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

@@ -1,6 +1,6 @@
 import type { IBoardElementData } from '@univerjs-pro/boards';
 import type { IBoardElementSpatialIndex } from './board-container-spatial-index.util';
-import type { IBoardSelectionRect } from './board-selection-geometry.util';
+import type { BoardElementBoundsResolver, IBoardSelectionRect } from './board-selection-geometry.util';
 export declare const BOARD_SELECTION_DRAG_THRESHOLD = 4;
 export interface IBoardSelectionPoint {
     x: number;
@@ -13,6 +13,7 @@ export interface IResolveBoardElementDragSelectionOptions {
     end: IBoardSelectionPoint;
     dragSelection: boolean;
     preciseSelection: boolean;
+    resolveElementBounds?: BoardElementBoundsResolver;
     spatialIndex?: IBoardElementSpatialIndex;
 }
 export interface IResolvedBoardDragSelection {

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

@@ -1,29 +1,4 @@
-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;
-}
+import type { IAlignmentSnapGuide } from '@univerjs/engine-render';
 export interface IBoardConnectorAxisSnapOptions {
     anchor: {
         x: number;
@@ -41,22 +16,6 @@ export interface IBoardConnectorAxisSnapResult {
         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;
+    guide: IAlignmentSnapGuide;
 }
 export declare function resolveBoardConnectorAxisSnap(options: IBoardConnectorAxisSnapOptions): IBoardConnectorAxisSnapResult | null;

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

@@ -1,4 +1,5 @@
 import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IBoardGuideCandidate } from './board-guide-candidates.util';
 import type { IBoardSelectionRect } from './board-selection-geometry.util';
 export type BoardSpacingGuideAxis = 'horizontal' | 'vertical';
 export interface IBoardSpacingGuidePoint {
@@ -20,5 +21,6 @@ export interface IResolveBoardElementSpacingGuidesOptions {
     elementData: Record<string, IBoardElementData>;
     elementOrder: string[];
     maxDistance?: number;
+    candidates?: readonly IBoardGuideCandidate[];
 }
 export declare function resolveBoardElementSpacingGuides(options: IResolveBoardElementSpacingGuidesOptions): IBoardSpacingGuide[];

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

@@ -36,9 +36,15 @@ export interface IResolveBoardViewportFitRectOptions {
     padding?: number;
     zoom?: IBoardViewportZoomConfig;
 }
+export interface IResolveBoardViewportWorldRectOptions {
+    viewport: IBoardViewportTransform;
+    viewportSize: IBoardViewportSize;
+    padding?: number;
+}
 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 resolveBoardViewportWorldRect(options: IResolveBoardViewportWorldRectOptions): IBoardViewportRect;
 export declare function getBoardPointFromClient(element: HTMLElement, clientX: number, clientY: number, viewport: IBoardViewportTransform, zoom?: IBoardViewportZoomConfig): {
     x: number;
     y: number;

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

@@ -1,8 +1,4 @@
-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";
-export declare function connectorStyleToShapeStrokeData(style: IBoardConnectorStyle): IShapeData;
-export declare function shapeStrokeToBoardConnectorStylePatch(shapeData?: IShapeData): Partial<IBoardConnectorStyle>;
 export declare function BoardConnectorFloatingToolbar({ popup }: {
     popup: {
         extraProps?: {

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

@@ -0,0 +1,35 @@
+import type { BoardConnectorRouting, IBoardConnectorLabel, IBoardConnectorLabelStylePatch, IBoardConnectorMarker, IBoardConnectorStyle } from '@univerjs-pro/boards';
+import type { IShapeData } from '@univerjs-pro/engine-shape';
+import type { ITextStyle } from '@univerjs/core';
+import type { ReactNode } from 'react';
+import { HorizontalAlign, RichTextBuilder } from '@univerjs/core';
+export declare function connectorStyleToShapeStrokeData(style: IBoardConnectorStyle): IShapeData;
+export declare function shapeStrokeToBoardConnectorStylePatch(shapeData?: IShapeData): Partial<IBoardConnectorStyle>;
+export declare function ToolbarButton(props: {
+    title?: string;
+    ariaLabel?: string;
+    active?: boolean;
+    children: ReactNode;
+    onClick?: () => void;
+}): import("react").JSX.Element;
+export declare function MarkerDropdown(props: {
+    label: string;
+    currentMarker?: IBoardConnectorMarker;
+    flipIcon?: boolean;
+    onSelect: (marker: IBoardConnectorMarker | undefined) => void;
+}): import("react").JSX.Element;
+export declare function SettingsDropdown(props: {
+    routing?: BoardConnectorRouting;
+    style: IBoardConnectorStyle;
+    onRouting: (routing: BoardConnectorRouting) => void;
+    onStyle: (style: Partial<IBoardConnectorStyle>) => void;
+}): import("react").JSX.Element;
+export declare function createConnectorLabelRichTextBuilder(label: IBoardConnectorLabel): RichTextBuilder;
+export declare function ConnectorLabelSettingsDropdown(props: {
+    label: IBoardConnectorLabel;
+    onEditText: () => void;
+    onDeleteText: () => void;
+    onStyle: (patch: IBoardConnectorLabelStylePatch) => void;
+    onTextStyle: (patch: ITextStyle) => void;
+    onHorizontalAlign: (horizontalAlign: HorizontalAlign) => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,7 @@
+export interface IBoardRenamePopupProps {
+    kind: 'container' | 'lane';
+    initialTitle: string;
+    onCancel: () => void;
+    onSubmit: (title: string) => void | Promise<void>;
+}
+export declare function BoardRenamePopup(props: IBoardRenamePopupProps): import("react").JSX.Element;

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

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

package/lib/types/views/board-shape-floating-toolbar/BoardSwimlaneToolbarMenu.d.ts

@@ -0,0 +1,12 @@
+export interface IBoardSwimlaneToolbarMenuAction {
+    key: string;
+    label: string;
+    shortcut?: string;
+    disabled?: boolean;
+    children?: IBoardSwimlaneToolbarMenuAction[];
+    onClick?: () => void;
+}
+export declare function BoardSwimlaneToolbarMenu(props: {
+    kind: 'container' | 'lane';
+    actions: IBoardSwimlaneToolbarMenuAction[];
+}): import("react").JSX.Element;

package/lib/umd/facade.js

@@ -0,0 +1 @@
+function _0x4345(){var _0x2fb38b=['UniverProBoardsFacade','3204aJNzRR','getActivePageId','55282BRTgqj','6335KDKxKH','FBoard','9968lTkksO','20xrgyoJ','1974isoSmg','13070QdnZGH','getScreenshot','_commandService','3905yaYyyY','@univerjs-pro/boards-ui','10790EidIha','_boardModel','amd','analyzeRenderedLayout','240664XuRlxN','924NejoPA','UniverProBoardsUi','2dizLng','syncExecuteCommand','function','1204797kuOrxV'];_0x4345=function(){return _0x2fb38b;};return _0x4345();}function _0x1e99(_0x423c4c,_0x36d9cf){_0x423c4c=_0x423c4c-0x110;var _0x4345a0=_0x4345();var _0x1e9945=_0x4345a0[_0x423c4c];return _0x1e9945;}(function(_0x20a493,_0x43010a){var _0x416a7c=_0x1e99,_0x138a51=_0x20a493();while(!![]){try{var _0x1419e3=parseInt(_0x416a7c(0x113))/0x1*(parseInt(_0x416a7c(0x11a))/0x2)+-parseInt(_0x416a7c(0x116))/0x3+parseInt(_0x416a7c(0x110))/0x4*(-parseInt(_0x416a7c(0x11e))/0x5)+-parseInt(_0x416a7c(0x11f))/0x6*(-parseInt(_0x416a7c(0x11b))/0x7)+parseInt(_0x416a7c(0x11d))/0x8*(parseInt(_0x416a7c(0x118))/0x9)+parseInt(_0x416a7c(0x120))/0xa*(parseInt(_0x416a7c(0x123))/0xb)+-parseInt(_0x416a7c(0x111))/0xc*(parseInt(_0x416a7c(0x125))/0xd);if(_0x1419e3===_0x43010a)break;else _0x138a51['push'](_0x138a51['shift']());}catch(_0x1ef42d){_0x138a51['push'](_0x138a51['shift']());}}}(_0x4345,0x875af),function(_0x5d2cc2,_0x1e6d04){var _0x2ea0b1=_0x1e99;typeof exports=='object'&&typeof module<'u'?_0x1e6d04(require('@univerjs-pro/boards-ui'),require('@univerjs-pro/boards/facade')):typeof define==_0x2ea0b1(0x115)&&define[_0x2ea0b1(0x127)]?define([_0x2ea0b1(0x124),'@univerjs-pro/boards/facade'],_0x1e6d04):(_0x5d2cc2=typeof globalThis<'u'?globalThis:_0x5d2cc2||self,_0x1e6d04(_0x5d2cc2[_0x2ea0b1(0x112)],_0x5d2cc2[_0x2ea0b1(0x117)]));}(this,function(_0x3618db,_0x46daf2){var _0x583279=_0x1e99,_0x8708cc=class extends _0x46daf2[_0x583279(0x11c)]{[_0x583279(0x128)](_0xc4fdbd){var _0x32d676=_0x583279;return this[_0x32d676(0x122)][_0x32d676(0x114)](_0x3618db['AnalyzeBoardRenderedLayoutCommand']['id'],{'unitId':this['id'],'subUnitId':this['_boardModel'][_0x32d676(0x119)](),'focusPadding':_0xc4fdbd});}[_0x583279(0x121)](_0x3fb9a3){var _0x46729e=_0x583279;return this[_0x46729e(0x122)]['executeCommand'](_0x3618db['CaptureBoardScreenshotCommand']['id'],{..._0x3fb9a3,'unitId':this['id'],'subUnitId':this[_0x46729e(0x126)][_0x46729e(0x119)]()});}};_0x46daf2[_0x583279(0x11c)]['extend'](_0x8708cc);}));