@leafer-ui/interface 1.0.0-rc.3 → 1.0.0-rc.30

package/types/index.d.ts

@@ -1,5 +1,6 @@
-import { IPointData, IExportFileType, IWindingRule, IPathCommandData, IBlendMode, IMatrixData, ILeaferImage, IBlob, ILeaf, IPathString, IPathCreator, IBoundsData, ILeaferImageConfig, ILeaferCanvas, IRenderOptions, IPathDrawer, ILeafData, IPath2D, ILeafComputedData, ILeafInputData, IObject, 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, 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, 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;
@@ -12,11 +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;
@@ -41,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;
@@ -56,9 +56,13 @@ interface IImagePaint extends IPaintBase {
     mode?: IImagePaintMode;
     format?: IExportFileType;
     filters?: IImageFilters;
+    padding?: IFourNumber;
+    align?: IAlign;
     offset?: IPointData;
+    size?: number | ISizeData;
     scale?: number | IPointData;
     rotation?: number;
+    repeat?: IRepeat;
 }
 interface IImageFilters {
     exposure?: number;
@@ -69,10 +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 = 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';
@@ -80,6 +99,7 @@ type IFontWeight = IFontWeightNumer | IFontWeightString;
 type IFontWeightNumer = 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
 type IFontWeightString = 'thin' | 'extra-light' | 'light' | 'normal' | 'medium' | 'semi-bold' | 'bold' | 'extra-bold' | 'black';
 type ITextDecoration = 'none' | 'under' | 'delete';
+type ITextWrap = 'normal' | 'none' | 'break';
 interface IVectorPath {
     rule?: IWindingRule;
     data: string | IPathCommandData;
@@ -114,6 +134,7 @@ interface ILeafPaint {
     image?: ILeaferImage;
     loadId?: number;
     patternId?: string;
+    patternTask?: ITaskItem;
     data?: ILeafPaintPatternData;
 }
 interface ILeafPaintPatternData {
@@ -124,6 +145,7 @@ interface ILeafPaintPatternData {
     opacity?: number;
     transform?: IMatrixData;
     mode?: IImagePaintMode;
+    repeat?: 'repeat' | 'repeat-x' | 'repeat-y';
 }
 type ILeafFill = ILeafPaint;
 interface ILeafStrokePaint extends ILeafPaint {
@@ -145,22 +167,22 @@ 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: IPaint | IPaint[] | IPaintString;
+    fill?: IFill;
 }
 interface IFillInputData {
-    fill?: IPaint | IPaint[] | IPaintString;
+    fill?: IFill;
 }
 interface IFillComputedData {
     fill?: IColorString | ILeafPaint[];
@@ -170,64 +192,75 @@ interface IBorderComputedData {
     borderRadius?: number | number[];
 }
 interface IStrokeAttrData {
-    stroke: IPaint | IPaint[] | IPaintString;
-    strokeAlign: IStrokeAlign;
-    strokeWidth: number | number[] | IStrokeWidthString;
-    strokeCap: IStrokeCap;
-    strokeJoin: IStrokeJoin;
-    dashPattern: number[] | IDashPatternString;
-    dashOffset: number;
-    miterLimit: number;
+    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?: IPaint | IPaint[] | IPaintString;
+    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;
 }
 interface IStrokeComputedData {
     stroke?: IColorString | ILeafStrokePaint[];
     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;
-    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;
     textOverflow?: IOverflow | string;
 }
 interface ITextStyleComputedData {
@@ -243,21 +276,22 @@ interface ITextStyleComputedData {
     paraSpacing?: number;
     textAlign?: ITextAlign;
     verticalAlign?: IVerticalAlign;
-    textOverflow?: IOverflow;
+    textWrap?: ITextWrap;
+    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[];
@@ -267,33 +301,159 @@ interface IEffectComputedData {
     grayscale?: number;
 }
 
-interface IExportOptions {
-    quality?: number;
-    blob?: boolean;
-}
-interface IExportResult {
-    data: IBlob | string | boolean;
-}
-interface IExportResultFunction {
-    (data: IExportResult): void;
-}
-interface IExportModule {
-    export?(leaf: ILeaf, filename: IExportFileType | string, options?: IExportOptions | number | boolean): Promise<IExportResult>;
+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 IEditorConfig {
+    editSize?: IEditSize;
+    dualEvent?: boolean;
+    keyEvent?: boolean;
+    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;
+    mask?: IColorString$1;
+    buttonsDirection?: 'top' | 'right' | 'bottom' | 'left';
+    buttonsFixed?: boolean;
+    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;
+    rotateable?: boolean | 'rotate';
+    resizeable?: boolean | 'zoom';
+    skewable?: boolean;
+}
+interface IEditPoint extends IBox$1 {
+    direction: number;
+    pointType: IEditPointType;
+}
+type IEditPointType = 'rotate' | 'resize';
+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;
-}
-interface ILineData extends IUIData {
+    toPoint?: IPointData;
+    points?: number[];
+    curve?: boolean | number;
 }
-interface ILineInputData extends IUIBaseInputData {
+interface ILineAttrData {
     toPoint?: IPointData;
     points?: number[];
     curve?: boolean | number;
 }
+interface ILineData extends ILineAttrData, IUIData {
+}
+interface ILineInputData extends ILineAttrData, IUIBaseInputData {
+}
+interface IArrow extends ILine {
+    __: IArrowData;
+}
+interface IArrowAttrData {
+}
+interface IArrowData extends IArrowAttrData, ILineData {
+}
+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;
 }
@@ -303,9 +463,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;
@@ -318,9 +478,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;
@@ -333,8 +493,8 @@ interface IPolygonInputData extends IPolygonAttrData, IUIBaseInputData {
 }
 interface IStar extends IUI {
     __: IStarData;
-    corners: number;
-    innerRadius: number;
+    corners?: number;
+    innerRadius?: number;
 }
 interface IStarAttrData {
     corners?: number;
@@ -346,16 +506,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;
@@ -363,7 +517,6 @@ interface IPen extends IGroup, IPathCreator {
     pathStyle: IPathInputData;
     path: IPathCommandData;
     paint(): void;
-    clear(): void;
 }
 interface IPenData extends IGroupData {
 }
@@ -371,15 +524,22 @@ 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;
     __lineHeight?: number;
     __letterSpacing?: number;
+    __padding?: number[];
+    __clipText?: boolean;
+    __textBoxBounds?: IBoundsData$1;
 }
 interface ITextInputData extends ITextAttrData, ITextStyleInputData, IUIBaseInputData {
 }
@@ -396,6 +556,7 @@ interface ITextRowData {
     paraStart?: boolean;
     paraEnd?: boolean;
     isOverflow?: boolean;
+    textMode?: boolean;
 }
 interface ITextWordData {
     x?: number;
@@ -412,7 +573,7 @@ interface ITextCharData {
     char?: string;
 }
 interface ITextDrawData {
-    bounds: IBoundsData;
+    bounds: IBoundsData$1;
     rows: ITextRowData[];
     paraNumber: number;
     font: string;
@@ -430,29 +591,33 @@ interface IImageAttrData {
     url?: string;
 }
 interface IImageData extends IImageAttrData, IRectData {
+    __setImageFill(value: string): void;
 }
 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 {
+}
+interface IAppInputData extends ILeaferInputData {
 }
 interface IFrame extends IBox {
     __: IFrameData;
@@ -463,73 +628,148 @@ 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$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;
+    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;
-    getPath(curve?: boolean): IPathCommandData;
-    getPathString(curve?: boolean): IPathString;
+    toJSON(options?: IJSONOptions): IUIJSONData;
+    get(name?: string | string[] | IUIInputData): IUIInputData | IValue;
+    createProxyData(): IUIInputData;
+    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): 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;
-    __isTranslucentFill?: boolean;
-    __isTranslucentStroke?: boolean;
-    __useEffect?: 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;
-    children?: IUIBaseInputData[];
+    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 IUIJSONData extends IUIInputData {
+    matrix?: IMatrixData;
+}
+
+interface ILeafer extends IGroup, ILeaferAttrData, IControl {
+    readonly isApp: boolean;
+    readonly app: ILeafer;
+    parent?: IApp;
+    zoomLayer: IGroup;
+    editor: IEditorBase;
+    ground?: ILeafer;
+    tree?: ILeafer;
+    sky?: ILeafer;
+    userConfig?: ILeaferConfig;
+    onInit(): void;
+    initType(type: ILeaferType): void;
+    destroy(sync?: boolean): void;
+}
+
+interface IApp extends ILeafer {
+    children: ILeafer[];
+    realCanvas: boolean;
+}
+interface IAppConfig extends ILeaferConfig {
+    ground?: ILeaferConfig;
+    tree?: ILeaferConfig;
+    sky?: ILeaferConfig;
+    editor?: IEditorConfig;
 }
 
 type IUIRenderModule = IUIRender & ThisType<IUI>;
@@ -558,40 +798,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?(ui: IUI, attrName: 'fill' | 'stroke'): void;
-    fill?(ui: IUI, canvas: ILeaferCanvas, fill: string): void;
-    fills?(ui: IUI, canvas: ILeaferCanvas, fills: ILeafPaint[]): void;
-    fillText?(ui: IUI, canvas: ILeaferCanvas): void;
-    stroke?(ui: IUI, canvas: ILeaferCanvas, stroke: string): void;
-    strokes?(ui: IUI, canvas: ILeaferCanvas, strokes: ILeafPaint[]): void;
-    strokeText?(ui: IUI, canvas: ILeaferCanvas, stroke: string): void;
-    strokesText?(ui: IUI, canvas: ILeaferCanvas, strokes: ILeafPaint[]): void;
-    drawTextStroke?(ui: IUI, canvas: ILeaferCanvas): void;
-    shape?(ui: IUI, current: ILeaferCanvas, options: IRenderOptions): ICachedShape;
-    recycleImage?(data: IUIData, attrName: string): 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, options: IRenderOptions): void;
-    innerShadow?(ui: IUI, current: ILeaferCanvas, shape: ICachedShape, options: IRenderOptions): void;
-    blur?(ui: IUI, current: ILeaferCanvas, origin: ILeaferCanvas, options: IRenderOptions): void;
-    backgroundBlur?(ui: IUI, current: ILeaferCanvas, shape: ICachedShape, options: 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 { IBlurEffect, IBox, IBoxData, IBoxInputData, ICachedShape, ICanvas, ICanvasData, ICanvasInputData, IColor, IColorConvertModule, IColorStop, ICornerRadiusString, IDashPatternString, IEffectModule, IEllipse, IEllipseData, IEllipseInputData, IExportModule, IExportOptions, IExportResult, IExportResultFunction, IFontWeight, IFrame, IFrameData, IFrameInputData, IFrameRenderModule, IGradientPaint, IGrayscaleEffect, IGroup, IGroupData, IGroupInputData, IGroupRenderModule, IImage, IImageData, IImageInputData, IImagePaint, IImagePaintMode, IImageRenderModule, ILeafFill, ILeafPaint, ILeafPaintColor, ILeafPaintPatternData, ILeafShadowEffect, ILeafStrokePaint, 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, IShadowEffect, IShadowString, IStar, IStarData, IStarInputData, IColorString as IStringColor, IStrokeAlign, IStrokeCap, IStrokeJoin, IStrokeWidthString, IText, ITextAlign, ITextCase, ITextCharData, ITextConvertModule, ITextData, ITextDecoration, ITextDrawData, ITextInputData, ITextRenderModule, ITextRowData, ITextWordData, 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, 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 };