@leafer-ui/display 1.0.0-rc.16 → 1.0.0-rc.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer-ui/display",
-  "version": "1.0.0-rc.16",
+  "version": "1.0.0-rc.18",
   "description": "@leafer-ui/display",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -22,14 +22,14 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/core": "1.0.0-rc.16",
-    "@leafer-ui/data": "1.0.0-rc.16",
-    "@leafer-ui/display-module": "1.0.0-rc.16",
-    "@leafer-ui/decorator": "1.0.0-rc.16",
-    "@leafer-ui/external": "1.0.0-rc.16"
+    "@leafer/core": "1.0.0-rc.18",
+    "@leafer-ui/data": "1.0.0-rc.18",
+    "@leafer-ui/display-module": "1.0.0-rc.18",
+    "@leafer-ui/decorator": "1.0.0-rc.18",
+    "@leafer-ui/external": "1.0.0-rc.18"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-rc.16",
-    "@leafer-ui/interface": "1.0.0-rc.16"
+    "@leafer/interface": "1.0.0-rc.18",
+    "@leafer-ui/interface": "1.0.0-rc.18"
   }
 }

package/src/Canvas.ts

@@ -3,9 +3,9 @@ import { Creator, Matrix, Platform, dataProcessor, registerUI, hitType } from '@
 
 import { ICanvas, ICanvasData, ICanvasInputData, IUI } from '@leafer-ui/interface'
 import { CanvasData } from '@leafer-ui/data'
+import { resizeType } from '@leafer-ui/decorator'
 
 import { Rect } from './Rect'
-import { resizeType } from '@leafer-ui/decorator'
 
 
 @registerUI()

package/src/Group.ts

