@leafer-ui/interface 1.0.0-rc.9 → 1.0.1

package/types/index.d.ts

@@ -1,6 +1,6 @@
-import { IPointData, IExportFileType, ISizeData, IWindingRule, IPathCommandData, IBlendMode, IMatrixData, ILeaferImage, ITaskItem, IBlob, ILeaf, IPathString, IPathCreator, IBoundsData, ILeaferImageConfig, ILeaferCanvas, IRenderOptions, IPathDrawer, AnswerType, ILeafData, IPath2D, ILeafComputedData, ILeafInputData, IObject, ILeaferAttrData, IControl, ILeaferConfig, ILeafRender, ILeafBounds, ILeafHit, ICachedLeaf, IBooleanMap } from '@leafer/interface';
+import { IAlign, IUnitPointData, IExportFileType, IFourNumber, IPointData, ISizeData, IPathCommandData, IWindingRule, IBlendMode, IMatrixData, ILeaferImage, ITaskItem, IBoolean, INumber, IString, IUnitData, IPathCreator, IBoundsData as IBoundsData$1, ILeaferImageConfig, ICanvasContext2DSettings, ILeaferCanvas, ICanvasContext2D, IRenderOptions, IPickOptions, IPickResult, ILeaf as ILeaf$1, IJSONOptions, IValue, IFindCondition, IPathString, IPathDrawer, IExportOptions, IExportResult, IAnswer, ILeafData, ILeafComputedData, ILeafInputData, IObject as IObject$1, ILeaferAttrData, IControl, ILeaferConfig, ILeaferType, ILeafRender, ILeafBounds, ILeafHit, IStateStyleType, ICachedLeaf, IBooleanMap, IAround } from '@leafer/interface';
 export * from '@leafer/interface';
-import { IGroup as IGroup$1, ISelectorProxy, IUI as IUI$1, IObject as IObject$1, ILeaf as ILeaf$1, IEditSize, IDragEvent, IRotateEvent, IStroke as IStroke$1, IFill as IFill$1, IBoxInputData as IBoxInputData$1, IRectInputData as IRectInputData$1, ICursorType, IAround } from '@leafer-ui/interface';
+import { IGroup as IGroup$1, ISelectorProxy, IUI as IUI$1, ILeafList, IObject, ILeaf, IEditSize, IDragEvent, IZoomEvent, IRotateEvent, IGroupInputData as IGroupInputData$1, IStroke as IStroke$1, IFill as IFill$1, IBoxInputData as IBoxInputData$1, IRectInputData as IRectInputData$1, IColorString as IColorString$1, IDirection4, ICursorType, IImageCursor, IAlign as IAlign$1, IUnitPointData as IUnitPointData$1, IUIInputData as IUIInputData$1, IBox as IBox$1, IRect as IRect$1, IBoundsData, IKeyEvent } from '@leafer-ui/interface';
 
 type IPercent = string;
 type IColorString = string;
@@ -13,13 +13,10 @@ type IGradientPaintString = string;
 type IImagePaintString = string;
 type IShadowString = string;
 
-interface IUnitData {
-    type: 'percent' | 'px';
-    value: number;
-}
 type IPaint = ISolidPaint | IGradientPaint | IImagePaint;
 type IFill = IPaint | IPaint[] | IPaintString;
 type IStroke = IPaint | IPaint[] | IPaintString;
