@univerjs/engine-render 0.1.12 → 0.1.13

package/lib/types/components/sheets/interfaces.d.ts

@@ -1,6 +1,9 @@
 import { BorderStyleTypes, HorizontalAlign, ISelectionCellWithCoord, ObjectMatrix, VerticalAlign, WrapStrategy } from '@univerjs/core';
 import { BORDER_TYPE } from '../../basics/const';
 import { DocumentSkeleton } from '../docs/layout/doc-skeleton';
+import { Canvas } from '../../canvas';
+import { UniverRenderingContext } from '../../context';
+import { ISheetFontRenderExtension } from './extensions';
 
 export interface BorderCache {
     [key: string]: BorderCacheItem | {};
@@ -34,4 +37,48 @@ export declare enum ShowGridlinesState {
     OFF = 0,
     ON = 1
 }
+export declare enum SHEET_VIEWPORT_KEY {
+    VIEW_MAIN = "viewMain",
+    VIEW_MAIN_LEFT_TOP = "viewMainLeftTop",
+    VIEW_MAIN_TOP = "viewMainTop",
+    VIEW_MAIN_LEFT = "viewMainLeft",
+    VIEW_ROW_TOP = "viewRowTop",
+    VIEW_ROW_BOTTOM = "viewRowBottom",
+    VIEW_COLUMN_LEFT = "viewColumnLeft",
+    VIEW_COLUMN_RIGHT = "viewColumnRight",
+    VIEW_LEFT_TOP = "viewLeftTop"
+}
+export interface IPaintForRefresh {
+    cacheCanvas: Canvas;
+    cacheCtx: UniverRenderingContext;
+    mainCtx: UniverRenderingContext;
+    topOrigin: number;
+    leftOrigin: number;
+    bufferEdgeX: number;
+    bufferEdgeY: number;
+}
+export interface IPaintForScrolling {
+    cacheCanvas: Canvas;
+    cacheCtx: UniverRenderingContext;
+    mainCtx: UniverRenderingContext;
+    topOrigin: number;
+    leftOrigin: number;
+    bufferEdgeX: number;
+    bufferEdgeY: number;
+    rowHeaderWidth: number;
+    columnHeaderHeight: number;
+    scaleX: number;
+    scaleY: number;
+}
+export type ISheetRenderExtension = ISheetFontRenderExtension & ISheetBackgroundRenderExtension & ISheetBorderRenderExtension;
+export interface ISheetBackgroundRenderExtension {
+    backgroundRenderExtension?: {
+        isSkip?: boolean;
+    };
+}
+export interface ISheetBorderRenderExtension {
+    borderRenderExtension?: {
+        isSkip?: boolean;
+    };
+}
 export {};

package/lib/types/components/sheets/row-header.d.ts

@@ -1,5 +1,5 @@
 import { Nullable } from '@univerjs/core';
-import { IViewportBound, Vector2 } from '../../basics/vector2';
+import { IViewportInfo, Vector2 } from '../../basics/vector2';
 import { UniverRenderingContext } from '../../context';
 import { RowHeaderLayout } from './extensions/row-header-layout';
 import { SpreadsheetHeader } from './sheet-component';
@@ -22,7 +22,7 @@ export declare class SpreadsheetRowHeader extends SpreadsheetHeader {
     private _rowHeaderLayoutExtension;
     constructor(oKey: string, spreadsheetSkeleton?: SpreadsheetSkeleton);
     get rowHeaderLayoutExtension(): RowHeaderLayout;
-    draw(ctx: UniverRenderingContext, bounds?: IViewportBound): void;
+    draw(ctx: UniverRenderingContext, bounds?: IViewportInfo): void;
     isHit(coord: Vector2): boolean;
     private _initialDefaultExtension;
 }

package/lib/types/components/sheets/sheet-component.d.ts

@@ -1,5 +1,5 @@
 import { IRange, Nullable } from '@univerjs/core';
-import { IViewportBound, Vector2 } from '../../basics/vector2';
+import { IViewportInfo, Vector2 } from '../../basics/vector2';
 import { UniverRenderingContext } from '../../context';
 import { RenderComponent } from '../component';
 import { SHEET_EXTENSION_TYPE } from './extensions/sheet-extension';
@@ -10,7 +10,7 @@ export declare abstract class SheetComponent extends RenderComponent<Spreadsheet
     constructor(oKey: string, _skeleton?: SpreadsheetSkeleton | undefined);
     getSkeleton(): SpreadsheetSkeleton | undefined;
     updateSkeleton(spreadsheetSkeleton: SpreadsheetSkeleton): void;
-    render(mainCtx: UniverRenderingContext, bounds?: IViewportBound): this | undefined;
+    render(mainCtx: UniverRenderingContext, bounds?: IViewportInfo): this | undefined;
     getParentScale(): {
         scaleX: number;
         scaleY: number;
@@ -32,12 +32,12 @@ export declare abstract class SheetComponent extends RenderComponent<Spreadsheet
         endRow: number;
         endColumn: number;
     }>;
-    protected abstract _draw(ctx: UniverRenderingContext, bounds?: IViewportBound): void;
+    protected abstract _draw(ctx: UniverRenderingContext, bounds?: IViewportInfo): void;
     /**
      * TODO: DR-Univer, fix as unknown as
      */
     dispose(): void;
 }
 export declare abstract class SpreadsheetHeader extends SheetComponent {
-    protected _draw(ctx: UniverRenderingContext, bounds?: IViewportBound): void;
+    protected _draw(ctx: UniverRenderingContext, bounds?: IViewportInfo): void;
 }

