@univerjs-pro/shape-editor-ui 1.0.0-alpha.1 → 1.0.0-alpha.3

package/lib/types/utils/shape-transformer-config.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared modern selection affordances for shape surfaces that use the engine transformer.
+ * Per-object transformer settings still take precedence for special cases such as connectors.
+ */
+export declare const SHAPE_EDITOR_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/views/shape-floating-toolbar/ShapeFloatingToolbar.d.ts

@@ -1,8 +1,12 @@
 import type { IShapeData, ShapeTypeEnum } from '@univerjs-pro/engine-shape';
 import type { ITextStyle } from '@univerjs/core';
-import type { ReactNode } from 'react';
+import type { MouseEvent, PointerEvent, ReactNode } from 'react';
 import type { IShapeTextUpdateOptions } from './shape-floating-toolbar-utils';
 import { HorizontalAlign, VerticalAlign } from '@univerjs/core';
+export declare const SHAPE_FLOATING_TOOLBAR_DEFAULT_FILL_COLOR = "#3B82F6";
+export declare const SHAPE_FLOATING_TOOLBAR_DEFAULT_STROKE_COLOR = "#2563EB";
+export declare const SHAPE_FLOATING_TOOLBAR_DEFAULT_TEXT_COLOR = "#111827";
+export declare const SHAPE_FLOATING_TOOLBAR_DEFAULT_TEXT_BACKGROUND_COLOR = "#ffffff";
 export type IShapeFloatingToolbarWrappingStyle = string | number;
 export interface IShapeFloatingToolbarTextModel {
     ha?: HorizontalAlign;
@@ -29,21 +33,36 @@ export interface IShapeFloatingToolbarLayerActions {
     onBackward: () => void;
     onBack: () => void;
 }
+export interface IShapeFloatingToolbarExtensionAction {
+    key: string;
+    label: string;
+    icon: ReactNode;
+    render?: ReactNode;
+    active?: boolean;
+    disabled?: boolean;
+    visible?: boolean;
+    onClick?: () => void;
+}
+export interface IShapeFloatingToolbarExtensionGroup {
+    key: string;
+    visible?: boolean;
+    actions: IShapeFloatingToolbarExtensionAction[];
+}
 export interface IShapeFloatingToolbarProps {
     shapeData?: IShapeData;
     shapeType?: ShapeTypeEnum;
     textStyle: ITextStyle;
     textModel?: IShapeFloatingToolbarTextModel | null;
-    fontOptions: Array<{
-        label: string;
-        value: string;
-    }>;
     wrappingStyle?: IShapeFloatingToolbarWrappingStyle;
     wrappingStyleOptions?: Array<IToolbarDropdownOption<IShapeFloatingToolbarWrappingStyle>>;
     enableShapeFillReset?: boolean;
     enableShapeStrokeReset?: boolean;
     enableTextBackgroundReset?: boolean;
+    enableTextControls?: boolean;
     deferUntilCollapsedStateLoaded?: boolean;
+    defaultFillColor?: string;
+    defaultGradientEndColor?: string;
+    defaultStrokeColor?: string;
     onUpdateShapeData: (oldShapeJSON: {
         oldShapeData?: IShapeData;
     }, shapeData?: IShapeData) => void;
@@ -51,23 +70,125 @@ export interface IShapeFloatingToolbarProps {
     onUpdateWrappingStyle?: (value: IShapeFloatingToolbarWrappingStyle) => void;
     groupAction?: IShapeFloatingToolbarGroupAction;
     layerActions?: IShapeFloatingToolbarLayerActions;
+    extensionGroups?: IShapeFloatingToolbarExtensionGroup[];
     onOpenPanel?: () => void;
     onDelete?: () => void;
 }
-declare function TextWrapShapeIcon(): import("react").JSX.Element;
+export declare function ShapeFloatingToolbarIcon(props: {
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+export declare function ShapeFloatingToolbarContent(props: {
+    children: ReactNode;
+    className?: string;
+    maxWidthClassName?: string;
+    dataAttributes?: Record<`data-${string}`, string>;
+    onMouseDown?: (event: MouseEvent<HTMLDivElement>) => void;
+}): import("react").JSX.Element;
+export declare function ShapeFloatingToolbarButton(props: {
+    title?: string;
+    titleKey?: string;
+    active?: boolean;
+    disabled?: boolean;
+    children: ReactNode;
+    className?: string;
+    sizeClassName?: string;
+    ariaExpanded?: boolean;
+    onClick?: () => void;
+    onMouseDown?: (event: MouseEvent<HTMLButtonElement>) => void;
+    onPointerDown?: (event: PointerEvent<HTMLButtonElement>) => void;
+}): import("react").JSX.Element;
+export declare function ShapeFloatingToolbarDropdownTrigger(props: {
+    title?: string;
+    titleKey?: string;
+    icon: ReactNode;
+    active?: boolean;
+    className?: string;
+    sizeClassName?: string;
+    onMouseDown?: (event: MouseEvent<HTMLButtonElement>) => void;
+    onPointerDown?: (event: PointerEvent<HTMLButtonElement>) => void;
+}): import("react").JSX.Element;
+export declare function ShapeFloatingToolbarFontSizeSelect(props: {
+    value: string | number;
+    className?: string;
+    onChange: (fontSize: number) => void;
+    onAfterChange?: () => void;
+}): import("react").JSX.Element;
+export type ShapeStrokePanelMode = 'none' | 'solid' | 'dash' | 'dot';
+export interface IShapeStrokePanelContentProps {
+    titleKey: string;
+    shapeData: IShapeData;
+    disabled?: boolean;
+    resetLabelKey?: string;
+    modeOptions?: ShapeStrokePanelMode[];
+    showDashDropdown?: boolean;
+    fallbackColor?: string;
+    widthRange?: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    onReset?: () => void;
+    onRequestClose?: () => void;
+    onUpdateShapeData: IShapeFloatingToolbarProps['onUpdateShapeData'];
+}
+export declare function ShapeStrokePanelContent(props: IShapeStrokePanelContentProps): import("react").JSX.Element;
+export declare function ShapeStrokePanelButton(props: {
+    titleKey: string;
+    shapeData: IShapeData;
+    disabled?: boolean;
+    resetLabelKey?: string;
+    fallbackColor?: string;
+    onReset?: () => void;
+    onUpdateShapeData: IShapeFloatingToolbarProps['onUpdateShapeData'];
+}): import("react").JSX.Element;
+export declare function ShapeFillButton(props: {
+    titleKey: string;
+    shapeData: IShapeData;
+    disabled?: boolean;
+    fallbackColor?: string;
+    fallbackGradientEndColor?: string;
+    onUpdateShapeData: IShapeFloatingToolbarProps['onUpdateShapeData'];
+}): import("react").JSX.Element;
 export declare function TextFillButton(props: {
-    title: string;
+    titleKey: string;
     textStyle: ITextStyle;
     fallbackColor: string;
     onChange: (textStyle: ITextStyle) => void;
 }): import("react").JSX.Element;
 export declare function TextBackgroundColorButton(props: {
-    title: string;
+    titleKey: string;
     color: string;
-    resetLabel?: string;
     onApply: () => void;
     onReset?: () => void;
     onChange: (color: string) => void;
 }): import("react").JSX.Element;
+export declare function TypographyPanelButton(props: {
+    titleKey: string;
+    textStyle: {
+        isBold: boolean;
+        isItalic: boolean;
+        isUnderline: boolean;
+        isStrike: boolean;
+    };
+    horizontalAlign: HorizontalAlign;
+    verticalAlign: VerticalAlign;
+    horizontalAlignOptions: Array<IToolbarDropdownOption<HorizontalAlign>>;
+    verticalAlignOptions: Array<IToolbarDropdownOption<VerticalAlign>>;
+    onUpdateText: IShapeFloatingToolbarProps['onUpdateText'];
+}): import("react").JSX.Element;
+export declare function ShapeFloatingToolbarMenuPanel(props: {
+    title?: string;
+    titleKey?: string;
+    children: ReactNode;
+    className?: string;
+    minWidthClassName?: string;
+}): import("react").JSX.Element;
+export declare function ShapeFloatingToolbarMenuItem(props: {
+    label?: string;
+    labelKey?: string;
+    shortcut?: string;
+    disabled?: boolean;
+    onClick: () => void;
+}): import("react").JSX.Element;
 export declare function ShapeFloatingToolbar(props: IShapeFloatingToolbarProps): import("react").JSX.Element | null;
-export { TextWrapShapeIcon };

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

@@ -1,11 +1,8 @@
 import type { IShapeData } from '@univerjs-pro/engine-shape';
 import type { IDocumentData, ITextStyle } from '@univerjs/core';
+import type { IShapeTextModel } from '../shape-text-editor/types';
 import { HorizontalAlign, VerticalAlign } from '@univerjs/core';
-export interface IShapeTextModel {
-    va?: VerticalAlign;
-    ha?: HorizontalAlign;
-    doc: IDocumentData;
-}
+export type { IShapeTextModel };
 export interface IShapeTextUpdateOptions {
     textStyle?: ITextStyle;
     verticalAlign?: VerticalAlign;

package/lib/types/views/shape-picker/ShapePickerGrid.d.ts

@@ -0,0 +1,22 @@
+import type { ShapeGroupEnum, ShapeTypeOption } from './shapes';
+export interface IShapePickerGridProps {
+    onShapeClick: (shape: ShapeTypeOption) => void;
+    excludeGroups?: ShapeGroupEnum[];
+    options?: readonly ShapeTypeOption[];
+    scrollContainer?: 'self' | 'parent';
+    variant?: 'plain' | 'card';
+}
+export declare function ShapePickerGrid(props: IShapePickerGridProps): import("react").JSX.Element;
+export interface IShapePickerPanelProps {
+    onShapeClick: (shape: ShapeTypeOption) => void;
+    excludeGroups?: ShapeGroupEnum[];
+    options?: readonly ShapeTypeOption[];
+    scrollContainer?: 'self' | 'parent';
+    variant?: 'plain' | 'card';
+}
+export declare function ShapePickerPanel(props: IShapePickerPanelProps): import("react").JSX.Element;
+export interface IShapePickerDropdownProps extends IShapePickerPanelProps {
+    buttonLabel: string;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+}
+export declare function ShapePickerDropdown(props: IShapePickerDropdownProps): import("react").JSX.Element;

package/lib/types/views/shape-picker/index.d.ts

@@ -0,0 +1,4 @@
+export { ShapePickerDropdown, ShapePickerGrid, ShapePickerPanel, } from './ShapePickerGrid';
+export type { IShapePickerDropdownProps, IShapePickerGridProps, IShapePickerPanelProps, } from './ShapePickerGrid';
+export { groupShapeOptions, ShapeGroupEnum, shapeTypeOptions, } from './shapes';
+export type { ShapeLocaleKey, ShapeTypeOption, } from './shapes';

package/lib/types/views/shape-picker/shapes.d.ts

@@ -0,0 +1,25 @@
+import { ShapeTypeEnum } from '@univerjs-pro/engine-shape';
+export type ShapeLocaleKey = `shape.${string}`;
+export declare enum ShapeGroupEnum {
+    Line = "line",
+    Rectangle = "rectangle",
+    BasicShape = "basicShape",
+    BlockArrow = "blockArrow",
+    EquationShape = "equationShape",
+    Flowchart = "flowchart",
+    StarAndBanner = "starAndBanner",
+    Callout = "callout",
+    Other = "other"
+}
+export declare const shapeTypeOptions: Array<{
+    group: ShapeGroupEnum;
+    type: ShapeTypeEnum;
+    icon: string;
+    name: ShapeLocaleKey;
+    endArrow?: boolean;
+    startArrow?: boolean;
+    horizontal?: boolean;
+    vertical?: boolean;
+}>;
+export type ShapeTypeOption = typeof shapeTypeOptions[number];
+export declare function groupShapeOptions(options?: readonly ShapeTypeOption[], excludeGroups?: readonly ShapeGroupEnum[]): Partial<Record<ShapeGroupEnum, ShapeTypeOption[]>>;

package/lib/types/views/shape-text-editor/ShapeTextEditor.d.ts

@@ -1,29 +1,39 @@
-import type { Nullable } from '@univerjs/core';
+import type { ICustomShapeTextData, IShapeRect } from '@univerjs-pro/engine-shape';
+import type { IDocumentData, Nullable } from '@univerjs/core';
 import type { Editor, IKeyboardEventConfig } from '@univerjs/docs-ui';
-import type { DocumentSkeleton } from '@univerjs/engine-render';
 import type { CSSProperties } from 'react';
-import type { IShapeTextEditingParams, IShapeTextEditingServiceLike, IShapeTextEditorAdapter } from './types';
-import { ICommandService, VerticalAlign, WrapStrategy } from '@univerjs/core';
+import type { IShapeTextEditingParams, IShapeTextEditingService, IShapeTextEditorAdapter, IShapeTextModel, IShapeTextModelLike } from './types';
+import { HorizontalAlign, ICommandService, VerticalAlign } from '@univerjs/core';
+export { resolveShapeTextEditorBehaviorShapeData, resolveShapeTextEditorWrapStrategy, shouldAllowShapeTextEditorHostSizeShrink, shouldAutoFitShapeTextEditorNoWrap, } from './shape-text-behavior';
 export interface IShapeTextEditorProps {
     adapter: IShapeTextEditorAdapter;
     containerWidth: number;
     containerHeight: number;
     editingParams: Nullable<IShapeTextEditingParams>;
-    editingService: IShapeTextEditingServiceLike;
+    editingService: IShapeTextEditingService;
     editorUnitId: string;
     scaleX: number;
     scaleY: number;
     verticalAlignCommandId?: string;
 }
 interface IContentLayout {
+    documentMarginTop: number;
     editorLeft: number;
     editorTop: number;
     editorWidth: number;
     editorHeight: number;
+    editorSurfaceWidth?: number;
 }
+export declare function resolveShapeTextEditingContentHeight(measuredContentHeight: number, caretHeight?: number): number;
+export declare function getShapeTextEditingCaretHeight(activeRange?: {
+    getAbsolutePosition(): Nullable<{
+        height?: number;
+    }>;
+}): number | undefined;
 export declare function areShapeTextEditorLayoutsEqual(a: IContentLayout, b: IContentLayout): boolean;
 interface IShapeTextEditorLayoutOptions {
     actualHeight: number;
+    contentWidth?: number;
     scaleX: number;
     scaleY: number;
     textRect: {
@@ -43,6 +53,12 @@ interface IShapeTextEditorLayout {
     editorHeight: number;
     pageHeight: number;
 }
+interface IShapeTextEditorKeyboardRange {
+    startOffset?: number;
+    endOffset?: number;
+    collapsed?: boolean;
+}
+export declare function isShapeTextEditorKeyboardFocusActive(isInputFocusing: boolean, textRanges: readonly IShapeTextEditorKeyboardRange[] | null | undefined): boolean;
 interface IShapeTextEditorHostHeightOptions {
     hostHeight: number;
     textRect: {
@@ -73,38 +89,118 @@ interface IShapeTextEditorHostSizeChangeOptions {
     baselineHeight: number;
     tolerance?: number;
 }
-export declare function getShapeTextEditorOpticalVerticalOffset(skeleton: DocumentSkeleton, targetHeight: number, verticalAlign?: VerticalAlign): number;
+interface IShapeTextEditorKeyboardOptions {
+    commitOnEnter?: boolean;
+    cancel?: () => void;
+    commit?: () => void;
+    currentFontSize?: number;
+}
 export declare function getShapeTextEditorFocusSessionKey(options: {
     editorUnitId: string;
     editingParams: Nullable<IShapeTextEditingParams>;
 }): string | null;
-export declare function resolveShapeTextEditorWrapStrategy(shapeTextData: unknown): WrapStrategy;
+export declare function shouldCompleteShapeTextEditingOnPointerDown(target: EventTarget | null, editorElement: HTMLElement | null): boolean;
+export declare function resolveShapeTextEditorTextRect(options: {
+    shapeModel: Pick<IShapeTextModelLike, 'getShapeTextRect'>;
+    hostRect: IShapeRect;
+}): IShapeRect;
+export declare function buildShapeTextEditorCommitShapeText(options: {
+    dataModel?: IShapeTextModel;
+    isHorizontal?: boolean;
+    shapeText?: ICustomShapeTextData | null;
+}): ICustomShapeTextData;
+export declare function createEmptyShapeTextEditorDocument(editorUnitId: string, pageWidth: number): IDocumentData;
+export declare function resolveShapeTextEditorEmptyTextBoxMinSize(options: {
+    isHorizontal: boolean;
+    placeholderWidth: number;
+}): {
+    width: number;
+    height: number;
+};
+export declare function measureShapeTextEditorPlaceholderWidth(documentData: IDocumentData, placeholder: string): number;
+export declare function resolveShapeTextEditorMeasurePageWidth(options: {
+    autoFitNoWrap: boolean;
+    maxAutoFitWidth?: number;
+    textRectWidth: number;
+}): number;
+export declare function measureShapeTextEditorNoWrapContentWidth(documentData: IDocumentData | null | undefined): number;
+export declare function resolveShapeTextEditorRenderedContentWidth(options: {
+    actualWidth: number;
+    autoFitNoWrap: boolean;
+    measuredContentWidth?: number;
+    textRectWidth: number;
+}): number;
+export declare function resolveShapeTextEditorHostContentWidth(options: {
+    actualWidth: number;
+    allowShrink: boolean;
+    autoFitNoWrap: boolean;
+    measuredContentWidth?: number;
+    renderedContentWidth: number;
+}): number;
+export declare function resolveShapeTextEditorFinalPageWidth(options: {
+    autoFitNoWrap: boolean;
+    measurePageWidth?: number;
+    renderedContentWidth: number;
+    textRectWidth: number;
+}): number;
+export declare function resolveShapeTextEditorRenderSurfaceWidth(options: {
+    autoFitNoWrap: boolean;
+    editorWidth: number;
+    measurePageWidth: number;
+    renderedContentWidth?: number;
+    scaleX: number;
+}): number;
 export declare function hasShapeTextEditorHostSizeChanged(options: IShapeTextEditorHostSizeChangeOptions): boolean;
 export declare function resolveShapeTextEditorShouldShrinkHostSize(options: {
     adapter: Pick<IShapeTextEditorAdapter, 'allowHostSizeShrink' | 'updateHostSize'>;
     editingParams: Nullable<IShapeTextEditingParams>;
 }): boolean;
+export declare function shouldDeferShapeTextEditorHostSizeUpdateDuringEditing(options: {
+    adapter: Pick<IShapeTextEditorAdapter, 'deferHostSizeUpdateDuringEditing'>;
+    editingParams: Nullable<IShapeTextEditingParams>;
+}): boolean;
 export declare function resolveShapeTextEditorDocumentVerticalAlign(options: {
     opticalVerticalAlign: boolean;
     verticalAlign: VerticalAlign;
 }): VerticalAlign;
 export declare function resolveShapeTextEditorLayout(options: IShapeTextEditorLayoutOptions): IShapeTextEditorLayout;
+export declare function resolveShapeTextEditorPlaceholderLayout(options: {
+    documentMarginTop: number;
+    editorLeft: number;
+    editorSurfaceWidth?: number;
+    editorTop: number;
+    editorWidth: number;
+    horizontalAlign: HorizontalAlign;
+}): {
+    left: number;
+    textAlign: 'center' | 'left' | 'right';
+    top: number;
+    width: number;
+};
 export declare function resolveShapeTextEditorHostHeight(options: IShapeTextEditorHostHeightOptions): number;
 export declare function resolveShapeTextEditorHostSize(options: IShapeTextEditorHostSizeOptions): {
     width: number;
     height: number;
 };
+export declare function resolveShapeTextEditorPhysicalContentSize(options: {
+    crossAxisLength: number;
+    flowAxis: 'width' | 'height';
+    flowAxisLength: number;
+}): {
+    height: number;
+    width: number;
+};
 export declare function getShapeTextEditorContentStyle(leftOrWidth: number, topOrHeight: number, width?: number, height?: number): CSSProperties;
 export declare function setShapeTextEditorDocumentData(editor: Pick<Editor, 'setDocumentData' | 'clearUndoRedoHistory'>, ...params: Parameters<Editor['setDocumentData']>): void;
+export declare function getShapeTextEditorDocumentData(editor: Pick<Editor, 'getDocumentData' | 'getDocumentDataModel'>): IDocumentData | null;
 export declare function applyShapeTextEditorCanvasTransparency(renderer: {
     engine?: {
         getCanvasElement?: () => HTMLElement | null;
     };
 } | null | undefined | void): void;
-export declare function getShapeTextEditorKeyboardConfig(commandService: Pick<ICommandService, 'executeCommand'>, executeUndoRedoCommand?: (commandId: string) => void): IKeyboardEventConfig;
+export declare function getShapeTextEditorKeyboardConfig(commandService: Pick<ICommandService, 'executeCommand'>, executeUndoRedoCommand?: (commandId: string) => void, options?: IShapeTextEditorKeyboardOptions): IKeyboardEventConfig;
 /**
  * Shape editor component - second layer DOM.
  * Handles document editing, content height tracking, and vertical alignment.
  */
 export declare const ShapeTextEditor: (props: IShapeTextEditorProps) => import("react").JSX.Element;
-export {};

package/lib/types/views/shape-text-editor/ShapeTextEditorContainer.d.ts

@@ -1,4 +1,4 @@
-import type { IShapeTextEditingServiceLike, IShapeTextEditorAdapter, IShapeTextEditorPositionOptions } from './types';
+import type { IShapeTextEditingService, IShapeTextEditorAdapter, IShapeTextEditorPositionOptions } from './types';
 interface IContainerSize {
     width: number;
     height: number;
@@ -9,7 +9,7 @@ export declare function areShapeTextEditorContainerSizesEqual(a: IContainerSize,
 export interface IShapeTextEditorContainerProps {
     adapter: IShapeTextEditorAdapter;
     editorUnitId: string;
-    editingService: IShapeTextEditingServiceLike;
+    editingService: IShapeTextEditingService;
     positionOptions: IShapeTextEditorPositionOptions;
     verticalAlignCommandId?: string;
 }

package/lib/types/views/shape-text-editor/ShapeTextPositionWrapper.d.ts

@@ -1,6 +1,8 @@
 import type { Nullable } from '@univerjs/core';
+import type { Scene } from '@univerjs/engine-render';
 import type { ReactNode } from 'react';
 import type { IShapeTextEditingParams, IShapeTextEditorPositionOptions } from './types';
+import { IRenderManagerService } from '@univerjs/engine-render';
 export interface IShapePositionWrapperProps {
     children: ReactNode;
     editingParams: Nullable<IShapeTextEditingParams>;
@@ -12,6 +14,24 @@ export interface IShapePositionWrapperProps {
         scaleY: number;
     }) => void;
 }
+interface IShapeObjectLike {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    angle?: number;
+    onTransformChange$?: {
+        subscribeEvent: (listener: () => void) => {
+            unsubscribe: () => void;
+        };
+    };
+}
+interface IShapeTextEditorPointerBounds {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
 export declare function isShapeTextEditorPositionReady(editingParams: Nullable<IShapeTextEditingParams>, position: {
     left: number;
     top: number;
@@ -21,8 +41,17 @@ export declare function isShapeTextEditorPositionReady(editingParams: Nullable<I
     scaleX?: number;
     scaleY?: number;
 }): boolean;
+export declare function isShapeTextEditorPointerInsidePositionBounds(event: Pick<MouseEvent | PointerEvent, 'clientX' | 'clientY'>, rect: IShapeTextEditorPointerBounds): boolean;
+export declare function isShapeTextEditorPointerInsideContent(target: EventTarget | null, editorElement: HTMLElement | null): boolean;
+export declare function resolveShapeTextEditorPositionTransform(options: {
+    editingParams: Nullable<IShapeTextEditingParams>;
+    positionOptions: IShapeTextEditorPositionOptions;
+    renderUnit: Nullable<ReturnType<IRenderManagerService['getRenderById']>>;
+    scene: Nullable<Scene>;
+}): Nullable<IShapeObjectLike>;
 /**
  * Position wrapper component that handles shape positioning in DOM.
  * This is the first layer DOM that tracks shape position with scroll.
  */
 export declare const ShapeTextPositionWrapper: import("react").MemoExoticComponent<(props: IShapePositionWrapperProps) => import("react").JSX.Element>;
+export {};

package/lib/types/views/shape-text-editor/hooks/use-shape-position.d.ts

@@ -1,6 +1,6 @@
 import type { Nullable } from '@univerjs/core';
 import type { Scene, SpreadsheetSkeleton } from '@univerjs/engine-render';
-import type { IShapeTextEditingParams, IShapeTextEditorViewportKeys } from '../types';
+import type { IShapeTextEditingParams, IShapeTextEditorPositionOffset, IShapeTextEditorViewportKeys } from '../types';
 export interface IShapePosition {
     left: number;
     top: number;
@@ -15,6 +15,7 @@ export interface IShapePositionResult {
     updatePosition: () => void;
 }
 export declare function areShapePositionsEqual(a: IShapePosition, b: IShapePosition): boolean;
+export declare function offsetShapePosition(position: IShapePosition, offset: Nullable<IShapeTextEditorPositionOffset>): IShapePosition;
 /**
  * Calculate shape position in DOM coordinates.
  */
@@ -31,6 +32,7 @@ export interface IUseShapePositionOptions {
         height: number;
         angle: number;
     }>;
+    getPositionOffset?: () => Nullable<IShapeTextEditorPositionOffset>;
 }
 /**
  * Hook to calculate and track shape position in DOM coordinates.

package/lib/types/views/shape-text-editor/shape-text-behavior.d.ts

@@ -0,0 +1,15 @@
+import type { IShapeData, IShapeTextData } from '@univerjs-pro/engine-shape';
+import type { Nullable, WrapStrategy as WrapStrategyType } from '@univerjs/core';
+export declare function createShapeTextBoxShapeData(options: Pick<IShapeData, 'fill' | 'stroke'> & {
+    isHorizontal: boolean;
+}): IShapeData;
+export declare function resolveShapeTextEditorBehaviorShapeData(shapeData: Nullable<IShapeData> | undefined, shapeTextData: IShapeTextData): IShapeData;
+export declare function resolveShapeTextEditorWrapStrategy(shapeData: IShapeData, fallbackWrapStrategy?: WrapStrategyType): WrapStrategyType;
+export declare function shouldClipShapeTextDocument(shapeData: IShapeData, wrapStrategy?: WrapStrategyType): boolean;
+export declare function shouldAutoFitShapeTextEditorNoWrap(shapeData: IShapeData): boolean;
+export type ShapeTextFlowAxis = 'width' | 'height';
+/** Text layout is horizontal internally; vertical text rotates it onto height. */
+export declare function resolveShapeTextEditorFlowAxis(shapeData: IShapeData): ShapeTextFlowAxis;
+export declare function shouldAllowShapeTextEditorHostSizeShrink(shapeData: Nullable<IShapeData> | undefined, options?: {
+    textLike?: boolean;
+}): boolean;

package/lib/types/views/shape-text-editor/shape-text-document.d.ts

@@ -1,7 +1,8 @@
-import type { IShapeRect } from '@univerjs-pro/engine-shape';
-import type { HorizontalAlign, IDocumentData, VerticalAlign } from '@univerjs/core';
-import { WrapStrategy } from '@univerjs/core';
+import type { IShapeRect, IShapeText, IShapeTextBodyBehavior } from '@univerjs-pro/engine-shape';
+import type { IDocumentData } from '@univerjs/core';
+import { HorizontalAlign, VerticalAlign, WrapStrategy } from '@univerjs/core';
 interface IPrepareShapeTextDocumentOptions {
+    bodyBehavior?: IShapeTextBodyBehavior;
     isHorizontal: boolean;
     textRect: IShapeRect;
     verticalAlign?: VerticalAlign;
@@ -9,10 +10,14 @@ interface IPrepareShapeTextDocumentOptions {
     wrapStrategy?: WrapStrategy;
 }
 interface IShapeTextDocumentAlignmentOptions {
+    bodyBehavior?: IShapeTextBodyBehavior;
     verticalAlign?: VerticalAlign;
     horizontalAlign?: HorizontalAlign;
 }
+export declare function plainShapeTextToDocumentData(shapeText: IShapeText, id?: string): IDocumentData;
 export declare function resolveShapeTextDocumentAlignment(documentData: IDocumentData, fallback?: IShapeTextDocumentAlignmentOptions): IShapeTextDocumentAlignmentOptions;
 export declare function prepareShapeTextDocumentData(documentData: IDocumentData, options: IPrepareShapeTextDocumentOptions): IDocumentData;
+export declare function resolveShapeTextDocumentPageHeight(documentData: IDocumentData, viewportHeight: number): number;
 export declare function stripShapeTextDocumentLayout(documentData: IDocumentData, options?: IShapeTextDocumentAlignmentOptions): IDocumentData;
+export declare function createEditableShapeTextDocumentDataCopy(documentData: IDocumentData): IDocumentData;
 export {};

package/lib/types/views/shape-text-editor/shape-text-editor-commands.d.ts

@@ -0,0 +1,4 @@
+export declare const SHAPE_TEXT_EDITOR_HYPERLINK_EDIT_OPERATION_ID = "doc.operation.show-hyper-link-edit-popup";
+export declare const SHAPE_TEXT_EDITOR_CALLOUT_COMMAND_ID = "docs-callout.command.insert";
+export declare const SHAPE_TEXT_EDITOR_CODE_COMMAND_ID = "docs-code.command.insert";
+export declare const SHAPE_TEXT_EDITOR_QUOTE_COMMAND_ID = "docs-quote.command.insert";

package/lib/types/views/shape-text-editor/shape-text-layout.d.ts

@@ -0,0 +1,24 @@
+import type { DocumentSkeleton } from '@univerjs/engine-render';
+import { VerticalAlign } from '@univerjs/core';
+export interface IResolveShapeTextVerticalOffsetOptions {
+    contentHeight: number;
+    verticalAlign?: VerticalAlign;
+    viewportHeight: number;
+}
+export interface IShapeTextDocumentRenderLayout {
+    clipHeight: number;
+    clipTop: number;
+    contentHeight: number;
+    contentVerticalOffset: number;
+    marginTop: number;
+    verticalOffset: number;
+}
+export interface IResolveShapeTextDocumentRenderLayoutOptions extends IResolveShapeTextVerticalOffsetOptions {
+    opticalVerticalOffset?: number;
+    verticalOffset?: number;
+}
+export declare function isShapeTextOpticalVerticalAlignEnabled(value: unknown): boolean;
+export declare function resolveShapeTextVerticalOffset(options: IResolveShapeTextVerticalOffsetOptions): number;
+export declare function resolveShapeTextDocumentRenderLayout(options: IResolveShapeTextDocumentRenderLayoutOptions): IShapeTextDocumentRenderLayout;
+export declare function getShapeTextContentHeight(skeleton: DocumentSkeleton, fallbackHeight?: number): number;
+export declare function getShapeTextOpticalVerticalOffset(skeleton: DocumentSkeleton, targetHeight: number, verticalAlign?: VerticalAlign): number;

package/lib/types/views/shape-text-editor/shape-text-no-wrap-layout.d.ts

@@ -0,0 +1,24 @@
+import type { ShapeTextHorizontalAnchor, ShapeTextWrapType } from '@univerjs-pro/engine-shape';
+import type { IDocumentData } from '@univerjs/core';
+import { HorizontalAlign } from '@univerjs/core';
+export interface IShapeTextNoWrapRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface IShapeTextNoWrapLayout {
+    contentWidth: number;
+    measureAsNoWrap: boolean;
+    textRect: IShapeTextNoWrapRect;
+}
+export interface IResolveShapeTextNoWrapLayoutOptions {
+    documentData?: IDocumentData;
+    horizontalAlign?: HorizontalAlign;
+    horizontalAnchor?: ShapeTextHorizontalAnchor;
+    isHorizontal?: boolean;
+    textRect: IShapeTextNoWrapRect;
+    textWrap?: ShapeTextWrapType;
+    widthBuffer?: number;
+}
+export declare function resolveShapeTextNoWrapLayout(options: IResolveShapeTextNoWrapLayoutOptions): IShapeTextNoWrapLayout;