@leafer-ui/interface 1.0.0-beta.9 → 1.0.0-rc.1

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@leafer-ui/interface",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0-rc.1",
   "description": "@leafer-ui/interface",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
   "main": "src/index.ts",
+  "types": "types/index.d.ts",
   "files": [
-    "src"
+    "src",
+    "types",
+    "dist"
   ],
   "repository": {
     "type": "git",
@@ -19,6 +22,6 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/interface": "1.0.0-beta.9"
+    "@leafer/interface": "1.0.0-rc.1"
   }
 }

package/src/IUI.ts

@@ -1,6 +1,4 @@
-import { ILeaf, ILeafComputedData, ILeafData, ILeafInputData, ILeaferCanvas, IRenderOptions, IPathDrawer, IPointData, IPath2D, IPathCommandData, IWindingRule, ILeaferImageConfig, IBoundsData, IObject, __Number, IPathString, ILeaferImage, IBlob } from '@leafer/interface'
-
-import { IOverflow } from './type/IType'
+import { ILeaf, ILeafComputedData, ILeafData, ILeafInputData, ILeaferCanvas, IRenderOptions, IPathDrawer, IPointData, IPath2D, IPathCommandData, IWindingRule, ILeaferImageConfig, IBoundsData, IObject, __Number, IPathString, ILeaferImage, IBlob, IPathCreator } from '@leafer/interface'
 
 import {
     IFillAttrData, IFillInputData, IFillComputedData,
@@ -10,6 +8,7 @@ import {
     IEffectAttrData, IEffectInputData, IEffectComputedData,
     ITextStyleAttrData, ITextStyleInputData, ITextStyleComputedData
 } from './ICommonAttr'
+import { IOverflow } from './type/IType'
 import { IExportOptions } from './module/IExport'
 
 
@@ -17,10 +16,14 @@ import { IExportOptions } from './module/IExport'
 export interface ILine extends IUI {
     __: ILineData
     toPoint: IPointData
+    points: number[]
+    curve: boolean | number
 }
 export interface ILineData extends IUIData { }
-export interface ILineInputData extends IUIInputData {
+export interface ILineInputData extends IUIBaseInputData {
     toPoint?: IPointData
+    points?: number[]
+    curve?: boolean | number
 }
 
 
@@ -29,7 +32,7 @@ export interface IRect extends IUI {
     __: IRectData
 }
 export interface IRectData extends IUIData { }
-export interface IRectInputData extends IUIInputData { }
+export interface IRectInputData extends IUIBaseInputData { }
 
 
 // Ellipse
@@ -45,34 +48,38 @@ interface IEllipseAttrData {
     innerRadius?: number
 }
 export interface IEllipseData extends IEllipseAttrData, IUIData { }
-export interface IEllipseInputData extends IEllipseAttrData, IUIInputData { }
+export interface IEllipseInputData extends IEllipseAttrData, IUIBaseInputData { }
 
 
 // Polygon
 export interface IPolygon extends IUI {
     __: IPolygonData
     sides: number
+    points: number[]
+    curve: boolean | number
 }
 interface IPolygonAttrData {
     sides?: number
+    points?: number[]
+    curve?: boolean | number
 }
 export interface IPolygonData extends IPolygonAttrData, IUIData { }
-export interface IPolygonInputData extends IPolygonAttrData, IUIInputData { }
+export interface IPolygonInputData extends IPolygonAttrData, IUIBaseInputData { }
 
 
 // Star
 export interface IStar extends IUI {
     __: IStarData
-    points: number
+    corners: number
     innerRadius: number
 }
 interface IStarAttrData {
-    points?: number
+    corners?: number
     innerRadius?: number
 }
 
 export interface IStarData extends IStarAttrData, IUIData { }
-export interface IStarInputData extends IStarAttrData, IUIInputData { }
+export interface IStarInputData extends IStarAttrData, IUIBaseInputData { }
 
 // Path
 export interface IPath extends IUI {
@@ -84,34 +91,20 @@ export interface IPathData extends IUIData {
     path?: IPathCommandData
     windingRule?: IWindingRule
 }
-export interface IPathInputData extends IUIInputData {
+export interface IPathInputData extends IUIBaseInputData {
     path?: IPathCommandData | IPathString
     windingRule?: IWindingRule
 }
 
 // Pen
 
-export interface IPen extends IGroup {
+export interface IPen extends IGroup, IPathCreator {
     __: IPenData
-    path: IPath
+    pathElement: IPath
     pathStyle: IPathInputData
-    pathData: IPathCommandData
-
-    moveTo(x: number, y: number): IPen
-    lineTo(x: number, y: number): IPen
-    bezierCurveTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number): IPen
-    quadraticCurveTo(x1: number, y1: number, x: number, y: number): IPen
-
-    rect(x: number, y: number, width: number, height: number): IPen
-    roundRect(x: number, y: number, width: number, height: number, cornerRadius: number | number[]): IPen
-    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation?: number, startAngle?: number, endAngle?: number, anticlockwise?: boolean): IPen
-    arc(x: number, y: number, radius: number, startAngle?: number, endAngle?: number, anticlockwise?: boolean): IPen
-    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): IPen
-
-    close(): IPen
-    clear(): IPen
-
+    path: IPathCommandData
     paint(): void
+    clear(): void
 }
 
 export interface IPenData extends IGroupData { }
@@ -132,7 +125,7 @@ export interface ITextData extends ITextAttrData, ITextStyleComputedData, IUIDat
     __lineHeight?: number
     __letterSpacing?: number
 }
-export interface ITextInputData extends ITextAttrData, ITextStyleInputData, IUIInputData {
+export interface ITextInputData extends ITextAttrData, ITextStyleInputData, IUIBaseInputData {
 
 }
 
@@ -187,7 +180,7 @@ interface IImageAttrData {
     url?: string
 }
 export interface IImageData extends IImageAttrData, IRectData { }
-export interface IImageInputData extends IImageAttrData, IUIInputData { }
+export interface IImageInputData extends IImageAttrData, IUIBaseInputData { }
 
 export interface ICanvas extends IRect {
     __: ICanvasData
@@ -201,7 +194,7 @@ interface ICanvasAttrData {
     smooth?: boolean
 }
 export interface ICanvasData extends ICanvasAttrData, IRectData { }
-export interface ICanvasInputData extends ICanvasAttrData, IUIInputData { }
+export interface ICanvasInputData extends ICanvasAttrData, IUIBaseInputData { }
 
 
 // Leafer
@@ -254,15 +247,15 @@ export interface IGroup extends IUI {
     removeAll(): void
 }
 export interface IGroupData extends IUIData { }
-export interface IGroupInputData extends IUIInputData { }
+export interface IGroupInputData extends IUIBaseInputData { }
 
 // UI
 export interface IUI extends IFillAttrData, IStrokeAttrData, ICornerRadiusAttrData, IEffectAttrData, ILeaf {
     __: IUIData
     parent?: IGroup
 
-    set(data: IUITagInputData): void
-    get(): IUITagInputData
+    set(data: IUIInputData): void
+    toJSON(): IUIInputData
 
     getPath(curve?: boolean): IPathCommandData
     getPathString(curve?: boolean): IPathString
@@ -271,6 +264,8 @@ export interface IUI extends IFillAttrData, IStrokeAttrData, ICornerRadiusAttrDa
     __drawAfterFill?(canvas: ILeaferCanvas, options: IRenderOptions): void
 
     export(filename: string, options?: IExportOptions | number): Promise<IBlob | string | boolean>
+    clone(): IUI
+
 }
 
 export interface IUIData extends IUIComputedData, ILeafData {
@@ -306,16 +301,20 @@ export interface IUIData extends IUIComputedData, ILeafData {
 }
 export interface IUIComputedData extends IFillComputedData, IBorderComputedData, IStrokeComputedData, ITextStyleComputedData, ICornerRadiusComputedData, IEffectComputedData, ILeafComputedData {
     padding?: number | number[]
+
     locked?: boolean
 }
 
-export interface IUIInputData extends IFillInputData, IStrokeInputData, ITextStyleInputData, ICornerRadiusInputData, IEffectInputData, ILeafInputData {
+export interface IUIBaseInputData extends IFillInputData, IStrokeInputData, ITextStyleInputData, ICornerRadiusInputData, IEffectInputData, ILeafInputData {
     padding?: number | number[]
     locked?: boolean
+    children?: IUIBaseInputData[]
 }
 
 
 export type IUITag =
+    | 'App'
+    | 'Leafer'
     | 'Rect'
     | 'Ellipse'
     | 'Polygon'
@@ -331,6 +330,6 @@ export type IUITag =
     | 'Box'
 
 
-export interface IUITagInputData extends IRectInputData, IEllipseInputData, IPolygonInputData, IStarInputData, ILineInputData, IPathInputData, ITextInputData, IImageInputData, IGroupInputData, IFrameInputData, IObject {
-    tagName?: IUITag
+export interface IUIInputData extends IRectInputData, IEllipseInputData, IPolygonInputData, IStarInputData, ILineInputData, IPathInputData, ITextInputData, IImageInputData, IGroupInputData, IFrameInputData, IUIBaseInputData, IObject {
+
 }

package/src/index.ts

@@ -15,19 +15,21 @@ export {
     IBox, IBoxInputData, IBoxData,
     IGroup, IGroupInputData, IGroupData,
     ILeaferInputData, ILeaferData,
-    IUI, IUIInputData, IUIData,
-    IUITag, IUITagInputData
+    IUI, IUIBaseInputData, IUIData,
+    IUITag, IUIInputData
 } from './IUI'
 export { IUnitData, IVectorPath, IShadowEffect, IBlurEffect, IGrayscaleEffect, IStrokeAlign, IStrokeJoin, IStrokeCap, IRGB, IRGBA, IColor, IColorStop, IPaint, IGradientPaint, IImagePaint, IImagePaintMode, IFontWeight, ITextCase, ITextDecoration, ITextAlign, IVerticalAlign, IOverflow } from './type/IType'
 export { ICornerRadiusString, IStrokeWidthString, IPaintString, IShadowString, IPercent, IDashPatternString, IColorString as IStringColor } from './type/IStringType'
-export { ILeafFill, ILeafPaint, ILeafPaintColor, ILeafStrokePaint, ILeafShadowEffect } from './type/IComputedType'
+export { ILeafFill, ILeafPaint, ILeafPaintPatternData, ILeafPaintColor, ILeafStrokePaint, ILeafShadowEffect } from './type/IComputedType'
 
 export { IUIRenderModule, IRectRenderModule, IImageRenderModule, ITextRenderModule, IGroupRenderModule, IFrameRenderModule } from './module/IUIRender'
 export { IUIBoundsModule } from './module/IUIBounds'
 export { IUIHitModule } from './module/IUIHit'
+export { ITextConvertModule } from './module/ITextConvert'
+export { IColorConvertModule } from './module/IColorConvert'
 export { IExportModule, IExportOptions, IExportResult, IExportResultFunction } from './module/IExport'
 
+
 export { IPaintModule } from './module/IPaint'
 export { IEffectModule } from './module/IEffect'
-export { ICachedShape } from './ICachedShape'
-
+export { ICachedShape } from './ICachedShape'

package/src/module/IColorConvert.ts

@@ -0,0 +1,5 @@
+import { IColor } from '../type/IType'
+
+export interface IColorConvertModule {
+    string?(color: IColor, opacity?: number): string
+}

package/src/module/IExport.ts

@@ -15,5 +15,5 @@ export interface IExportResultFunction {
 
 
 export interface IExportModule {
-    export(leaf: ILeaf, filename: IExportFileType | string, options?: IExportOptions | number | boolean): Promise<IExportResult>
+    export?(leaf: ILeaf, filename: IExportFileType | string, options?: IExportOptions | number | boolean): Promise<IExportResult>
 }

package/src/module/IPaint.ts

@@ -1,25 +1,26 @@
-import { ILeaferCanvas, IRenderOptions } from '@leafer/interface'
+import { ILeaferCanvas, IRenderOptions, IBooleanMap } from '@leafer/interface'
 
 import { ILeafPaint } from '../type/IComputedType'
-import { IUI } from '../IUI'
+import { IUI, IUIData } from '../IUI'
 import { ICachedShape } from '../ICachedShape'
 
 export interface IPaintModule {
-    computeFill?(ui: IUI): void
-    computeStroke?(ui: IUI): void
+    compute?(ui: IUI, attrName: 'fill' | 'stroke'): void
 
-    fill?(ui: IUI, canvas: ILeaferCanvas, fill: string | object): void
+    fill?(ui: IUI, canvas: ILeaferCanvas, fill: string): void
     fills?(ui: IUI, canvas: ILeaferCanvas, fills: ILeafPaint[]): void
 
-    drawText?(ui: IUI, canvas: ILeaferCanvas): void
+    fillText?(ui: IUI, canvas: ILeaferCanvas): void
 
-    stroke?(ui: IUI, canvas: ILeaferCanvas, stroke: string | object): void
+    stroke?(ui: IUI, canvas: ILeaferCanvas, stroke: string): void
     strokes?(ui: IUI, canvas: ILeaferCanvas, strokes: ILeafPaint[]): void
 
-    strokeText?(ui: IUI, canvas: ILeaferCanvas, stroke: string | object): 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
 }

package/src/module/ITextConvert.ts

@@ -0,0 +1,5 @@
+import { ITextData, ITextDrawData } from '../IUI'
+
+export interface ITextConvertModule {
+    getDrawData?(content: string, style: ITextData): ITextDrawData
+}

package/src/type/IComputedType.ts

@@ -1,17 +1,31 @@
-import { IBlendMode, IMatrixData } from '@leafer/interface'
+import { IBlendMode, ILeaferImage, IMatrixData } from '@leafer/interface'
 
 import { IColorString } from './IStringType'
-import { IStrokeAlign, IStrokeJoin, IStrokeCap } from './IType'
+import { IStrokeAlign, IStrokeJoin, IStrokeCap, IImagePaintMode } from './IType'
 import { IPaintType } from './IType'
 
 export type ILeafPaintColor = IColorString | CanvasGradient | CanvasPattern
 
 export interface ILeafPaint {
-    type: IPaintType
-    style: ILeafPaintColor
+    type?: IPaintType
+    style?: ILeafPaintColor
     transform?: IMatrixData
     blendMode?: IBlendMode
     opacity?: number
+    image?: ILeaferImage
+    loadId?: number
+    patternId?: string
+    data?: ILeafPaintPatternData
+}
+
+export interface ILeafPaintPatternData {
+    width?: number
+    height?: number
+    scaleX?: number
+    scaleY?: number
+    opacity?: number
+    transform?: IMatrixData
+    mode?: IImagePaintMode
 }
 
 export type ILeafFill = ILeafPaint

package/src/type/IType.ts

@@ -1,4 +1,4 @@
-import { IPointData, IPathCommandData, IWindingRule, IBlendMode } from '@leafer/interface'
+import { IPointData, IPathCommandData, IWindingRule, IBlendMode, IExportFileType } from '@leafer/interface'
 import { IColorString } from './IStringType'
 
 export interface IUnitData {
@@ -61,6 +61,7 @@ export interface IImagePaint extends IPaintBase {
     type: "image"
     url: string
     mode?: IImagePaintMode
+    format?: IExportFileType
 
     filters?: IImageFilters
 

package/types/index.d.ts

@@ -0,0 +1,595 @@
+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';
+export * from '@leafer/interface';
+
+type IPercent = string;
+type IColorString = string;
+type ICornerRadiusString = string;
+type IStrokeWidthString = string;
+type IDashPatternString = string;
+type IPaintString = ISolidPaintString | IGradientPaintString | IImagePaintString;
+type ISolidPaintString = string;
+type IGradientPaintString = string;
+type IImagePaintString = string;
+type IShadowString = string;
+
+interface IUnitData {
+    type: 'percent' | 'px';
+    value: number;
+}
+type IPaint = ISolidPaint | IGradientPaint | IImagePaint;
+interface IPaintBase {
+    type: IPaintType;
+    blendMode?: IBlendMode;
+    visible?: boolean;
+    opacity?: number;
+}
+type IPaintType = 'image' | 'solid' | IGradientType;
+type IGradientType = 'linear' | 'radial' | 'angular';
+interface ISolidPaint extends IPaintBase {
+    type: 'solid';
+    color: IColor;
+}
+type IColor = IColorString | IRGB | IRGBA;
+interface IRGB {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+}
+interface IRGBA extends IRGB {
+    a: number;
+}
+interface IGradientPaint extends IPaintBase {
+    type: IGradientType;
+    from?: IPointData;
+    to?: IPointData;
+    stretch?: number;
+    stops: IColorStop[];
+}
+interface IColorStop {
+    offset: number;
+    color: IColor;
+}
+interface IImagePaint extends IPaintBase {
+    type: "image";
+    url: string;
+    mode?: IImagePaintMode;
+    format?: IExportFileType;
+    filters?: IImageFilters;
+    offset?: IPointData;
+    scale?: number | IPointData;
+    rotation?: number;
+}
+interface IImageFilters {
+    exposure?: number;
+    contrast?: number;
+    saturation?: number;
+    temperature?: number;
+    tint?: number;
+    highlights?: number;
+    shadows?: number;
+}
+type IImagePaintMode = 'cover' | 'fit' | 'strench' | 'clip' | 'repeat';
+type IStrokeAlign = 'inside' | 'outside' | 'center';
+type IStrokeCap = 'none' | 'round' | 'square' | 'arrow-lines' | 'arrow-equilateral';
+type IStrokeJoin = 'bevel' | 'round' | 'miter';
+type ITextAlign = 'left' | 'center' | 'right' | 'justify';
+type IVerticalAlign = 'top' | 'middle' | 'bottom';
+type ITextCase = 'upper' | 'lower' | 'title' | 'none' | 'small-caps';
+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';
+interface IVectorPath {
+    rule?: IWindingRule;
+    data: string | IPathCommandData;
+}
+interface IShadowEffect {
+    x: number;
+    y: number;
+    blur: number;
+    spread?: number;
+    color: IColorString | IColor;
+    blendMode?: IBlendMode;
+    visible?: boolean;
+    box?: boolean;
+}
+interface IBlurEffect {
+    blur: number;
+    visible?: boolean;
+}
+interface IGrayscaleEffect {
+    grayscale: number;
+    visible?: boolean;
+}
+type IOverflow = 'show' | 'hide';
+
+type ILeafPaintColor = IColorString | CanvasGradient | CanvasPattern;
+interface ILeafPaint {
+    type?: IPaintType;
+    style?: ILeafPaintColor;
+    transform?: IMatrixData;
+    blendMode?: IBlendMode;
+    opacity?: number;
+    image?: ILeaferImage;
+    loadId?: number;
+    patternId?: string;
+    data?: ILeafPaintPatternData;
+}
+interface ILeafPaintPatternData {
+    width?: number;
+    height?: number;
+    scaleX?: number;
+    scaleY?: number;
+    opacity?: number;
+    transform?: IMatrixData;
+    mode?: IImagePaintMode;
+}
+type ILeafFill = ILeafPaint;
+interface ILeafStrokePaint extends ILeafPaint {
+    strokeAlign?: IStrokeAlign;
+    strokeWidth?: number;
+    strokeCap?: IStrokeCap;
+    strokeJoin?: IStrokeJoin;
+    dashPattern?: number[];
+    miterLimit?: number;
+}
+interface ILeafShadowEffect {
+    x: number;
+    y: number;
+    blur: number;
+    spread?: number;
+    color: IColorString;
+    blendMode?: IBlendMode;
+    box?: boolean;
+}
+
+interface ICornerRadiusAttrData {
+    cornerRadius: number | number[] | ICornerRadiusString;
+    cornerSmoothing: number;
+}
+interface ICornerRadiusInputData {
+    cornerRadius?: number | number[] | ICornerRadiusString;
+    cornerSmoothing?: number;
+}
+interface ICornerRadiusComputedData {
+    cornerRadius?: number;
+    cornerSmoothing?: number;
+}
+interface IFillAttrData {
+    fill: IPaint | IPaint[] | IPaintString;
+}
+interface IFillInputData {
+    fill?: IPaint | IPaint[] | IPaintString;
+}
+interface IFillComputedData {
+    fill?: IColorString | ILeafPaint[];
+}
+interface IBorderComputedData {
+    borderWidth?: number | number[];
+    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;
+}
+interface IStrokeInputData {
+    stroke?: IPaint | IPaint[] | IPaintString;
+    strokeAlign?: IStrokeAlign;
+    strokeWidth?: number | number[] | IStrokeWidthString;
+    strokeCap?: IStrokeCap;
+    strokeJoin?: IStrokeJoin;
+    dashPattern?: number[] | IDashPatternString;
+    dashOffset?: number;
+    miterLimit?: number;
+}
+interface IStrokeComputedData {
+    stroke?: IColorString | ILeafStrokePaint[];
+    strokeAlign?: IStrokeAlign;
+    strokeWidth?: number;
+    strokeWidths?: number[];
+    strokeCap?: IStrokeCap;
+    strokeJoin?: IStrokeJoin;
+    dashPattern?: number[];
+    dashOffset?: number;
+    miterLimit?: number;
+}
+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;
+}
+interface ITextStyleInputData {
+    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;
+}
+interface ITextStyleComputedData {
+    fontFamily?: string;
+    fontSize?: number;
+    fontWeight?: IFontWeight;
+    italic?: boolean;
+    textCase?: ITextCase;
+    textDecoration?: ITextDecoration;
+    letterSpacing?: number;
+    lineHeight?: number;
+    paraIndent?: number;
+    paraSpacing?: number;
+    textAlign?: ITextAlign;
+    verticalAlign?: IVerticalAlign;
+    textOverflow?: IOverflow;
+}
+interface IEffectAttrData {
+    shadow: IShadowEffect | IShadowEffect[] | IShadowString;
+    innerShadow: IShadowEffect | IShadowEffect[] | IShadowString;
+    blur: number | IBlurEffect;
+    backgroundBlur: number | IBlurEffect;
+    grayscale: number | IGrayscaleEffect;
+}
+interface IEffectInputData {
+    shadow?: IShadowEffect | IShadowEffect[] | IShadowString;
+    innerShadow?: IShadowEffect | IShadowEffect[] | IShadowString;
+    blur?: number | IBlurEffect;
+    backgroundBlur?: number | IBlurEffect;
+    grayscale?: number | IGrayscaleEffect;
+}
+interface IEffectComputedData {
+    shadow?: ILeafShadowEffect[];
+    innerShadow?: ILeafShadowEffect[];
+    blur?: number;
+    backgroundBlur?: number;
+    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 ILine extends IUI {
+    __: ILineData;
+    toPoint: IPointData;
+    points: number[];
+    curve: boolean | number;
+}
+interface ILineData extends IUIData {
+}
+interface ILineInputData extends IUIBaseInputData {
+    toPoint?: IPointData;
+    points?: number[];
+    curve?: boolean | number;
+}
+interface IRect extends IUI {
+    __: IRectData;
+}
+interface IRectData extends IUIData {
+}
+interface IRectInputData extends IUIBaseInputData {
+}
+interface IEllipse extends IUI {
+    __: IEllipseData;
+    startAngle: number;
+    endAngle: number;
+    innerRadius: number;
+}
+interface IEllipseAttrData {
+    startAngle?: number;
+    endAngle?: number;
+    innerRadius?: number;
+}
+interface IEllipseData extends IEllipseAttrData, IUIData {
+}
+interface IEllipseInputData extends IEllipseAttrData, IUIBaseInputData {
+}
+interface IPolygon extends IUI {
+    __: IPolygonData;
+    sides: number;
+    points: number[];
+    curve: boolean | number;
+}
+interface IPolygonAttrData {
+    sides?: number;
+    points?: number[];
+    curve?: boolean | number;
+}
+interface IPolygonData extends IPolygonAttrData, IUIData {
+}
+interface IPolygonInputData extends IPolygonAttrData, IUIBaseInputData {
+}
+interface IStar extends IUI {
+    __: IStarData;
+    corners: number;
+    innerRadius: number;
+}
+interface IStarAttrData {
+    corners?: number;
+    innerRadius?: number;
+}
+interface IStarData extends IStarAttrData, IUIData {
+}
+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;
+    pathElement: IPath;
+    pathStyle: IPathInputData;
+    path: IPathCommandData;
+    paint(): void;
+    clear(): void;
+}
+interface IPenData extends IGroupData {
+}
+interface IPenInputData extends IGroupInputData {
+}
+interface IText extends ITextStyleAttrData, IUI {
+    __: ITextData;
+    text: string;
+}
+interface ITextAttrData {
+    text?: string;
+}
+interface ITextData extends ITextAttrData, ITextStyleComputedData, IUIData {
+    __baseLine?: number;
+    __lineHeight?: number;
+    __letterSpacing?: number;
+}
+interface ITextInputData extends ITextAttrData, ITextStyleInputData, IUIBaseInputData {
+}
+interface ITextRowData {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    text?: string;
+    data?: ITextCharData[];
+    words?: ITextWordData[];
+    paraStart?: boolean;
+    paraEnd?: boolean;
+    isOverflow?: boolean;
+}
+interface ITextWordData {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    data?: ITextCharData[];
+}
+interface ITextCharData {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    char?: string;
+}
+interface ITextDrawData {
+    bounds: IBoundsData;
+    rows: ITextRowData[];
+    paraNumber: number;
+    font: string;
+    decorationY?: number;
+    decorationHeight?: number;
+    overflow?: number;
+}
+interface IImage extends IRect, ILeaferImageConfig {
+    __: IImageData;
+    url: string;
+    ready: boolean;
+    image?: ILeaferImage;
+}
+interface IImageAttrData {
+    url?: string;
+}
+interface IImageData extends IImageAttrData, IRectData {
+}
+interface IImageInputData extends IImageAttrData, IUIBaseInputData {
+}
+interface ICanvas extends IRect {
+    __: ICanvasData;
+    pixelRatio: number;
+    smooth: boolean;
+    canvas: ILeaferCanvas;
+    __updateSize(): void;
+}
+interface ICanvasAttrData {
+    pixelRatio?: number;
+    smooth?: boolean;
+}
+interface ICanvasData extends ICanvasAttrData, IRectData {
+}
+interface ICanvasInputData extends ICanvasAttrData, IUIBaseInputData {
+}
+interface ILeaferData extends IGroupData {
+    pixelRatio?: number;
+}
+interface ILeaferInputData extends IGroupInputData {
+    pixelRatio?: number;
+}
+interface IFrame extends IBox {
+    __: IFrameData;
+}
+interface IFrameData extends IBoxData {
+}
+interface IFrameInputData extends IBoxInputData {
+}
+interface IBox extends IGroup {
+    __: IBoxData;
+    overflow: IOverflow;
+    __updateRectRenderBounds(): void;
+    __renderGroup(canvas: ILeaferCanvas, options: IRenderOptions): void;
+}
+interface IBoxData extends IGroupData {
+    overflow?: IOverflow;
+}
+interface IBoxInputData extends IGroupInputData {
+    overflow?: IOverflow;
+}
+interface IGroup extends IUI {
+    __: IGroupData;
+    children: IUI[];
+    mask?: IUI;
+    add(child: IUI, index?: number): void;
+    addAt(child: IUI, index: number): void;
+    addAfter(child: IUI, after: IUI): void;
+    addBefore(child: IUI, before: IUI): void;
+    remove(child?: IUI): void;
+    removeAll(): void;
+}
+interface IGroupData extends IUIData {
+}
+interface IGroupInputData extends IUIBaseInputData {
+}
+interface IUI extends IFillAttrData, IStrokeAttrData, ICornerRadiusAttrData, IEffectAttrData, ILeaf {
+    __: IUIData;
+    parent?: IGroup;
+    set(data: IUIInputData): void;
+    toJSON(): IUIInputData;
+    getPath(curve?: boolean): IPathCommandData;
+    getPathString(curve?: boolean): IPathString;
+    __drawPathByData(drawer: IPathDrawer, data: IPathCommandData): void;
+    __drawAfterFill?(canvas: ILeaferCanvas, options: IRenderOptions): void;
+    export(filename: string, options?: IExportOptions | number): Promise<IBlob | string | boolean>;
+    clone(): IUI;
+}
+interface IUIData extends IUIComputedData, ILeafData {
+    padding?: number | number[];
+    locked?: boolean;
+    __isFills?: boolean;
+    __isStrokes?: 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;
+}
+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[];
+}
+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 {
+}
+
+type IUIRenderModule = IUIRender & ThisType<IUI>;
+interface IUIRender extends ILeafRender {
+    __drawAfterFill?(canvas: ILeaferCanvas, options: IRenderOptions): void;
+}
+type IRectRenderModule = IRectRender & ThisType<IRect>;
+interface IRectRender extends IUIRender {
+}
+type IImageRenderModule = IImageRender & ThisType<IImage>;
+interface IImageRender extends IUIRender {
+}
+type ITextRenderModule = ITextRender & ThisType<IText>;
+interface ITextRender extends IUIRender {
+}
+type IGroupRenderModule = IGroupRender & ThisType<IGroup>;
+interface IGroupRender extends IUIRender {
+}
+type IFrameRenderModule = IFrameRender & ThisType<IFrame>;
+interface IFrameRender extends IGroupRender {
+}
+
+type IUIBoundsModule = IUIBounds & ThisType<IUI>;
+interface IUIBounds extends ILeafBounds {
+}
+
+type IUIHitModule = ILeafHit & ThisType<IUI>;
+
+interface ITextConvertModule {
+    getDrawData?(content: string, style: ITextData): ITextDrawData;
+}
+
+interface IColorConvertModule {
+    string?(color: IColor, opacity?: number): string;
+}
+
+interface ICachedShape extends ICachedLeaf {
+    worldCanvas?: ILeaferCanvas;
+    shapeBounds: IBoundsData;
+    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;
+}
+
+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;
+}
+
+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 };