package/lib/types/components/sheets/sheet-skeleton.d.ts

@@ -1,5 +1,5 @@
 import { BooleanNumber, DocumentDataModel, HorizontalAlign, IContextService, LocaleService, ObjectMatrix, VerticalAlign, WrapStrategy, ICellData, IPaddingData, IRange, ISelectionCellWithCoord, ITextRotation, IWorksheetData, Nullable, Styles, Worksheet } from '@univerjs/core';
-import { IBoundRectNoAngle, IViewportBound } from '../../basics/vector2';
+import { IBoundRectNoAngle, IViewportInfo } from '../../basics/vector2';
 import { DocumentSkeleton } from '../docs/layout/doc-skeleton';
 import { Skeleton } from '../skeleton';
 import { IStylesCache } from './interfaces';
@@ -50,6 +50,9 @@ export declare class SpreadsheetSkeleton extends Skeleton {
     private _columnTotalWidth;
     private _rowHeaderWidth;
     private _columnHeaderHeight;
+    /**
+     * skeletonData(row col range) of visible area
+     */
     private _rowColumnSegment;
     private _dataMergeCache;
     private _overflowCache;
@@ -101,30 +104,20 @@ export declare class SpreadsheetSkeleton extends Skeleton {
     setOverflowCache(value: ObjectMatrix<IRange>): void;
     setMarginLeft(left: number): void;
     setMarginTop(top: number): void;
-    calculateSegment(bounds?: IViewportBound): true | undefined;
-    calculateWithoutClearingCache(bounds?: IViewportBound): this | undefined;
-    calculate(bounds?: IViewportBound): this;
+    calculateSegment(bounds?: IViewportInfo): true | undefined;
+    calculateWithoutClearingCache(bounds?: IViewportInfo): this | undefined;
+    calculate(bounds?: IViewportInfo): this;
     calculateAutoHeightInRange(ranges: Nullable<IRange[]>): IRowAutoHeightInfo[];
     private _calculateRowAutoHeight;
     private _updateLayout;
     private _dynamicallyUpdateRowHeaderWidth;
-    getRowColumnSegment(bounds?: IViewportBound): {
-        startRow: number;
-        endRow: number;
-        startColumn: number;
-        endColumn: number;
-    };
+    getRowColumnSegment(bounds?: IViewportInfo): IRange;
     /**
      * @deprecated should never expose a property that is provided by another module!
      * @returns
      */
     getWorksheetConfig(): IWorksheetData;
-    getRowColumnSegmentByViewBound(bound?: IBoundRectNoAngle): {
-        startRow: number;
-        endRow: number;
-        startColumn: number;
-        endColumn: number;
-    };
+    getRowColumnSegmentByViewBound(bound?: IBoundRectNoAngle): IRange;
     getMergeBounding(startRow: number, startColumn: number, endRow: number, endColumn: number): {
         startRow: number;
         startColumn: number;
@@ -284,12 +277,7 @@ export declare class SpreadsheetSkeleton extends Skeleton {
      * @param viewBound The range of the visible area of the canvas
      * @returns The range cell index of the canvas visible area
      */
-    protected _getBounding(rowHeightAccumulation: number[], columnWidthAccumulation: number[], viewBound?: IBoundRectNoAngle): {
-        startRow: number;
-        endRow: number;
-        startColumn: number;
-        endColumn: number;
-    };
+    protected _getBounding(rowHeightAccumulation: number[], columnWidthAccumulation: number[], viewBound?: IBoundRectNoAngle): IRange;
     private _generateRowMatrixCache;
     private _generateColumnMatrixCache;
     private _getOverflowBound;

package/lib/types/components/sheets/spreadsheet.d.ts

@@ -1,4 +1,5 @@
-import { IViewportBound, Vector2 } from '../../basics/vector2';
+import { IBoundRectNoAngle, IViewportInfo, Vector2 } from '../../basics/vector2';
+import { Canvas } from '../../canvas';
 import { UniverRenderingContext } from '../../context';
 import { Documents } from '../docs/document';
 import { Background } from './extensions/background';
@@ -6,15 +7,15 @@ import { Border } from './extensions/border';
 import { Font } from './extensions/font';
 import { SheetComponent } from './sheet-component';
 import { SpreadsheetSkeleton } from './sheet-skeleton';
+import { IPaintForRefresh, IPaintForScrolling, SHEET_VIEWPORT_KEY } from './interfaces';
 
 export declare class Spreadsheet extends SheetComponent {
     private _allowCache;
     private _backgroundExtension;
     private _borderExtension;
     private _fontExtension;
-    private _cacheCanvas;
     private _refreshIncrementalState;
-    private _forceDirty;
+    private _dirtyBounds;
     private _forceDisableGridlines;
     private _documents;
     isPrinting: boolean;
@@ -29,7 +30,14 @@ export declare class Spreadsheet extends SheetComponent {
      * TODO: DR-Univer, fix as unknown as
      */
     dispose(): void;
-    draw(ctx: UniverRenderingContext, bounds?: IViewportBound): void;
+    /**
+     * draw by viewport
+     * cacheBound ---> viewBound
+     * diffCacheBounds ---> diffRange
+     * @param ctx
+     * @param viewportInfo
+     */
+    draw(ctx: UniverRenderingContext, viewportInfo: IViewportInfo): void;
     isHit(coord: Vector2): boolean;
     getNoMergeCellPositionByIndex(rowIndex: number, columnIndex: number): {
         startY: number;
@@ -41,6 +49,11 @@ export declare class Spreadsheet extends SheetComponent {
         x: number;
         y: number;
     };
+    isForceDirty(): boolean;
+    /**
+     * canvas resize & zoom would call forceDirty
+     * @param state
+     */
     makeForceDirty(state?: boolean): void;
     setForceDisableGridlines(disabled: boolean): void;
     getSelectionBounding(startRow: number, startColumn: number, endRow: number, endColumn: number): {
@@ -49,20 +62,48 @@ export declare class Spreadsheet extends SheetComponent {
         endRow: number;
         endColumn: number;
     } | undefined;
-    render(mainCtx: UniverRenderingContext, bounds?: IViewportBound): this | undefined;
-    private _resizeCacheCanvas;
-    protected _applyCache(ctx?: UniverRenderingContext, sx?: number, sy?: number, sw?: number, sh?: number, dx?: number, dy?: number, dw?: number, dh?: number): void;
-    protected _draw(ctx: UniverRenderingContext, bounds?: IViewportBound): void;
+    /**
+     * @param state
+     */
+    makeDirty(state?: boolean): this;
+    setDirtyArea(dirtyBounds: IBoundRectNoAngle[]): void;
+    renderByViewport(mainCtx: UniverRenderingContext, viewportInfo: IViewportInfo, spreadsheetSkeleton: SpreadsheetSkeleton): void;
+    paintNewAreaForScrolling(viewportInfo: IViewportInfo, param: IPaintForScrolling): void;
+    /**
+     * Redraw the entire viewport.
+     */
+    refreshCacheCanvas(viewportInfo: IViewportInfo, param: IPaintForRefresh): void;
+    render(mainCtx: UniverRenderingContext, viewportInfo: IViewportInfo): this | undefined;
+    /**
+     * applyCache from cache canvas
+     * @param cacheCanvas Source Image
+     * @param ctx MainCtx
+     * @param sx
+     * @param sy
+     * @param sw
+     * @param sh
+     * @param dx
+     * @param dy
+     * @param dw
+     * @param dh
+     */
+    protected _applyCache(cacheCanvas: Canvas, ctx: UniverRenderingContext, sx?: number, sy?: number, sw?: number, sh?: number, dx?: number, dy?: number, dw?: number, dh?: number): void;
+    protected _draw(ctx: UniverRenderingContext, bounds?: IViewportInfo): void;
     private _getAncestorSize;
     private _getAncestorParent;
     private _initialDefaultExtension;
-    private _addMakeDirtyToScroll;
-    private _hasScrollViewportOperator;
-    private _getHasScrollViewports;
+    /**
+     * draw gridlines
+     * @param ctx
+     */
     private _drawAuxiliary;
     /**
      * Clear the guide lines within a range in the table, to make room for merged cells and overflow.
      */
     private _clearRectangle;
     private _clearBackground;
+    sheetContentViewport(): SHEET_VIEWPORT_KEY[];
+    sheetHeaderViewport(): SHEET_VIEWPORT_KEY[];
+    testShowRuler(cacheCtx: UniverRenderingContext, viewportInfo: IViewportInfo): void;
+    testGetRandomLightColor(): string;
 }

package/lib/types/custom/custom-object.d.ts

@@ -1,5 +1,5 @@
 import { BaseObject } from '../base-object';
-import { IViewportBound, Vector2 } from '../basics/vector2';
+import { IViewportInfo, Vector2 } from '../basics/vector2';
 import { UniverRenderingContext } from '../context';
 
 export declare class CustomObject extends BaseObject {
@@ -9,6 +9,6 @@ export declare class CustomObject extends BaseObject {
     toJson(): {
         [x: string]: any;
     };
-    render(mainCtx: UniverRenderingContext, bounds?: IViewportBound): this;
+    render(mainCtx: UniverRenderingContext, bounds?: IViewportInfo): this;
     isHit(coord: Vector2): boolean;
 }

package/lib/types/group.d.ts

@@ -1,19 +1,39 @@
 import { BaseObject } from './base-object';
 import { CURSOR_TYPE, RENDER_CLASS_TYPE } from './basics/const';
-import { IViewportBound, Vector2 } from './basics/vector2';
+import { IViewportInfo, Vector2 } from './basics/vector2';
 import { UniverRenderingContext } from './context';
 
 export declare class Group extends BaseObject {
     private _objects;
+    private _selfSizeMode;
     constructor(key?: string, ...objects: BaseObject[]);
     get classType(): RENDER_CLASS_TYPE;
     set cursor(val: CURSOR_TYPE);
+    getState(): import('@univerjs/core').ITransformState | {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        angle: number;
+        scaleX: number;
+        scaleY: number;
+    };
+    get width(): number;
+    get height(): number;
+    set width(val: number);
+    set height(val: number);
+    get maxZIndex(): number;
+    openSelfSizeMode(): void;
+    closeSelfSizeMode(): void;
+    reCalculateObjects(): void;
     addObjects(...objects: BaseObject[]): void;
     addObject(o: BaseObject | string): void;
     removeObject(object: BaseObject | string): void;
+    removeSelfObjectAndTransform(oKey: string, width?: number, height?: number, isTransform?: boolean): void;
+    private _transformObject;
     getObjectsByOrder(): BaseObject[];
     getObjects(): BaseObject[];
-    render(ctx: UniverRenderingContext, bounds?: IViewportBound): void;
+    render(ctx: UniverRenderingContext, bounds?: IViewportInfo): void;
     resize(width?: number | string, height?: number | string): this;
     scale(scaleX?: number, scaleY?: number): this;
     skew(skewX?: number, skewY?: number): this;

package/lib/types/index.d.ts

@@ -42,3 +42,4 @@ export type { IPageRenderConfig } from './components/docs/document';
 export { DocumentSkeleton } from './components/docs/layout/doc-skeleton';
 export { ThinEngine } from './thin-engine';
 export { getCharSpaceApply, getNumberUnitValue } from './components/docs/layout/tools';
+export { type IChangeObserverConfig } from './scene.transformer';

package/lib/types/layer.d.ts

@@ -1,7 +1,7 @@
 import { Disposable } from '@univerjs/core';
 import { BaseObject } from './base-object';
 import { UniverRenderingContext } from './context';
-import { ThinScene } from './thin-scene';
+import { Scene } from './scene';
 
 export declare class Layer extends Disposable {
     private _scene;
@@ -11,8 +11,8 @@ export declare class Layer extends Disposable {
     private _cacheCanvas;
     protected _dirty: boolean;
     private _debounceDirtyFunc;
-    constructor(_scene: ThinScene, objects?: BaseObject[], _zIndex?: number, _allowCache?: boolean);
-    get scene(): ThinScene;
+    constructor(_scene: Scene, objects?: BaseObject[], _zIndex?: number, _allowCache?: boolean);
+    get scene(): Scene;
     get zIndex(): number;
     enableCache(): void;
     disableCache(): void;

package/lib/types/scene-viewer.d.ts

@@ -2,7 +2,7 @@ import { Nullable } from '@univerjs/core';
 import { BaseObject } from './base-object';
 import { RENDER_CLASS_TYPE } from './basics/const';
 import { IObjectFullState } from './basics/interfaces';
-import { IViewportBound, Vector2 } from './basics/vector2';
+import { IViewportInfo, Vector2 } from './basics/vector2';
 import { UniverRenderingContext } from './context';
 import { ThinScene } from './thin-scene';
 
@@ -12,7 +12,7 @@ export declare class SceneViewer extends BaseObject {
     private _allowSelectedClipElement;
     constructor(key?: string, props?: IObjectFullState);
     get classType(): RENDER_CLASS_TYPE;
-    render(mainCtx: UniverRenderingContext, bounds?: IViewportBound): this;
+    render(mainCtx: UniverRenderingContext, bounds?: IViewportInfo): this;
     getSubScenes(): Map<string, ThinScene>;
     getActiveSubScene(): Nullable<ThinScene>;
     getSubScene(sceneKey: string): ThinScene | undefined;
@@ -22,7 +22,7 @@ export declare class SceneViewer extends BaseObject {
     enableSelectedClipElement(): void;
     disableSelectedClipElement(): void;
     allowSelectedClipElement(): boolean;
-    pick(coord: Vector2): Nullable<ThinScene | BaseObject>;
+    pick(coord: Vector2): Nullable<BaseObject | ThinScene>;
     dispose(): void;
     private _initialProps;
 }

package/lib/types/scene.d.ts

@@ -6,11 +6,12 @@ import { ISceneTransformState } from './basics/interfaces';
 import { Vector2 } from './basics/vector2';
 import { UniverRenderingContext } from './context';
 import { Layer } from './layer';
-import { ITransformerConfig, Transformer } from './scene.transformer';
+import { Transformer } from './scene.transformer';
 import { SceneViewer } from './scene-viewer';
 import { ThinEngine } from './thin-engine';
 import { ThinScene } from './thin-scene';
 import { Viewport } from './viewport';
+import { ITransformerConfig } from './basics/transformer-config';
 
 export declare class Scene extends ThinScene {
     private _parent;
@@ -26,12 +27,13 @@ export declare class Scene extends ThinScene {
      * when you resize them. Instead it changes `scaleX` and `scaleY` properties.
      */
     private _transformer;
-    private _transformerOpenState;
     /** @hidden */
     private _inputManager;
     constructor(sceneKey: string, _parent: ThinEngine<Scene> | SceneViewer, state?: ISceneTransformState);
     get ancestorScaleX(): number;
     get ancestorScaleY(): number;
+    get ancestorLeft(): number;
+    get ancestorTop(): number;
     set cursor(val: CURSOR_TYPE);
     attachControl(hasDown?: boolean, hasUp?: boolean, hasMove?: boolean, hasWheel?: boolean): this | undefined;
     detachControl(): this;
@@ -69,6 +71,7 @@ export declare class Scene extends ThinScene {
     getAllObjectsByOrder(isDesc?: boolean): BaseObject[];
     getAllObjectsByOrderForPick(isDesc?: boolean): BaseObject[];
     getObject(oKey: string): BaseObject | undefined;
+    getObjectIncludeInGroup(oKey: string): BaseObject | undefined;
     fuzzyMathObjects(oKey: string): BaseObject[];
     addViewport(...viewport: Viewport[]): this;
     removeViewport(key: string): Viewport | undefined;
@@ -76,9 +79,10 @@ export declare class Scene extends ThinScene {
     getViewport(key: string): Viewport | undefined;
     render(parentCtx?: UniverRenderingContext): void;
     requestRender(parentCtx?: UniverRenderingContext): Promise<unknown>;
-    openTransformer(config?: ITransformerConfig): void;
-    closeTransformer(isDestroyed?: boolean): void;
-    applyTransformer(o: BaseObject): void;
+    attachTransformerTo(o: BaseObject): void;
+    detachTransformerFrom(o: BaseObject): void;
+    initTransformer(config?: ITransformerConfig): void;
+    getTransformerByCreate(): Transformer;
     getTransformer(): Nullable<Transformer>;
     getActiveViewportByRelativeCoord(coord: Vector2): Viewport | undefined;
     getActiveViewportByCoord(coord: Vector2): Viewport | undefined;

package/lib/types/scene.transformer.d.ts

@@ -2,49 +2,21 @@ import { Nullable, Disposable, Observable } from '@univerjs/core';
 import { BaseObject } from './base-object';
 import { IMouseEvent, IPointerEvent } from './basics/i-events';
 import { Group } from './group';
-import { ThinScene } from './thin-scene';
+import { Scene } from './scene';
+import { ITransformerConfig } from './basics/transformer-config';
 
 declare enum MoveObserverType {
     MOVE_START = 0,
     MOVING = 1,
     MOVE_END = 2
 }
-interface IChangeObserverConfig {
+export interface IChangeObserverConfig {
     objects: Map<string, BaseObject>;
     moveX?: number;
     moveY?: number;
+    angle?: number;
     type: MoveObserverType;
 }
-export interface ITransformerConfig {
-    hoverEnabled?: boolean;
-    hoverEnterFunc?: Nullable<(e: IPointerEvent | IMouseEvent) => void>;
-    hoverLeaveFunc?: Nullable<(e: IPointerEvent | IMouseEvent) => void>;
-    rotateEnabled?: boolean;
-    rotationSnaps?: number[];
-    rotationSnapTolerance?: number;
-    rotateAnchorOffset?: number;
-    rotateSize?: number;
-    rotateCornerRadius?: number;
-    borderEnabled?: boolean;
-    borderStroke?: string;
-    borderStrokeWidth?: number;
-    borderDash?: number[];
-    borderSpacing: number;
-    resizeEnabled?: boolean;
-    enabledAnchors?: number[];
-    anchorFill?: string;
-    anchorStroke?: string;
-    anchorStrokeWidth?: number;
-    anchorSize?: number;
-    anchorCornerRadius?: number;
-    keepRatio?: boolean;
-    centeredScaling?: boolean;
-    flipEnabled?: boolean;
-    ignoreStroke?: boolean;
-    boundBoxFunc?: Nullable<(oldBox: BaseObject, newBox: BaseObject) => BaseObject>;
-    useSingleNodeRotation?: boolean;
-    shouldOverdrawWholeArea?: boolean;
-}
 /**
  * Transformer constructor.  Transformer is a special type of group that allow you transform
  * primitives and shapes. Transforming tool is not changing `width` and `height` properties of nodes
@@ -52,6 +24,7 @@ export interface ITransformerConfig {
  */
 export declare class Transformer extends Disposable implements ITransformerConfig {
     private _scene;
+    isCropper: boolean;
     hoverEnabled: boolean;
     hoverEnterFunc: Nullable<(e: IPointerEvent | IMouseEvent) => void>;
     hoverLeaveFunc: Nullable<(e: IPointerEvent | IMouseEvent) => void>;
@@ -74,6 +47,8 @@ export declare class Transformer extends Disposable implements ITransformerConfi
     anchorCornerRadius: number;
     keepRatio: boolean;
     centeredScaling: boolean;
+    zeroLeft: number;
+    zeroTop: number;
     /**
      * leftTop centerTop rightTop
      * leftMiddle rightMiddle
@@ -88,10 +63,11 @@ export declare class Transformer extends Disposable implements ITransformerConfi
     onChangeStartObservable: Observable<IChangeObserverConfig>;
     onChangingObservable: Observable<IChangeObserverConfig>;
     onChangeEndObservable: Observable<IChangeObserverConfig>;
-    onClearControlObservable: Observable<null>;
+    onClearControlObservable: Observable<boolean>;
     onCreateControlObservable: Observable<Group>;
     private _startOffsetX;
     private _startOffsetY;
+    private _startStateMap;
     private _viewportScrollX;
     private _viewportScrollY;
     private _moveObserver;
@@ -99,30 +75,73 @@ export declare class Transformer extends Disposable implements ITransformerConfi
     private _cancelFocusObserver;
     private _transformerControlMap;
     private _selectedObjectMap;
-    constructor(_scene: ThinScene, config?: ITransformerConfig);
-    getScene(): ThinScene;
-    hideControl(): void;
-    attachTo(applyObject: BaseObject): BaseObject | undefined;
+    private _observerObjectMap;
+    private _copperControl;
+    private _copperSelectedObject;
+    private _moveBufferSkip;
+    private _debounceClearFunc;
+    constructor(_scene: Scene, config?: ITransformerConfig);
+    changeNotification(): this;
+    getSelectedObjectMap(): Map<string, BaseObject>;
+    resetProps(config?: ITransformerConfig): void;
+    getScene(): Scene;
+    clearControls(changeSelf?: boolean): void;
+    updateControl(): void;
+    debounceRefreshControls(): void;
+    clearSelectedObjects(): void;
+    refreshControls(): this;
+    createControlForCopper(applyObject: BaseObject): void;
+    clearCopperControl(): void;
+    setSelectedControl(applyObject: BaseObject): void;
+    private _getConfig;
+    attachTo(applyObject: BaseObject): BaseObject;
+    detachFrom(applyObject: BaseObject): BaseObject;
     dispose(): void;
     private _initialProps;
-    private _updateControlChildren;
+    private _checkMoveBoundary;
+    private _moving;
+    private _moveBufferBlocker;
     private _anchorMoving;
+    private _moveFunc;
+    private _getMovePoint;
+    /**
+     *
+     */
+    private _applyRotationForResult;
+    private _updateCloseKeepRatioState;
+    private _getLimitedSize;
+    private _resizeLeftTop;
+    private _resizeRightBottom;
+    private _resizeLeftBottom;
+    private _resizeRightTop;
+    private _fixMoveLtRb;
+    private _fixMoveLbRt;
     private _attachEventToAnchor;
+    private _recoverySizeBoundary;
     private _attachEventToRotate;
+    private _rotateMoving;
     private _getOutlinePosition;
     private _getRotateAnchorCursor;
+    private _getCopperAnchorPosition;
     private _getRotateAnchorPosition;
     private _createResizeAnchor;
+    private _createCopperResizeAnchor;
+    private _getNorthEastPoints;
+    private _getNorthWestPoints;
+    private _getSouthEastPoints;
+    private _getSouthWestPoints;
     private _checkTransformerType;
     private _updateControlIterator;
     private _updateControl;
     private _hideControl;
     private _attachHover;
-    private _clearControl;
+    private _clearControls;
+    private _clearControlMap;
     private _createControl;
     private _getTopScene;
-    private _moving;
     private _updateActiveObjectList;
+    private _findGroupObject;
     private _addCancelObserver;
+    private _smoothAccuracy;
 }
 export {};

package/lib/types/shape/image.d.ts

@@ -0,0 +1,54 @@
+import { ISrcRect, Nullable, PresetGeometryType } from '@univerjs/core';
+import { UniverRenderingContext } from '../context';
+import { IObjectFullState, IViewportInfo, RENDER_CLASS_TYPE } from '../basics';
+import { IShapeProps, Shape } from './shape';
+
+export interface IImageProps extends IShapeProps {
+    image?: HTMLImageElement;
+    url?: string;
+    success?: () => void;
+    fail?: () => void;
+    /**
+     * 20.1.8.55 srcRect (Source Rectangle)
+     */
+    srcRect?: Nullable<ISrcRect>;
+    /**
+     * 20.1.9.18 prstGeom (Preset geometry)
+     */
+    prstGeom?: Nullable<PresetGeometryType>;
+}
+export declare class Image extends Shape<IImageProps> {
+    protected _props: IImageProps;
+    protected _native: Nullable<HTMLImageElement>;
+    private _renderByCropper;
+    private _transformCalculateSrcRect;
+    constructor(id: string, config: IImageProps);
+    get srcRect(): Nullable<ISrcRect>;
+    get prstGeom(): Nullable<PresetGeometryType>;
+    get classType(): RENDER_CLASS_TYPE;
+    transformByStateCloseCropper(option: IObjectFullState): void;
+    changeSource(url: string): void;
+    resetSize(): void;
+    setPrstGeom(prstGeom?: Nullable<PresetGeometryType>): void;
+    setSrcRect(srcRect?: Nullable<ISrcRect>): void;
+    getProps(): IImageProps;
+    getNative(): Nullable<HTMLImageElement>;
+    getNativeSize(): {
+        width: number;
+        height: number;
+    };
+    closeRenderByCropper(): void;
+    openRenderByCropper(): void;
+    calculateTransformWithSrcRect(): {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        angle: number;
+    };
+    private _transformBySrcRect;
+    render(mainCtx: UniverRenderingContext, bounds?: IViewportInfo): this;
+    protected _draw(ctx: UniverRenderingContext): void;
+    private _init;
+    private _updateSrcRectByTransform;
+}

package/lib/types/shape/index.d.ts

@@ -17,7 +17,7 @@ export * from './circle';
 export * from './control';
 export * from './drawing';
 export * from './path';
-export * from './picture';
+export * from './image';
 export * from './rect';
 export * from './regular-polygon';
 export * from './rich-text';