@@ -51,7 +51,7 @@ export class Group extends UI implements IGroup {
 
             let child: IUI
             children.forEach(childData => {
-                child = UICreator.get(childData.tag, childData) as IUI
+                child = (childData as IUI).__ ? childData as IUI : UICreator.get(childData.tag, childData) as IUI
                 this.add(child)
             })
 

package/src/Leafer.ts

@@ -1,7 +1,7 @@
-import { ILeaferCanvas, IRenderer, ILayouter, ISelector, IWatcher, IInteraction, ILeaferConfig, ICanvasManager, IHitCanvasManager, IAutoBounds, IScreenSizeData, IResizeEvent, ILeaf, IEventListenerId, ITimer, IValue, IObject, IControl, IPointData, ILeaferType, ICursorType, IBoundsData, INumber } from '@leafer/interface'
+import { ILeaferCanvas, IRenderer, ILayouter, ISelector, IWatcher, IInteraction, ILeaferConfig, ICanvasManager, IHitCanvasManager, IAutoBounds, IScreenSizeData, IResizeEvent, IEventListenerId, ITimer, IValue, IObject, IControl, IPointData, ILeaferType, ICursorType, IBoundsData, INumber, IZoomType, IFourNumber } from '@leafer/interface'
 import { AutoBounds, LayoutEvent, ResizeEvent, LeaferEvent, CanvasManager, ImageManager, DataHelper, Creator, Run, Debug, RenderEvent, registerUI, boundsType, canvasSizeAttrs, dataProcessor, WaitHelper, WatchEvent, Bounds } from '@leafer/core'
 
-import { ILeaferInputData, ILeaferData, IFunction, IUIInputData, ILeafer, IGroup, IApp, IEditorBase } from '@leafer-ui/interface'
+import { ILeaferInputData, ILeaferData, IFunction, IUIInputData, ILeafer, IApp, IEditorBase } from '@leafer-ui/interface'
 import { LeaferData } from '@leafer-ui/data'
 import { Group } from './Group'
 
@@ -54,8 +54,6 @@ export class Leafer extends Group implements ILeafer {
     // plugin
     public editor: IEditorBase
 
-    public zoomLayer: IGroup = this
-
     public userConfig: ILeaferConfig
     public config: ILeaferConfig = {
         type: 'design',
@@ -69,7 +67,6 @@ export class Leafer extends Group implements ILeafer {
         move: {
             holdSpaceKey: true,
             holdMiddleKey: true,
-            dragOut: true,
             autoDistance: 2
         }
     }
@@ -236,10 +233,6 @@ export class Leafer extends Group implements ILeafer {
         this.__level = 1
     }
 
-    public setZoomLayer(zoomLayer: ILeaf): void {
-        this.zoomLayer = zoomLayer as IGroup
-    }
-
     protected __checkAutoLayout(config: ILeaferConfig): void {
         if (!config.width || !config.height) {
             this.autoLayout = new AutoBounds(config)
@@ -327,15 +320,18 @@ export class Leafer extends Group implements ILeafer {
         }
     }
 
-    public waitReady(item: IFunction): void {
+    public waitReady(item: IFunction, bind?: IObject): void {
+        if (bind) item = item.bind(bind)
         this.ready ? item() : this.__readyWait.push(item)
     }
 
-    public waitViewReady(item: IFunction): void {
+    public waitViewReady(item: IFunction, bind?: IObject): void {
+        if (bind) item = item.bind(bind)
         this.viewReady ? item() : this.__viewReadyWait.push(item)
     }
 
-    public waitViewCompleted(item: IFunction): void {
+    public waitViewCompleted(item: IFunction, bind?: IObject): void {
+        if (bind) item = item.bind(bind)
         this.__viewCompletedWait.push(item)
         if (this.viewCompleted) {
             this.__checkViewCompleted(false)
@@ -344,7 +340,8 @@ export class Leafer extends Group implements ILeafer {
         }
     }
 
-    public nextRender(item: IFunction, off?: 'off'): void {
+    public nextRender(item: IFunction, bind?: IObject, off?: 'off'): void {
+        if (bind) item = item.bind(bind)
         const list = this.__nextRenderWait
         if (off) {
             for (let i = 0; i < list.length; i++) {
@@ -355,6 +352,16 @@ export class Leafer extends Group implements ILeafer {
         }
     }
 
+    // need view plugin
+    public zoom(_zoomType: IZoomType, _padding?: IFourNumber, _fixedScale?: boolean): IBoundsData { return undefined }
+
+    public validScale(changeScale: number): number {
+        const { scaleX } = this.zoomLayer.__, { min, max } = this.app.config.zoom, absScale = Math.abs(scaleX * changeScale)
+        if (absScale < min) changeScale = min / scaleX
+        else if (absScale > max) changeScale = max / scaleX
+        return changeScale
+    }
+
     protected __checkUpdateLayout(): void {
         this.__layout.update()
     }

package/src/Pen.ts

@@ -20,7 +20,7 @@ export class Pen extends Group implements IPen {
     public pathStyle: IPathInputData
 
     @penPathType()
-    public path: IPathCommandData // use __path, readonly
+    declare public path: IPathCommandData // use __path, readonly
 
     public __path: IPathCommandData
 

package/src/UI.ts

@@ -1,8 +1,8 @@
-import { ILeaferCanvas, IPathDrawer, IPathCommandData, IHitType, INumber, IBoolean, IString, IPathString, IExportFileType, IPointData, ICursorType, IMaskType, IAround, IValue, IWindingRule } from '@leafer/interface'
-import { Leaf, PathDrawer, surfaceType, dataType, positionType, boundsType, pathType, scaleType, rotationType, opacityType, sortType, maskType, dataProcessor, registerUI, useModule, rewrite, rewriteAble, UICreator, PathCorner, hitType, strokeType, PathConvert, eraserType, cursorType, autoLayoutType, PathCreator, naturalBoundsType, pathInputType } from '@leafer/core'
+import { ILeaferCanvas, IPathDrawer, IPathCommandData, IHitType, INumber, IBoolean, IString, IPathString, IExportFileType, IPointData, ICursorType, IMaskType, IAround, IValue, IWindingRule, IPathCreator } from '@leafer/interface'
+import { Leaf, PathDrawer, surfaceType, dataType, positionType, boundsType, pathType, scaleType, rotationType, opacityType, sortType, maskType, dataProcessor, registerUI, useModule, rewrite, rewriteAble, UICreator, PathCorner, hitType, strokeType, PathConvert, eraserType, cursorType, autoLayoutType, pen, naturalBoundsType, pathInputType } from '@leafer/core'
 
 import { IUI, IShadowEffect, IBlurEffect, IStrokeAlign, IStrokeJoin, IStrokeCap, IBlendMode, IDashPatternString, IShadowString, IGrayscaleEffect, IUIData, IGroup, IStrokeWidthString, ICornerRadiusString, IUIInputData, IExportOptions, IExportResult, IFill, IStroke, IArrowType, IFindUIMethod, IEditSize, ILeafer } from '@leafer-ui/interface'
-import { arrowType, effectType } from '@leafer-ui/decorator'
+import { arrowType, effectType, stateType, zoomLayerType } from '@leafer-ui/decorator'
 
 import { UIData } from '@leafer-ui/data'
 import { UIBounds, UIRender } from '@leafer-ui/display-module'
@@ -10,6 +10,8 @@ import { UIBounds, UIRender } from '@leafer-ui/display-module'
 import { Export, PathArrow } from '@leafer-ui/external'
 
 
+
+
 @useModule(UIBounds)
 @useModule(UIRender)
 @rewriteAble()
@@ -26,6 +28,9 @@ export class UI extends Leaf implements IUI {
     declare public leafer?: ILeafer
     declare public parent?: IGroup
 
+    @zoomLayerType()
+    public zoomLayer: IGroup
+
     public get isFrame(): boolean { return false }
 
     declare public children?: IUI[]
@@ -53,9 +58,17 @@ export class UI extends Leaf implements IUI {
     @opacityType(true)
     public visible: IBoolean
 
+
+    @stateType(false)
+    public selected: IBoolean
+
+    @stateType(false)
+    public disabled: IBoolean
+
     @dataType(false)
     public locked: IBoolean
 
+
     @sortType(0)
     public zIndex: INumber
 
@@ -231,6 +244,27 @@ export class UI extends Leaf implements IUI {
     public grayscale: INumber | IGrayscaleEffect
 
 
+    // states
+
+    @dataType()
+    public normalStyle: IUIInputData // auto restore hover / press / focus / selected / disabled style
+
+    @dataType()
+    public hoverStyle: IUIInputData
+
+    @dataType()
+    public pressStyle: IUIInputData
+
+    @dataType()
+    public focusStyle: IUIInputData
+
+    @dataType()
+    public selectedStyle: IUIInputData
+
+    @dataType()
+    public disabledStyle: IUIInputData
+
+
     public set scale(value: INumber | IPointData) {
         if (typeof value === 'number') {
             this.scaleX = this.scaleY = value
@@ -246,6 +280,12 @@ export class UI extends Leaf implements IUI {
     }
 
 
+    public get pen(): IPathCreator {
+        pen.set(this.path = this.__.path || [])
+        return pen
+    }
+
+
     constructor(data?: IUIInputData) {
         super(data)
     }
@@ -261,8 +301,8 @@ export class UI extends Leaf implements IUI {
         Object.assign(this, data)
     }
 
-    public get(name?: string): IUIInputData | IValue {
-        return name ? this.__.__getInput(name) : this.__.__getInputData()
+    public get(name?: string | string[] | IUIInputData): IUIInputData | IValue {
+        return typeof name === 'string' ? this.__.__getInput(name) : this.__.__getInputData(name)
     }
 
     public createProxyData(): IUIInputData { return undefined }
@@ -281,9 +321,11 @@ export class UI extends Leaf implements IUI {
         this.__layout.update()
         let path = pathForRender ? this.__.__pathForRender : this.__.path
         if (!path) {
-            path = []
             const { width, height } = this.boxBounds
-            if (width || height) this.__drawPathByBox(new PathCreator(path))
+            if (width || height) {
+                pen.set(path = [])
+                this.__drawPathByBox(pen)
+            }
         }
         return curve ? PathConvert.toCanvasData(path, true) : path
     }

package/types/index.d.ts

@@ -0,0 +1,384 @@
+import { IString, INumber, IBoolean, IMaskType, IAround, IHitType, ICursorType, IPathCommandData, IPathString, IWindingRule, IPointData, IPathCreator, IValue, ILeaferCanvas, IPathDrawer, IExportFileType, IPickOptions, IPickResult, IRenderer, IWatcher, ILayouter, ISelector, IInteraction, ICanvasManager, IHitCanvasManager, ILeaferConfig, IAutoBounds, IEventListenerId, ITimer, IControl, ILeaferType, IScreenSizeData, IBoundsData, IResizeEvent, IObject, IZoomType, IFourNumber, IRenderOptions, ILeaferImage, ICanvasContext2D } from '@leafer/interface';
+import { Leaf } from '@leafer/core';
+import { IUI, IUIData, IUIInputData, ILeafer, IGroup, IBlendMode, IEditSize, IFill, IStroke, IStrokeAlign, IStrokeWidthString, IStrokeCap, IStrokeJoin, IDashPatternString, IArrowType, ICornerRadiusString, IShadowEffect, IShadowString, IBlurEffect, IGrayscaleEffect, IFindUIMethod, IExportOptions, IExportResult, IGroupData, IGroupInputData, ILeaferData, IApp, IEditorBase, IFunction, ILeaferInputData, IBox, IBoxData, IOverflow, IBoxInputData, IFrame, IFrameData, IFrameInputData, IRect, IRectData, IRectInputData, IEllipse, IEllipseData, IEllipseInputData, IPolygon, IPolygonData, IPolygonInputData, IStar, IStarData, IStarInputData, ILine, ILineData, ILineInputData, IImage, IImageData, IImageInputData, ICanvas, ICanvasData, ICanvasInputData, IText, ITextData, IHitType as IHitType$1, IFontWeight, ITextCase, ITextDecoration, IUnitData, ITextAlign, IVerticalAlign, ITextWrap, ITextDrawData, ITextInputData, IPath, IPathData, IPathInputData, IPen, IPenData, IPathCommandData as IPathCommandData$1, IPenInputData } from '@leafer-ui/interface';
+
+declare class UI extends Leaf implements IUI {
+    __: IUIData;
+    proxyData: IUIInputData;
+    __proxyData?: IUIInputData;
+    get app(): ILeafer;
+    leafer?: ILeafer;
+    parent?: IGroup;
+    zoomLayer: IGroup;
+    get isFrame(): boolean;
+    children?: IUI[];
+    id: IString;
+    name: IString;
+    className: IString;
+    blendMode: IBlendMode;
+    opacity: INumber;
+    visible: IBoolean;
+    selected: IBoolean;
+    disabled: IBoolean;
+    locked: IBoolean;
+    zIndex: INumber;
+    mask: IBoolean;
+    maskType: IMaskType;
+    eraser: IBoolean;
+    x: INumber;
+    y: INumber;
+    width: INumber;
+    height: INumber;
+    scaleX: INumber;
+    scaleY: INumber;
+    rotation: INumber;
+    skewX: INumber;
+    skewY: INumber;
+    around: IAround;
+    draggable: IBoolean;
+    editable: IBoolean;
+    editSize?: IEditSize;
+    hittable: IBoolean;
+    hitFill: IHitType;
+    hitStroke: IHitType;
+    hitBox: IBoolean;
+    hitChildren: IBoolean;
+    hitSelf: IBoolean;
+    hitRadius: INumber;
+    cursor: ICursorType | ICursorType[];
+    fill: IFill;
+    stroke: IStroke;
+    strokeAlign: IStrokeAlign;
+    strokeWidth: INumber | INumber[] | IStrokeWidthString;
+    strokeWidthFixed: IBoolean;
+    strokeCap: IStrokeCap;
+    strokeJoin: IStrokeJoin;
+    dashPattern: INumber[] | IDashPatternString;
+    dashOffset: INumber;
+    miterLimit: INumber;
+    lazy: IBoolean;
+    pixelRatio: INumber;
+    path: IPathCommandData | IPathString;
+    windingRule: IWindingRule;
+    startArrow: IArrowType;
+    endArrow: IArrowType;
+    cornerRadius: number | number[] | ICornerRadiusString;
+    cornerSmoothing: INumber;
+    shadow: IShadowEffect | IShadowEffect[] | IShadowString;
+    innerShadow: IShadowEffect | IShadowEffect[] | IShadowString;
+    blur: INumber | IBlurEffect;
+    backgroundBlur: INumber | IBlurEffect;
+    grayscale: INumber | IGrayscaleEffect;
+    normalStyle: IUIInputData;
+    hoverStyle: IUIInputData;
+    pressStyle: IUIInputData;
+    focusStyle: IUIInputData;
+    selectedStyle: IUIInputData;
+    disabledStyle: IUIInputData;
+    set scale(value: INumber | IPointData);
+    get scale(): INumber | IPointData;
+    get pen(): IPathCreator;
+    constructor(data?: IUIInputData);
+    reset(_data?: IUIInputData): void;
+    set(data: IUIInputData): void;
+    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;
+    getPath(curve?: boolean, pathForRender?: boolean): IPathCommandData;
+    getPathString(curve?: boolean, pathForRender?: boolean): IPathString;
+    __onUpdateSize(): void;
+    __updateRenderPath(): void;
+    __drawRenderPath(canvas: ILeaferCanvas): void;
+    __drawPath(canvas: ILeaferCanvas): void;
+    __drawPathByData(drawer: IPathDrawer, data: IPathCommandData): void;
+    __drawPathByBox(drawer: IPathDrawer): void;
+    export(filename: IExportFileType | string, options?: IExportOptions | number | boolean): Promise<IExportResult>;
+    clone(): IUI;
+    static one(data: IUIInputData, x?: number, y?: number, width?: number, height?: number): IUI;
+    static registerUI(): void;
+    static registerData(data: IUIData): void;
+    destroy(): void;
+}
+
+declare class Group extends UI implements IGroup {
+    get __tag(): string;
+    get isBranch(): boolean;
+    __: IGroupData;
+    children: IUI[];
+    constructor(data?: IGroupInputData);
+    reset(data?: IGroupInputData): void;
+    __setBranch(): void;
+    set(data: IUIInputData): void;
+    toJSON(): IUIInputData;
+    pick(_hitPoint: IPointData, _options?: IPickOptions): IPickResult;
+    addAt(child: IUI, index: number): void;
+    addAfter(child: IUI, after: IUI): void;
+    addBefore(child: UI, before: IUI): void;
+    add(_child: IUI, _index?: number): void;
+    addMany(..._children: IUI[]): void;
+    remove(_child?: IUI, _destroy?: boolean): void;
+    removeAll(_destroy?: boolean): void;
+    clear(): void;
+}
+
+declare class Leafer extends Group implements ILeafer {
+    get __tag(): string;
+    __: ILeaferData;
+    pixelRatio: INumber;
+    get isApp(): boolean;
+    get app(): ILeafer;
+    get isLeafer(): boolean;
+    parent?: IApp;
+    running: boolean;
+    created: boolean;
+    ready: boolean;
+    viewReady: boolean;
+    viewCompleted: boolean;
+    get imageReady(): boolean;
+    get layoutLocked(): boolean;
+    transforming: boolean;
+    view: unknown;
+    canvas: ILeaferCanvas;
+    renderer: IRenderer;
+    watcher: IWatcher;
+    layouter: ILayouter;
+    selector?: ISelector;
+    interaction?: IInteraction;
+    canvasManager: ICanvasManager;
+    hitCanvasManager?: IHitCanvasManager;
+    editor: IEditorBase;
+    userConfig: ILeaferConfig;
+    config: ILeaferConfig;
+    autoLayout?: IAutoBounds;
+    get cursorPoint(): IPointData;
+    leafs: number;
+    __eventIds: IEventListenerId[];
+    protected __startTimer: ITimer;
+    protected __controllers: IControl[];
+    protected __readyWait: IFunction[];
+    protected __viewReadyWait: IFunction[];
+    protected __viewCompletedWait: IFunction[];
+    __nextRenderWait: IFunction[];
+    constructor(userConfig?: ILeaferConfig, data?: ILeaferInputData);
+    init(userConfig?: ILeaferConfig, parentApp?: IApp): void;
+    onInit(): void;
+    initType(_type: ILeaferType): void;
+    set(data: IUIInputData): void;
+    start(): void;
+    stop(): void;
+    unlockLayout(): void;
+    lockLayout(): void;
+    resize(size: IScreenSizeData): void;
+    forceFullRender(): void;
+    forceRender(bounds?: IBoundsData): void;
+    updateCursor(cursor?: ICursorType): void;
+    protected __doResize(size: IScreenSizeData): void;
+    protected __onResize(event: IResizeEvent): void;
+    protected __setApp(): void;
+    protected __bindApp(app: IApp): void;
+    __setLeafer(leafer: ILeafer): void;
+    protected __checkAutoLayout(config: ILeaferConfig): void;
+    __setAttr(attrName: string, newValue: IValue): void;
+    __getAttr(attrName: string): IValue;
+    protected __changeCanvasSize(attrName: string, newValue: number): void;
+    protected __changeFill(newValue: string): void;
+    protected __onCreated(): void;
+    protected __onReady(): void;
+    protected __onViewReady(): void;
+    protected __onNextRender(): void;
+    protected __checkViewCompleted(emit?: boolean): void;
+    protected __onWatchData(): void;
+    waitReady(item: IFunction, bind?: IObject): void;
+    waitViewReady(item: IFunction, bind?: IObject): void;
+    waitViewCompleted(item: IFunction, bind?: IObject): void;
+    nextRender(item: IFunction, bind?: IObject, off?: 'off'): void;
+    zoom(_zoomType: IZoomType, _padding?: IFourNumber, _fixedScale?: boolean): IBoundsData;
+    validScale(changeScale: number): number;
+    protected __checkUpdateLayout(): void;
+    protected emitLeafer(type: string): void;
+    protected __listenEvents(): void;
+    protected __removeListenEvents(): void;
+    destroy(): void;
+}
+
+declare class Box extends Group implements IBox {
+    get __tag(): string;
+    get isBranchLeaf(): boolean;
+    __: IBoxData;
+    overflow: IOverflow;
+    constructor(data?: IBoxInputData);
+    __updateStrokeSpread(): number;
+    __updateRectRenderSpread(): number;
+    __updateRenderSpread(): number;
+    __updateRectBoxBounds(): void;
+    __updateBoxBounds(): void;
+    __updateStrokeBounds(): void;
+    __updateRenderBounds(): void;
+    __updateRectRenderBounds(): void;
+    __updateRectChange(): void;
+    __updateChange(): void;
+    __renderRect(_canvas: ILeaferCanvas, _options: IRenderOptions): void;
+    __renderGroup(_canvas: ILeaferCanvas, _options: IRenderOptions): void;
+    __render(canvas: ILeaferCanvas, options: IRenderOptions): void;
+    __drawAfterFill(canvas: ILeaferCanvas, options: IRenderOptions): void;
+}
+
+declare class Frame extends Box implements IFrame {
+    get __tag(): string;
+    get isFrame(): boolean;
+    __: IFrameData;
+    fill: IFill;
+    overflow: IOverflow;
+    constructor(data?: IFrameInputData);
+}
+
+declare class Rect extends UI implements IRect {
+    get __tag(): string;
+    __: IRectData;
+    constructor(data?: IRectInputData);
+}
+
+declare class Ellipse extends UI implements IEllipse {
+    get __tag(): string;
+    __: IEllipseData;
+    innerRadius: INumber;
+    startAngle: INumber;
+    endAngle: INumber;
+    constructor(data?: IEllipseInputData);
+    __updatePath(): void;
+}
+
+declare class Polygon extends UI implements IPolygon {
+    get __tag(): string;
+    __: IPolygonData;
+    sides: INumber;
+    points: number[];
+    curve: boolean | number;
+    constructor(data?: IPolygonInputData);
+    __updatePath(): void;
+    __updateRenderPath(): void;
+    __updateBoxBounds(): void;
+}
+
+declare class Star extends UI implements IStar {
+    get __tag(): string;
+    __: IStarData;
+    corners: INumber;
+    innerRadius: INumber;
+    constructor(data?: IStarInputData);
+    __updatePath(): void;
+}
+
+declare class Line extends UI implements ILine {
+    get __tag(): string;
+    __: ILineData;
+    strokeAlign: IStrokeAlign;
+    height: INumber;
+    points: number[];
+    curve: boolean | number;
+    get toPoint(): IPointData;
+    set toPoint(value: IPointData);
+    constructor(data?: ILineInputData);
+    __updatePath(): void;
+    __updateRenderPath(): void;
+    __updateBoxBounds(): void;
+}
+
+declare class Image extends Rect implements IImage {
+    get __tag(): string;
+    __: IImageData;
+    url: IString;
+    get ready(): boolean;
+    image: ILeaferImage;
+    constructor(data?: IImageInputData);
+    destroy(): void;
+}
+
+declare class Canvas extends Rect implements ICanvas {
+    get __tag(): string;
+    __: ICanvasData;
+    width: INumber;
+    height: INumber;
+    pixelRatio: INumber;
+    smooth: boolean;
+    hitFill: IHitType;
+    canvas: ILeaferCanvas;
+    context: ICanvasContext2D;
+    constructor(data?: ICanvasInputData);
+    draw(ui: IUI, offset?: IPointData, scale?: number | IPointData, rotation?: number): void;
+    paint(): void;
+    __drawAfterFill(canvas: ILeaferCanvas, _options: IRenderOptions): void;
+    __updateSize(): void;
+    destroy(): void;
+}
+
+declare class Text extends UI implements IText {
+    get __tag(): string;
+    __: ITextData;
+    width: INumber;
+    height: INumber;
+    padding: number | number[];
+    fill: IFill;
+    strokeAlign: IStrokeAlign;
+    hitFill: IHitType$1;
+    text: IString;
+    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;
+    get textDrawData(): ITextDrawData;
+    constructor(data?: ITextInputData);
+    __drawHitPath(canvas: ILeaferCanvas): void;
+    __drawPathByData(drawer: IPathDrawer, _data?: IPathCommandData): void;
+    __drawRenderPath(canvas: ILeaferCanvas): void;
+    __updateTextDrawData(): void;
+    __updateBoxBounds(): void;
+    __updateRenderSpread(): number;
+    __updateRenderBounds(): void;
+}
+
+declare class Path extends UI implements IPath {
+    get __tag(): string;
+    __: IPathData;
+    strokeAlign: IStrokeAlign;
+    constructor(data?: IPathInputData);
+}
+
+declare class Pen extends Group implements IPen {
+    get __tag(): string;
+    __: IPenData;
+    pathElement: IPath;
+    pathStyle: IPathInputData;
+    path: IPathCommandData$1;
+    __path: IPathCommandData$1;
+    constructor(data?: IPenInputData);
+    setStyle(data: IPathInputData): Pen;
+    beginPath(): Pen;
+    moveTo(_x: number, _y: number): Pen;
+    lineTo(_x: number, _y: number): Pen;
+    bezierCurveTo(_x1: number, _y1: number, _x2: number, _y2: number, _x: number, _y: number): Pen;
+    quadraticCurveTo(_x1: number, _y1: number, _x: number, _y: number): Pen;
+    closePath(): Pen;
+    rect(_x: number, _y: number, _width: number, _height: number): Pen;
+    roundRect(_x: number, _y: number, _width: number, _height: number, _cornerRadius: number | number[]): Pen;
+    ellipse(_x: number, _y: number, _radiusX: number, _radiusY: number, _rotation?: number, _startAngle?: number, _endAngle?: number, _anticlockwise?: boolean): Pen;
+    arc(_x: number, _y: number, _radius: number, _startAngle?: number, _endAngle?: number, _anticlockwise?: boolean): Pen;
+    arcTo(_x1: number, _y1: number, _x2: number, _y2: number, _radius: number): Pen;
+    drawEllipse(_x: number, _y: number, _radiusX: number, _radiusY: number, _rotation?: number, _startAngle?: number, _endAngle?: number, _anticlockwise?: boolean): Pen;
+    drawArc(_x: number, _y: number, _radius: number, _startAngle?: number, _endAngle?: number, _anticlockwise?: boolean): Pen;
+    drawPoints(_points: number[], _curve?: boolean | number, _close?: boolean): Pen;
+    paint(): void;
+}
+
+export { Box, Canvas, Ellipse, Frame, Group, Image, Leafer, Line, Path, Pen, Polygon, Rect, Star, Text, UI };