+type IPaintAttr = 'fill' | 'stroke';
 interface IPaintBase {
     type: IPaintType;
     blendMode?: IBlendMode;
@@ -44,10 +41,10 @@ interface IRGBA extends IRGB {
 }
 interface IGradientPaint extends IPaintBase {
     type: IGradientType;
-    from?: IPointData;
-    to?: IPointData;
+    from?: IAlign | IUnitPointData;
+    to?: IAlign | IUnitPointData;
     stretch?: number;
-    stops: IColorStop[];
+    stops: IColorStop[] | IColorString[];
 }
 interface IColorStop {
     offset: number;
@@ -59,6 +56,8 @@ interface IImagePaint extends IPaintBase {
     mode?: IImagePaintMode;
     format?: IExportFileType;
     filters?: IImageFilters;
+    padding?: IFourNumber;
+    align?: IAlign;
     offset?: IPointData;
     size?: number | ISizeData;
     scale?: number | IPointData;
@@ -74,12 +73,25 @@ interface IImageFilters {
     highlights?: number;
     shadows?: number;
 }
-type IImagePaintMode = 'cover' | 'fit' | 'strench' | 'clip' | 'repeat';
+type IImagePaintMode = 'normal' | 'cover' | 'fit' | 'strench' | 'clip' | 'repeat';
 type IRepeat = boolean | 'x' | 'y';
 type IStrokeAlign = 'inside' | 'outside' | 'center';
-type IStrokeCap = 'none' | 'round' | 'square' | 'arrow-lines' | 'arrow-equilateral';
+type IStrokeCap = 'none' | 'round' | 'square';
 type IStrokeJoin = 'bevel' | 'round' | 'miter';
-type IArrowType = 'none' | 'line' | 'triangle' | 'circle';
+type IArrowType = IPathDataArrow | 'none' | 'angle' | 'angle-side' | 'arrow' | 'triangle' | 'triangle-flip' | 'circle' | 'circle-line' | 'square' | 'square-line' | 'diamond' | 'diamond-line' | 'mark';
+interface IPathDataArrowMap {
+    [name: string]: IPathDataArrow;
+}
+interface IPathDataArrow {
+    connect?: IPathDataArrowOffset;
+    offset?: IPathDataArrowOffset;
+    path: IPathCommandData;
+}
+interface IPathDataArrowOffset {
+    x?: number;
+    bevelJoin?: number;
+    roundJoin?: number;
+}
 type ITextAlign = 'left' | 'center' | 'right' | 'justify';
 type IVerticalAlign = 'top' | 'middle' | 'bottom';
 type ITextCase = 'upper' | 'lower' | 'title' | 'none' | 'small-caps';
@@ -155,19 +167,19 @@ interface ILeafShadowEffect {
 }
 
 interface ICornerRadiusAttrData {
-    cornerRadius: number | number[] | ICornerRadiusString;
-    cornerSmoothing: number;
+    cornerRadius?: IFourNumber | ICornerRadiusString;
+    cornerSmoothing?: INumber;
 }
 interface ICornerRadiusInputData {
-    cornerRadius?: number | number[] | ICornerRadiusString;
-    cornerSmoothing?: number;
+    cornerRadius?: IFourNumber | ICornerRadiusString;
+    cornerSmoothing?: INumber;
 }
 interface ICornerRadiusComputedData {
     cornerRadius?: number;
     cornerSmoothing?: number;
 }
 interface IFillAttrData {
-    fill: IFill;
+    fill?: IFill;
 }
 interface IFillInputData {
     fill?: IFill;
@@ -180,26 +192,28 @@ interface IBorderComputedData {
     borderRadius?: number | number[];
 }
 interface IStrokeAttrData {
-    stroke: IStroke;
-    strokeAlign: IStrokeAlign;
-    strokeWidth: number | number[] | IStrokeWidthString;
-    strokeCap: IStrokeCap;
-    strokeJoin: IStrokeJoin;
-    dashPattern: number[] | IDashPatternString;
-    dashOffset: number;
-    miterLimit: number;
-    startArrow: IArrowType;
-    endArrow: IArrowType;
+    stroke?: IStroke;
+    strokeAlign?: IStrokeAlign;
+    strokeWidth?: IFourNumber | IStrokeWidthString;
+    strokeWidthFixed?: IBoolean;
+    strokeCap?: IStrokeCap;
+    strokeJoin?: IStrokeJoin;
+    dashPattern?: INumber[] | IDashPatternString;
+    dashOffset?: INumber;
+    miterLimit?: INumber;
+    startArrow?: IArrowType;
+    endArrow?: IArrowType;
 }
 interface IStrokeInputData {
     stroke?: IStroke;
     strokeAlign?: IStrokeAlign;
-    strokeWidth?: number | number[] | IStrokeWidthString;
+    strokeWidth?: IFourNumber | IStrokeWidthString;
+    strokeWidthFixed?: IBoolean;
     strokeCap?: IStrokeCap;
     strokeJoin?: IStrokeJoin;
-    dashPattern?: number[] | IDashPatternString;
-    dashOffset?: number;
-    miterLimit?: number;
+    dashPattern?: INumber[] | IDashPatternString;
+    dashOffset?: INumber;
+    miterLimit?: INumber;
     startArrow?: IArrowType;
     endArrow?: IArrowType;
 }
@@ -208,39 +222,42 @@ interface IStrokeComputedData {
     strokeAlign?: IStrokeAlign;
     strokeWidth?: number;
     strokeWidths?: number[];
+    strokeWidthFixed?: boolean;
     strokeCap?: IStrokeCap;
     strokeJoin?: IStrokeJoin;
     dashPattern?: number[];
     dashOffset?: number;
     miterLimit?: number;
+    startArrow?: IArrowType;
+    endArrow?: IArrowType;
 }
 interface ITextStyleAttrData {
-    fontFamily: string;
-    fontSize: number;
-    fontWeight: IFontWeight;
-    italic: boolean;
-    textCase: ITextCase;
-    textDecoration: ITextDecoration;
-    letterSpacing: number | IUnitData;
-    lineHeight: number | IUnitData;
-    paraIndent: number;
-    paraSpacing: number;
-    textAlign: ITextAlign;
-    verticalAlign: IVerticalAlign;
-    textWrap: ITextWrap;
-    textOverflow: IOverflow | string;
+    fontFamily?: IString;
+    fontSize?: INumber;
+    fontWeight?: IFontWeight;
+    italic?: IBoolean;
+    textCase?: ITextCase;
+    textDecoration?: ITextDecoration;
+    letterSpacing?: INumber | IUnitData;
+    lineHeight?: INumber | IUnitData;
+    paraIndent?: INumber;
+    paraSpacing?: INumber;
+    textAlign?: ITextAlign;
+    verticalAlign?: IVerticalAlign;
+    textWrap?: ITextWrap;
+    textOverflow?: IOverflow | string;
 }
 interface ITextStyleInputData {
-    fontFamily?: string;
-    fontSize?: number;
+    fontFamily?: IString;
+    fontSize?: INumber;
     fontWeight?: IFontWeight;
-    italic?: boolean;
+    italic?: IBoolean;
     textCase?: ITextCase;
     textDecoration?: ITextDecoration;
-    letterSpacing?: number | IUnitData;
-    lineHeight?: number | IUnitData;
-    paraIndent?: number;
-    paraSpacing?: number;
+    letterSpacing?: INumber | IUnitData;
+    lineHeight?: INumber | IUnitData;
+    paraIndent?: INumber;
+    paraSpacing?: INumber;
     textAlign?: ITextAlign;
     verticalAlign?: IVerticalAlign;
     textWrap?: ITextWrap;
@@ -263,18 +280,18 @@ interface ITextStyleComputedData {
     textOverflow?: IOverflow | string;
 }
 interface IEffectAttrData {
-    shadow: IShadowEffect | IShadowEffect[] | IShadowString;
-    innerShadow: IShadowEffect | IShadowEffect[] | IShadowString;
-    blur: number | IBlurEffect;
-    backgroundBlur: number | IBlurEffect;
-    grayscale: number | IGrayscaleEffect;
+    shadow?: IShadowEffect | IShadowEffect[] | IShadowString;
+    innerShadow?: IShadowEffect | IShadowEffect[] | IShadowString;
+    blur?: INumber | IBlurEffect;
+    backgroundBlur?: INumber | IBlurEffect;
+    grayscale?: INumber | IGrayscaleEffect;
 }
 interface IEffectInputData {
     shadow?: IShadowEffect | IShadowEffect[] | IShadowString;
     innerShadow?: IShadowEffect | IShadowEffect[] | IShadowString;
-    blur?: number | IBlurEffect;
-    backgroundBlur?: number | IBlurEffect;
-    grayscale?: number | IGrayscaleEffect;
+    blur?: INumber | IBlurEffect;
+    backgroundBlur?: INumber | IBlurEffect;
+    grayscale?: INumber | IGrayscaleEffect;
 }
 interface IEffectComputedData {
     shadow?: ILeafShadowEffect[];
@@ -284,26 +301,139 @@ interface IEffectComputedData {
     grayscale?: number;
 }
 
-interface IExportOptions {
-    quality?: number;
-    blob?: boolean;
+interface IEditorBase extends IGroup$1, ISelectorProxy {
+    config: IEditorConfig;
+    readonly mergeConfig: IEditorConfig;
+    hoverTarget?: IUI$1;
+    target?: IUI$1 | IUI$1[];
+    readonly list: IUI$1[];
+    leafList: ILeafList;
+    openedGroupList: ILeafList;
+    readonly editing: boolean;
+    innerEditing: boolean;
+    readonly groupOpening: boolean;
+    readonly multiple: boolean;
+    readonly single: boolean;
+    readonly dragging: boolean;
+    element?: IUI$1;
+    buttons: IGroup$1;
+    selector: IGroup$1;
+    editBox: IEditBoxBase;
+    editTool?: IObject;
+    innerEditor?: IObject;
+    select(target: IUI$1 | IUI$1[]): void;
+    cancel(): void;
+    hasItem(item: IUI$1): boolean;
+    shiftItem(item: IUI$1): void;
+    addItem(item: IUI$1): void;
+    removeItem(item: IUI$1): void;
+    update(): void;
+    updateEditBox(): void;
+    updateEditTool(): void;
+    getEditSize(ui: ILeaf): IEditSize;
+    onMove(e: IDragEvent): void;
+    onScale(e: IDragEvent | IZoomEvent): void;
+    onRotate(e: IDragEvent | IRotateEvent): void;
+    onSkew(e: IDragEvent): void;
+    group(group?: IGroup$1 | IGroupInputData$1): IGroup$1;
+    ungroup(): IUI$1[];
+    openGroup(group: IGroup$1): void;
+    closeGroup(group: IGroup$1): void;
+    openInnerEditor(target?: IUI$1): void;
+    closeInnerEditor(): void;
+    lock(): void;
+    unlock(): void;
+    toTop(): void;
+    toBottom(): void;
 }
-interface IExportResult {
-    data: IBlob | string | boolean;
+interface IEditorConfig {
+    editSize?: IEditSize;
+    dualEvent?: boolean;
+    keyEvent?: boolean;
+    stroke?: IStroke$1;
+    strokeWidth?: number;
+    pointFill?: IFill$1;
+    pointSize?: number;
+    pointRadius?: number;
+    point?: IEditPointInputData | IEditPointInputData[];
+    middlePoint?: IEditPointInputData | IEditPointInputData[];
+    rect?: IBoxInputData$1;
+    area?: IRectInputData$1;
+    mask?: boolean | IColorString$1;
+    circle?: IEditPointInputData;
+    circleDirection?: IDirection4;
+    circleMargin?: number;
+    rotatePoint?: IEditPointInputData;
+    buttonsDirection?: IDirection4;
+    buttonsFixed?: boolean | 'AABB' | 'OBB';
+    buttonsMargin?: number;
+    hideOnMove?: boolean;
+    hideOnSmall?: boolean | number;
+    moveCursor?: ICursorType;
+    resizeCursor?: IImageCursor;
+    rotateCursor?: IImageCursor;
+    skewCursor?: IImageCursor;
+    around?: IAlign$1 | IUnitPointData$1;
+    lockRatio?: boolean | 'corner';
+    rotateGap?: number;
+    selector?: boolean;
+    hover?: boolean;
+    hoverStyle?: IUIInputData$1;
+    select?: 'press' | 'tap';
+    boxSelect?: boolean;
+    continuousSelect?: boolean;
+    openInner?: 'double' | 'long';
+    moveable?: boolean | 'move';
+    resizeable?: boolean | 'zoom';
+    flipable?: boolean;
+    rotateable?: boolean | 'rotate';
+    skewable?: boolean;
 }
-interface IExportResultFunction {
-    (data: IExportResult): void;
+interface IEditPointInputData extends IBoxInputData$1 {
+    direction?: number;
+    pointType?: IEditPointType;
 }
-interface IExportModule {
-    running?: boolean;
-    export?(leaf: ILeaf, filename: IExportFileType | string, options?: IExportOptions | number | boolean): Promise<IExportResult>;
+interface IEditPoint extends IBox$1 {
+    direction: number;
+    pointType: IEditPointType;
+}
+type IEditPointType = 'rotate' | 'resize' | 'button';
+interface IEditBoxBase extends IGroup$1 {
+    editor: IEditorBase;
+    dragging: boolean;
+    moving: boolean;
+    view: IGroup$1;
+    circle: IEditPoint;
+    rect: IRect$1;
+    buttons: IGroup$1;
+    resizePoints: IEditPoint[];
+    rotatePoints: IEditPoint[];
+    resizeLines: IEditPoint[];
+    readonly flipped: boolean;
+    readonly flippedX: boolean;
+    readonly flippedY: boolean;
+    readonly flippedOne: boolean;
+    enterPoint: IEditPoint;
+    getPointStyle(userStyle?: IBoxInputData$1): IBoxInputData$1;
+    getPointsStyle(): IBoxInputData$1[];
+    getMiddlePointsStyle(): IBoxInputData$1[];
+    load(): void;
+    update(bounds: IBoundsData): void;
+    unload(): void;
+    onArrow(e: IKeyEvent): void;
+}
+interface IEditorConfigFunction {
+    (ui: any): IEditorConfig;
+}
+interface IEditToolFunction {
+    (ui: any): string;
 }
 
 interface ILine extends IUI {
     __: ILineData;
-    toPoint: IPointData;
-    points: number[];
-    curve: boolean | number;
+    toPoint?: IPointData;
+    points?: number[];
+    curve?: boolean | number;
 }
 interface ILineAttrData {
     toPoint?: IPointData;
@@ -321,7 +451,16 @@ interface IArrowAttrData {
 }
 interface IArrowData extends IArrowAttrData, ILineData {
 }
-interface IArrowInputData extends IArrowAttrData, IUIBaseInputData {
+interface IArrowInputData extends IArrowAttrData, ILineInputData {
+}
+interface IFlow extends IBox {
+    __: IFlowData;
+}
+interface IFlowAttrData {
+}
+interface IFlowData extends IFlowAttrData, IBoxData {
+}
+interface IFlowInputData extends IFlowAttrData, IBoxInputData {
 }
 interface IRect extends IUI {
     __: IRectData;
@@ -332,9 +471,9 @@ interface IRectInputData extends IUIBaseInputData {
 }
 interface IEllipse extends IUI {
     __: IEllipseData;
-    startAngle: number;
-    endAngle: number;
-    innerRadius: number;
+    startAngle?: number;
+    endAngle?: number;
+    innerRadius?: number;
 }
 interface IEllipseAttrData {
     startAngle?: number;
@@ -347,9 +486,9 @@ interface IEllipseInputData extends IEllipseAttrData, IUIBaseInputData {
 }
 interface IPolygon extends IUI {
     __: IPolygonData;
-    sides: number;
-    points: number[];
-    curve: boolean | number;
+    sides?: number;
+    points?: number[];
+    curve?: boolean | number;
 }
 interface IPolygonAttrData {
     sides?: number;
@@ -362,8 +501,8 @@ interface IPolygonInputData extends IPolygonAttrData, IUIBaseInputData {
 }
 interface IStar extends IUI {
     __: IStarData;
-    corners: number;
-    innerRadius: number;
+    corners?: number;
+    innerRadius?: number;
 }
 interface IStarAttrData {
     corners?: number;
@@ -375,16 +514,10 @@ interface IStarInputData extends IStarAttrData, IUIBaseInputData {
 }
 interface IPath extends IUI {
     __: IPathData;
-    path: IPathCommandData | IPathString;
-    windingRule: IWindingRule;
 }
 interface IPathData extends IUIData {
-    path?: IPathCommandData;
-    windingRule?: IWindingRule;
 }
 interface IPathInputData extends IUIBaseInputData {
-    path?: IPathCommandData | IPathString;
-    windingRule?: IWindingRule;
 }
 interface IPen extends IGroup, IPathCreator {
     __: IPenData;
@@ -392,7 +525,6 @@ interface IPen extends IGroup, IPathCreator {
     pathStyle: IPathInputData;
     path: IPathCommandData;
     paint(): void;
-    clear(): void;
 }
 interface IPenData extends IGroupData {
 }
@@ -400,10 +532,14 @@ interface IPenInputData extends IGroupInputData {
 }
 interface IText extends ITextStyleAttrData, IUI {
     __: ITextData;
-    text: string;
+    text?: string;
+    padding?: IFourNumber;
+    resizeFontSize?: IBoolean;
 }
 interface ITextAttrData {
     text?: string;
+    padding?: IFourNumber;
+    resizeFontSize?: boolean;
 }
 interface ITextData extends ITextAttrData, ITextStyleComputedData, IUIData {
     __baseLine?: number;
@@ -411,7 +547,7 @@ interface ITextData extends ITextAttrData, ITextStyleComputedData, IUIData {
     __letterSpacing?: number;
     __padding?: number[];
     __clipText?: boolean;
-    __textBoxBounds?: IBoundsData;
+    __textBoxBounds?: IBoundsData$1;
 }
 interface ITextInputData extends ITextAttrData, ITextStyleInputData, IUIBaseInputData {
 }
@@ -445,7 +581,7 @@ interface ITextCharData {
     char?: string;
 }
 interface ITextDrawData {
-    bounds: IBoundsData;
+    bounds: IBoundsData$1;
     rows: ITextRowData[];
     paraNumber: number;
     font: string;
@@ -469,24 +605,23 @@ interface IImageInputData extends IImageAttrData, IUIBaseInputData {
 }
 interface ICanvas extends IRect {
     __: ICanvasData;
-    pixelRatio: number;
-    smooth: boolean;
-    canvas: ILeaferCanvas;
+    smooth?: boolean;
+    contextSettings?: ICanvasContext2DSettings;
+    canvas?: ILeaferCanvas;
+    context?: ICanvasContext2D;
     __updateSize(): void;
 }
 interface ICanvasAttrData {
-    pixelRatio?: number;
     smooth?: boolean;
+    contextSettings?: ICanvasContext2DSettings;
 }
 interface ICanvasData extends ICanvasAttrData, IRectData {
 }
 interface ICanvasInputData extends ICanvasAttrData, IUIBaseInputData {
 }
 interface ILeaferData extends IGroupData {
-    pixelRatio?: number;
 }
 interface ILeaferInputData extends IGroupInputData {
-    pixelRatio?: number;
 }
 interface IAppData extends ILeaferData {
 }
@@ -501,157 +636,122 @@ interface IFrameInputData extends IBoxInputData {
 }
 interface IBox extends IGroup {
     __: IBoxData;
-    overflow: IOverflow;
+    resizeChildren?: IBoolean;
+    overflow?: IOverflow;
     __updateRectRenderBounds(): void;
     __renderGroup(canvas: ILeaferCanvas, options: IRenderOptions): void;
 }
 interface IBoxData extends IGroupData {
+    resizeChildren?: boolean;
     overflow?: IOverflow;
 }
 interface IBoxInputData extends IGroupInputData {
+    resizeChildren?: boolean;
     overflow?: IOverflow;
 }
 interface IGroup extends IUI {
     __: IGroupData;
     children: IUI[];
-    mask?: IUI;
+    pick(hitPoint: IPointData, options?: IPickOptions): IPickResult;
     add(child: IUI, index?: number): void;
     addAt(child: IUI, index: number): void;
     addAfter(child: IUI, after: IUI): void;
     addBefore(child: IUI, before: IUI): void;
-    addMany(...children: ILeaf[]): void;
+    addMany(...children: ILeaf$1[]): void;
     remove(child?: IUI): void;
     removeAll(): void;
+    clear(): void;
 }
 interface IGroupData extends IUIData {
 }
 interface IGroupInputData extends IUIBaseInputData {
 }
-interface IUI extends IFillAttrData, IStrokeAttrData, ICornerRadiusAttrData, IEffectAttrData, ILeaf {
+interface IUI extends IFillAttrData, IStrokeAttrData, ICornerRadiusAttrData, IEffectAttrData, ILeaf$1 {
     __: IUIData;
     readonly app: ILeafer;
     leafer?: ILeafer;
     parent?: IGroup;
-    isFrame?: boolean;
-    proxyData: IUIInputData;
+    zoomLayer?: IGroup;
+    readonly isFrame?: boolean;
+    proxyData?: IUIInputData;
     __proxyData?: IUIInputData;
+    normalStyle?: IUIInputData;
+    hoverStyle?: IUIInputData;
+    pressStyle?: IUIInputData;
+    focusStyle?: IUIInputData;
+    selectedStyle?: IUIInputData;
+    disabledStyle?: IUIInputData;
+    editConfig?: IEditorConfig;
+    editOuter: string;
+    editInner: string;
     children?: IUI[];
+    readonly pen: IPathCreator;
     reset(data?: IUIInputData): void;
     set(data: IUIInputData): void;
-    toJSON(): IUIInputData;
-    get(): IUIInputData;
+    toJSON(options?: IJSONOptions): IUIJSONData;
+    get(name?: string | string[] | IUIInputData): IUIInputData | IValue;
     createProxyData(): IUIInputData;
-    find(condition: number | string | IFindUIMethod, options?: any): IUI[];
-    findOne(condition: number | string | IFindUIMethod, options?: any): IUI;
+    find(condition: number | string | IFindCondition | IFindUIMethod, options?: any): IUI[];
+    findTag(tag: string | string[]): IUI[];
+    findOne(condition: number | string | IFindCondition | IFindUIMethod, options?: any): IUI | undefined;
+    findId(id: number | string): IUI | undefined;
     getPath(curve?: boolean, pathForRender?: boolean): IPathCommandData;
     getPathString(curve?: boolean, pathForRender?: boolean): IPathString;
+    load(): void;
     __drawPathByData(drawer: IPathDrawer, data: IPathCommandData): void;
     __drawPathByBox(drawer: IPathDrawer): void;
     __drawAfterFill?(canvas: ILeaferCanvas, options: IRenderOptions): void;
-    export(filename: string, options?: IExportOptions | number): Promise<IBlob | string | boolean>;
+    export(filename: string, options?: IExportOptions | number | boolean): Promise<IExportResult>;
     clone(): IUI;
 }
 interface IFindUIMethod {
-    (leaf: IUI, options?: any): AnswerType;
+    (leaf: IUI, options?: any): IAnswer;
 }
 interface IUIData extends IUIComputedData, ILeafData {
     padding?: number | number[];
-    locked?: boolean;
+    normalStyle?: IUIInputData;
+    hoverStyle?: IUIInputData;
+    pressStyle?: IUIInputData;
+    focusStyle?: IUIInputData;
+    selectedStyle?: IUIInputData;
+    disabledStyle?: IUIInputData;
     __isFills?: boolean;
     __isStrokes?: boolean;
+    readonly __strokeWidth: number;
     __pixelFill?: boolean;
     __pixelStroke?: boolean;
+    __isHitPixel?: boolean;
+    __isCanvas?: boolean;
     __opacityFill?: boolean;
     __opacityStroke?: boolean;
     __drawAfterFill?: boolean;
     __isOverflow?: boolean;
     __blendLayer?: boolean;
-    __useEffect?: boolean;
-    __autoWidth: boolean;
-    __autoHeight: boolean;
-    __autoBounds: boolean;
-    path?: IPathCommandData;
-    windingRule?: IWindingRule;
-    __pathForRender?: IPathCommandData;
-    __path2DForRender?: IPath2D;
     __boxStroke?: boolean;
     __font?: string;
     __textDrawData?: ITextDrawData;
+    __needComputePaint: boolean;
+    __computePaint(): void;
 }
 interface IUIComputedData extends IFillComputedData, IBorderComputedData, IStrokeComputedData, ITextStyleComputedData, ICornerRadiusComputedData, IEffectComputedData, ILeafComputedData {
     padding?: number | number[];
-    locked?: boolean;
 }
 interface IUIBaseInputData extends IFillInputData, IStrokeInputData, ITextStyleInputData, ICornerRadiusInputData, IEffectInputData, ILeafInputData {
     padding?: number | number[];
-    locked?: boolean;
+    normalStyle?: IUIInputData;
+    hoverStyle?: IUIInputData;
+    pressStyle?: IUIInputData;
+    focusStyle?: IUIInputData;
+    selectedStyle?: IUIInputData;
+    disabledStyle?: IUIInputData;
     children?: IUIInputData[];
 }
 type IUITag = 'App' | 'Leafer' | 'Rect' | 'Ellipse' | 'Polygon' | 'Star' | 'Line' | 'Path' | 'Pen' | 'Text' | 'Image' | 'Canvas' | 'Group' | 'Frame' | 'Box';
-interface IUIInputData extends IRectInputData, IEllipseInputData, IPolygonInputData, IStarInputData, ILineInputData, IPathInputData, ITextInputData, IImageInputData, IGroupInputData, IFrameInputData, IUIBaseInputData, IObject {
+interface IUIInputData extends IRectInputData, IEllipseInputData, IPolygonInputData, IStarInputData, ILineInputData, IPathInputData, ITextInputData, IImageInputData, IGroupInputData, IFrameInputData, IUIBaseInputData, IObject$1 {
     children?: IUIInputData[];
 }
-
-interface IEditorBase extends IGroup$1, ISelectorProxy {
-    config: IEditorConfig;
-    hoverTarget: IUI$1;
-    target: IUI$1 | IUI$1[];
-    readonly list: IUI$1[];
-    readonly hasTarget: boolean;
-    readonly multiple: boolean;
-    readonly single: boolean;
-    readonly dragging: boolean;
-    element: IUI$1;
-    buttons: IGroup$1;
-    selector: IGroup$1;
-    editBox: IGroup$1;
-    editTool: IObject$1;
-    hasItem(item: IUI$1): boolean;
-    shiftItem(item: IUI$1): void;
-    addItem(item: IUI$1): void;
-    removeItem(item: IUI$1): void;
-    update(): void;
-    updateEditTool(): void;
-    getEditSize(ui: ILeaf$1): IEditSize;
-    onMove(e: IDragEvent): void;
-    onScale(e: IDragEvent): void;
-    onRotate(e: IDragEvent | IRotateEvent): void;
-    onSkew(e: IDragEvent): void;
-    group(): void;
-    ungroup(): void;
-    lock(): void;
-    unlock(): void;
-    toTop(): void;
-    toBottom(): void;
-}
-interface IEditorConfig {
-    editSize?: 'auto' | IEditSize;
-    stroke?: IStroke$1;
-    strokeWidth?: number;
-    pointFill?: IFill$1;
-    pointSize?: number;
-    pointRadius?: number;
-    point?: IBoxInputData$1 | IBoxInputData$1[];
-    middlePoint?: IBoxInputData$1 | IBoxInputData$1[];
-    rotatePoint?: IBoxInputData$1;
-    rect?: IBoxInputData$1;
-    area?: IRectInputData$1;
-    buttonsDirection?: 'top' | 'right' | 'bottom' | 'left';
-    buttonsFixed?: boolean;
-    buttonsMargin?: number;
-    hideOnMove?: boolean;
-    moveCursor?: ICursorType;
-    resizeCursor?: ICursorType[];
-    rotateCursor?: ICursorType[];
-    around?: IAround;
-    lockRatio?: boolean;
-    rotateGap?: number;
-    selector?: boolean;
-    hover?: boolean;
-    boxSelect?: boolean;
-    rotateable?: boolean;
-    resizeable?: boolean;
-    skewable?: boolean;
+interface IUIJSONData extends IUIInputData {
+    matrix?: IMatrixData;
 }
 
 interface ILeafer extends IGroup, ILeaferAttrData, IControl {
@@ -664,6 +764,9 @@ interface ILeafer extends IGroup, ILeaferAttrData, IControl {
     tree?: ILeafer;
     sky?: ILeafer;
     userConfig?: ILeaferConfig;
+    onInit(): void;
+    initType(type: ILeaferType): void;
+    destroy(sync?: boolean): void;
 }
 
 interface IApp extends ILeafer {
@@ -703,40 +806,74 @@ interface IUIBounds extends ILeafBounds {
 
 type IUIHitModule = ILeafHit & ThisType<IUI>;
 
+interface IPathArrowModule {
+    list: IPathDataArrowMap;
+    addArrows(ui: IUI, changeRenderPath?: boolean): void;
+}
+
 interface ITextConvertModule {
-    getDrawData?(content: string, style: ITextData): ITextDrawData;
+    getDrawData(content: string, style: ITextData): ITextDrawData;
 }
 
 interface IColorConvertModule {
-    string?(color: IColor, opacity?: number): string;
+    string(color: IColor, opacity?: number): string;
+}
+
+interface IExportModule {
+    running?: boolean;
+    export(leaf: ILeaf$1, filename: IExportFileType | string, options?: IExportOptions | number | boolean): Promise<IExportResult>;
+}
+
+interface IStateModule {
+    isHover(leaf: ILeaf$1): boolean;
+    isPress(leaf: ILeaf$1): boolean;
+    isFocus(leaf: ILeaf$1): boolean;
+    isDrag(leaf: ILeaf$1): boolean;
+    setStyle(leaf: ILeaf$1, stateType: IStateStyleType, value: boolean): void;
+    updateEventStyle(leaf: ILeaf$1, eventType: string): void;
 }
 
 interface ICachedShape extends ICachedLeaf {
     worldCanvas?: ILeaferCanvas;
-    shapeBounds: IBoundsData;
+    shapeBounds: IBoundsData$1;
     scaleX: number;
     scaleY: number;
 }
 
 interface IPaintModule {
-    compute?(attrName: 'fill' | 'stroke', ui: IUI): void;
-    fill?(fill: string, ui: IUI, canvas: ILeaferCanvas): void;
-    fills?(fills: ILeafPaint[], ui: IUI, canvas: ILeaferCanvas): void;
-    fillText?(ui: IUI, canvas: ILeaferCanvas): void;
-    stroke?(stroke: string, ui: IUI, canvas: ILeaferCanvas, renderOptions: IRenderOptions): void;
-    strokes?(strokes: ILeafPaint[], ui: IUI, canvas: ILeaferCanvas, renderOptions: IRenderOptions): void;
-    strokeText?(stroke: string, ui: IUI, canvas: ILeaferCanvas, renderOptions: IRenderOptions): void;
-    strokesText?(strokes: ILeafPaint[], ui: IUI, canvas: ILeaferCanvas, renderOptions: IRenderOptions): void;
-    drawTextStroke?(ui: IUI, canvas: ILeaferCanvas): void;
-    shape?(ui: IUI, current: ILeaferCanvas, renderOptions: IRenderOptions): ICachedShape;
-    recycleImage?(attrName: 'fill' | 'stroke', data: IUIData): IBooleanMap;
+    compute(attrName: IPaintAttr, ui: IUI): void;
+    fill(fill: string, ui: IUI, canvas: ILeaferCanvas): void;
+    fills(fills: ILeafPaint[], ui: IUI, canvas: ILeaferCanvas): void;
+    fillText(ui: IUI, canvas: ILeaferCanvas): void;
+    stroke(stroke: string, ui: IUI, canvas: ILeaferCanvas): void;
+    strokes(strokes: ILeafPaint[], ui: IUI, canvas: ILeaferCanvas): void;
+    strokeText(stroke: string | ILeafPaint[], ui: IUI, canvas: ILeaferCanvas): void;
+    drawTextStroke(ui: IUI, canvas: ILeaferCanvas): void;
+    shape(ui: IUI, current: ILeaferCanvas, renderOptions: IRenderOptions): ICachedShape;
+}
+interface IPaintImageModule {
+    image(ui: IUI, attrName: string, paint: IImagePaint, boxBounds: IBoundsData$1, firstUse: boolean): ILeafPaint;
+    checkImage(ui: IUI, canvas: ILeaferCanvas, paint: ILeafPaint, allowPaint?: boolean): boolean;
+    createPattern(ui: IUI, paint: ILeafPaint, pixelRatio: number): boolean;
+    recycleImage(attrName: IPaintAttr, data: IUIData): IBooleanMap;
+    createData(leafPaint: ILeafPaint, image: ILeaferImage, paint: IImagePaint, box: IBoundsData$1): void;
+    getPatternData(paint: IImagePaint, box: IBoundsData$1, image: ILeaferImage): ILeafPaintPatternData;
+    fillOrFitMode(data: ILeafPaintPatternData, box: IBoundsData$1, x: number, y: number, scaleX: number, scaleY: number, rotation: number): void;
+    clipMode(data: ILeafPaintPatternData, box: IBoundsData$1, x: number, y: number, scaleX: number, scaleY: number, rotation: number): void;
+    repeatMode(data: ILeafPaintPatternData, box: IBoundsData$1, width: number, height: number, x: number, y: number, scaleX: number, scaleY: number, rotation: number, around: IAround): void;
+}
+interface IPaintGradientModule {
+    linearGradient(paint: IGradientPaint, box: IBoundsData$1): ILeafPaint;
+    radialGradient(paint: IGradientPaint, box: IBoundsData$1): ILeafPaint;
+    conicGradient(paint: IGradientPaint, box: IBoundsData$1): ILeafPaint;
+    getTransform(box: IBoundsData$1, from: IPointData, to: IPointData, stretch: number, rotate90: boolean): IMatrixData;
 }
 
 interface IEffectModule {
-    shadow?(ui: IUI, current: ILeaferCanvas, shape: ICachedShape, renderOptions: IRenderOptions): void;
-    innerShadow?(ui: IUI, current: ILeaferCanvas, shape: ICachedShape, renderOptions: IRenderOptions): void;
-    blur?(ui: IUI, current: ILeaferCanvas, origin: ILeaferCanvas, renderOptions: IRenderOptions): void;
-    backgroundBlur?(ui: IUI, current: ILeaferCanvas, shape: ICachedShape, renderOptions: IRenderOptions): void;
+    shadow(ui: IUI, current: ILeaferCanvas, shape: ICachedShape): void;
+    innerShadow(ui: IUI, current: ILeaferCanvas, shape: ICachedShape): void;
+    blur(ui: IUI, current: ILeaferCanvas, origin: ILeaferCanvas): void;
+    backgroundBlur(ui: IUI, current: ILeaferCanvas, shape: ICachedShape): void;
 }
 
-export type { IApp, IAppConfig, IAppData, IAppInputData, IArrow, IArrowData, IArrowInputData, IArrowType, IBlurEffect, IBox, IBoxData, IBoxInputData, ICachedShape, ICanvas, ICanvasData, ICanvasInputData, IColor, IColorConvertModule, IColorStop, IColorString, ICornerRadiusString, IDashPatternString, IEditorBase, IEditorConfig, IEffectModule, IEllipse, IEllipseData, IEllipseInputData, IExportModule, IExportOptions, IExportResult, IExportResultFunction, IFill, IFindUIMethod, IFontWeight, IFrame, IFrameData, IFrameInputData, IFrameRenderModule, IGradientPaint, IGrayscaleEffect, IGroup, IGroupData, IGroupInputData, IGroupRenderModule, IImage, IImageData, IImageInputData, IImagePaint, IImagePaintMode, IImageRenderModule, ILeafFill, ILeafPaint, ILeafPaintColor, ILeafPaintPatternData, ILeafShadowEffect, ILeafStrokePaint, ILeafer, ILeaferData, ILeaferInputData, ILine, ILineData, ILineInputData, IOverflow, IPaint, IPaintModule, IPaintString, IPath, IPathData, IPathInputData, IPen, IPenData, IPenInputData, IPercent, IPolygon, IPolygonData, IPolygonInputData, IRGB, IRGBA, IRect, IRectData, IRectInputData, IRectRenderModule, IRepeat, IShadowEffect, IShadowString, IStar, IStarData, IStarInputData, IStroke, IStrokeAlign, IStrokeCap, IStrokeJoin, IStrokeWidthString, IText, ITextAlign, ITextCase, ITextCharData, ITextConvertModule, ITextData, ITextDecoration, ITextDrawData, ITextInputData, ITextRenderModule, ITextRowData, ITextWordData, ITextWrap, IUI, IUIBaseInputData, IUIBoundsModule, IUIData, IUIHitModule, IUIInputData, IUIRenderModule, IUITag, IUnitData, IVectorPath, IVerticalAlign };
+export type { IApp, IAppConfig, IAppData, IAppInputData, IArrow, IArrowData, IArrowInputData, IArrowType, IBlurEffect, IBox, IBoxData, IBoxInputData, ICachedShape, ICanvas, ICanvasData, ICanvasInputData, IColor, IColorConvertModule, IColorStop, IColorString, ICornerRadiusString, IDashPatternString, IEditBoxBase, IEditPoint, IEditPointInputData, IEditPointType, IEditToolFunction, IEditorBase, IEditorConfig, IEditorConfigFunction, IEffectAttrData, IEffectComputedData, IEffectInputData, IEffectModule, IEllipse, IEllipseData, IEllipseInputData, IExportModule, IFill, IFindUIMethod, IFlow, IFlowData, IFlowInputData, IFontWeight, IFrame, IFrameData, IFrameInputData, IFrameRenderModule, IGradientPaint, IGrayscaleEffect, IGroup, IGroupData, IGroupInputData, IGroupRenderModule, IImage, IImageData, IImageInputData, IImagePaint, IImagePaintMode, IImageRenderModule, ILeafFill, ILeafPaint, ILeafPaintColor, ILeafPaintPatternData, ILeafShadowEffect, ILeafStrokePaint, ILeafer, ILeaferData, ILeaferInputData, ILine, ILineData, ILineInputData, IOverflow, IPaint, IPaintAttr, IPaintGradientModule, IPaintImageModule, IPaintModule, IPaintString, IPath, IPathArrowModule, IPathData, IPathDataArrow, IPathDataArrowMap, IPathInputData, IPen, IPenData, IPenInputData, IPercent, IPolygon, IPolygonData, IPolygonInputData, IRGB, IRGBA, IRect, IRectData, IRectInputData, IRectRenderModule, IRepeat, IShadowEffect, IShadowString, IStar, IStarData, IStarInputData, IStateModule, IStroke, IStrokeAlign, IStrokeAttrData, IStrokeCap, IStrokeComputedData, IStrokeInputData, IStrokeJoin, IStrokeWidthString, IText, ITextAlign, ITextCase, ITextCharData, ITextConvertModule, ITextData, ITextDecoration, ITextDrawData, ITextInputData, ITextRenderModule, ITextRowData, ITextStyleAttrData, ITextStyleComputedData, ITextStyleInputData, ITextWordData, ITextWrap, IUI, IUIBaseInputData, IUIBoundsModule, IUIData, IUIHitModule, IUIInputData, IUIJSONData, IUIRenderModule, IUITag, IVectorPath, IVerticalAlign };