@leafer/display 1.0.0-rc.9 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/display",
-  "version": "1.0.0-rc.9",
+  "version": "1.0.1",
   "description": "@leafer/display",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -22,16 +22,16 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/math": "1.0.0-rc.9",
-    "@leafer/data": "1.0.0-rc.9",
-    "@leafer/layout": "1.0.0-rc.9",
-    "@leafer/display-module": "1.0.0-rc.9",
-    "@leafer/event": "1.0.0-rc.9",
-    "@leafer/decorator": "1.0.0-rc.9",
-    "@leafer/helper": "1.0.0-rc.9",
-    "@leafer/platform": "1.0.0-rc.9"
+    "@leafer/math": "1.0.1",
+    "@leafer/data": "1.0.1",
+    "@leafer/layout": "1.0.1",
+    "@leafer/display-module": "1.0.1",
+    "@leafer/event": "1.0.1",
+    "@leafer/decorator": "1.0.1",
+    "@leafer/helper": "1.0.1",
+    "@leafer/platform": "1.0.1"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-rc.9"
+    "@leafer/interface": "1.0.1"
   }
 }

package/src/Branch.ts

@@ -3,7 +3,7 @@ import { ChildEvent } from '@leafer/event'
 import { BoundsHelper } from '@leafer/math'
 import { BranchHelper, LeafBoundsHelper, WaitHelper } from '@leafer/helper'
 import { useModule } from '@leafer/decorator'
-import { BranchRender, LeafMask } from '@leafer/display-module'
+import { BranchRender } from '@leafer/display-module'
 
 import { Leaf } from './Leaf'
 
@@ -14,14 +14,7 @@ const { localBoxBounds, localStrokeBounds, localRenderBounds, maskLocalBoxBounds
 
 
 @useModule(BranchRender)
-@useModule(LeafMask)
-export class Branch extends Leaf {
-
-    constructor() {
-        super()
-        this.isBranch = true
-        this.children = []
-    }
+export class Branch extends Leaf { // tip: rewrited Group
 
     // overwrite
 
@@ -70,12 +63,16 @@ export class Branch extends Leaf {
     }
 
     public add(child: ILeaf, index?: number): void {
+        if (child === this) return
+
         if (child.parent) child.parent.remove(child)
         child.parent = this
 
         index === undefined ? this.children.push(child) : this.children.splice(index, 0, child)
         if (child.isBranch) this.__.__childBranchNumber = (this.__.__childBranchNumber || 0) + 1
-        child.__layout.boundsChanged || child.__layout.matrixChange() // layouted(removed), need update
+
+        child.__layout.boxChanged || child.__layout.boxChange() // layouted(removed), need update
+        child.__layout.matrixChanged || child.__layout.matrixChange() // layouted(removed), need update
 
         if (child.__parentWait) WaitHelper.run(child.__parentWait)
 
@@ -91,7 +88,7 @@ export class Branch extends Leaf {
         children.forEach(child => this.add(child))
     }
 
-    public remove(child?: Leaf, destroy?: boolean): void {
+    public remove(child?: ILeaf, destroy?: boolean): void {
         if (child) {
             const index = this.children.indexOf(child)
             if (index > -1) {
@@ -119,6 +116,10 @@ export class Branch extends Leaf {
         }
     }
 
+    public clear(): void {
+        this.removeAll(true)
+    }
+
     protected __preRemove(): void {
         if (this.__hasMask) this.__updateMask()
         if (this.__hasEraser) this.__updateEraser()

package/src/Leaf.ts

@@ -1,21 +1,22 @@
-import { ILeaferBase, ILeaf, ILeafInputData, ILeafData, ILeaferCanvas, IRenderOptions, IBoundsType, ILocationType, IMatrixWithBoundsData, ILayoutBoundsData, IValue, ILeafLayout, InnerId, IHitCanvas, IRadiusPointData, IEventListenerMap, IEventListener, IEventListenerOptions, IEventListenerId, IEvent, IObject, IFunction, IPointData, IBoundsData, IBranch, IMatrixWithLayoutData, IFindMethod, ILayoutAttr, IMatrixData, IAttrDecorator } from '@leafer/interface'
-import { IncrementId, MatrixHelper, PointHelper } from '@leafer/math'
+import { ILeaferBase, ILeaf, ILeafInputData, ILeafData, ILeaferCanvas, IRenderOptions, IBoundsType, ILocationType, IMatrixWithBoundsData, ILayoutBoundsData, IValue, ILeafLayout, InnerId, IHitCanvas, IRadiusPointData, IEventListenerMap, IEventListener, IEventListenerId, IEvent, IObject, IFunction, IPointData, IBoundsData, IBranch, IFindMethod, IMatrixData, IAttrDecorator, IMatrixWithBoundsScaleData, IMatrixWithScaleData, IAlign, IJSONOptions, IEventMap, IEventOption, IAxis } from '@leafer/interface'
+import { BoundsHelper, IncrementId, MatrixHelper, PointHelper } from '@leafer/math'
 import { LeafData } from '@leafer/data'
 import { LeafLayout } from '@leafer/layout'
-import { LeafDataProxy, LeafMatrix, LeafBounds, LeafHit, LeafEventer, LeafRender } from '@leafer/display-module'
+import { LeafDataProxy, LeafMatrix, LeafBounds, LeafEventer, LeafRender } from '@leafer/display-module'
 import { boundsType, useModule, defineDataProcessor } from '@leafer/decorator'
 import { LeafHelper, WaitHelper } from '@leafer/helper'
+import { ChildEvent } from '@leafer/event'
 
 
 const { LEAF, create } = IncrementId
-const { toInnerPoint, toOuterPoint } = MatrixHelper
-const { tempToOuterOf, copy } = PointHelper
-const { moveLocal, zoomOfLocal, rotateOfLocal, skewOfLocal, transform, setTransform, drop } = LeafHelper
+const { toInnerPoint, toOuterPoint, multiplyParent } = MatrixHelper
+const { toOuterOf } = BoundsHelper
+const { copy } = PointHelper
+const { moveLocal, zoomOfLocal, rotateOfLocal, skewOfLocal, moveWorld, zoomOfWorld, rotateOfWorld, skewOfWorld, transform, transformWorld, setTransform, getFlipTransform, getLocalOrigin, getRelativeWorld, drop } = LeafHelper
 
 @useModule(LeafDataProxy)
 @useModule(LeafMatrix)
 @useModule(LeafBounds)
-@useModule(LeafHit)
 @useModule(LeafEventer)
 @useModule(LeafRender)
 export class Leaf implements ILeaf {
@@ -34,27 +35,31 @@ export class Leaf implements ILeaf {
     public leafer?: ILeaferBase
     public parent?: ILeaf
 
-    public isLeafer: boolean
-    public isBranch: boolean
-    public isBranchLeaf: boolean
+    public get isLeafer(): boolean { return false }
+    public get isBranch(): boolean { return false }
+    public get isBranchLeaf(): boolean { return false }
 
     public __: ILeafData
     public __layout: ILeafLayout
 
-    public __world: IMatrixWithLayoutData
+    public __world: IMatrixWithBoundsScaleData
     public __local?: IMatrixWithBoundsData // and localStrokeBounds? localRenderBounds?
 
+    public __nowWorld?: IMatrixWithBoundsScaleData // use __world or __cameraWorld render
+    public __cameraWorld?: IMatrixWithBoundsScaleData // use camera matrix render  
+
     public get __localMatrix(): IMatrixData { return this.__local || this.__layout }
-    public get __localBounds(): IBoundsData { return this.__local || this.__ as IBoundsData }
+    public get __localBoxBounds(): IBoundsData { return this.__local || this.__layout }
 
     public __worldOpacity: number
 
     // now transform
-    public get worldTransform(): IMatrixWithLayoutData { return this.__layout.getTransform('world') as IMatrixWithLayoutData }
-    public get localTransform(): IMatrixWithBoundsData { return this.__layout.getTransform('local') as IMatrixWithBoundsData }
+    public get worldTransform(): IMatrixWithScaleData { return this.__layout.getTransform('world') as IMatrixWithScaleData }
+    public get localTransform(): IMatrixData { return this.__layout.getTransform('local') }
 
     // now bounds
     public get boxBounds(): IBoundsData { return this.getBounds('box', 'inner') }
+    public get renderBounds(): IBoundsData { return this.getBounds('render', 'inner') }
     public get worldBoxBounds(): IBoundsData { return this.getBounds('box') }
     public get worldStrokeBounds(): IBoundsData { return this.getBounds('stroke') }
     public get worldRenderBounds(): IBoundsData { return this.getBounds('render') }
@@ -74,8 +79,13 @@ export class Leaf implements ILeaf {
 
     public get __onlyHitMask(): boolean { return this.__hasMask && !this.__.hitChildren }
     public get __ignoreHitWorld(): boolean { return (this.__hasMask || this.__hasEraser) && this.__.hitChildren }
+    public get __inLazyBounds(): boolean { const { leafer } = this; return leafer && leafer.created && leafer.lazyBounds.hit(this.__world) }
+
+    public get pathInputed(): boolean { return this.__.__pathInputed as unknown as boolean }
 
     // event
+    public set event(map: IEventMap) { let event; for (let key in map) event = map[key], event instanceof Array ? this.on(key, event[0], event[1]) : this.on(key, event) }
+
     public __captureMap?: IEventListenerMap
     public __bubbleMap?: IEventListenerMap
 
@@ -99,7 +109,7 @@ export class Leaf implements ILeaf {
 
     public reset(data?: ILeafInputData): void {
 
-        this.__world = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0, x: 0, y: 0, width: 0, height: 0, scaleX: 1, scaleY: 1, rotation: 0, skewX: 0, skewY: 0 }
+        this.__world = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0, x: 0, y: 0, width: 0, height: 0, scaleX: 1, scaleY: 1 }
         if (data !== null) this.__local = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0, x: 0, y: 0, width: 0, height: 0 }
 
         this.__worldOpacity = 1
@@ -108,7 +118,10 @@ export class Leaf implements ILeaf {
         this.__layout = new this.__LayoutProcessor(this)
 
         if (this.__level) this.resetCustom()
-        if (data) data.children ? this.set(data) : Object.assign(this, data)
+        if (data) {
+            if ((data as ILeaf).__) data = (data as ILeaf).toJSON()
+            data.children ? this.set(data) : Object.assign(this, data)
+        }
     }
 
     public resetCustom(): void {
@@ -117,16 +130,22 @@ export class Leaf implements ILeaf {
     }
 
 
-    public waitParent(item: IFunction): void {
+    public waitParent(item: IFunction, bind?: IObject): void {
+        if (bind) item = item.bind(bind)
         this.parent ? item() : (this.__parentWait ? this.__parentWait.push(item) : this.__parentWait = [item])
     }
 
-    public waitLeafer(item: IFunction): void {
+    public waitLeafer(item: IFunction, bind?: IObject): void {
+        if (bind) item = item.bind(bind)
         this.leafer ? item() : (this.__leaferWait ? this.__leaferWait.push(item) : this.__leaferWait = [item])
     }
 
-    public nextRender(item: IFunction): void {
-        this.leafer ? this.leafer.nextRender(item) : this.waitLeafer(() => this.leafer.nextRender(item))
+    public nextRender(item: IFunction, bind?: IObject, off?: 'off'): void {
+        this.leafer ? this.leafer.nextRender(item, bind, off) : this.waitLeafer(() => this.leafer.nextRender(item, bind, off))
+    }
+
+    public removeNextRender(item: IFunction): void {
+        this.nextRender(item, null, 'off')
     }
 
     public __bindLeafer(leafer: ILeaferBase | null): void {
@@ -155,19 +174,31 @@ export class Leaf implements ILeaf {
     // data
 
     public set(_data: IObject): void { }
-    public get(): ILeafInputData { return undefined }
+    public get(_name?: string): ILeafInputData | IValue { return undefined }
+
+    public setAttr(name: string, value: any): void { (this as IObject)[name] = value }
+    public getAttr(name: string): any { return (this as IObject)[name] }
 
-    public toJSON(): IObject {
-        return this.__.__getInputData()
+    public getComputedAttr(name: string): any { return (this.__ as IObject)[name] }
+
+    public toJSON(options?: IJSONOptions): IObject {
+        if (options) this.__layout.update()
+        return this.__.__getInputData(null, options)
     }
 
-    public toString(): string {
-        return JSON.stringify(this.toJSON())
+    public toString(options?: IJSONOptions): string {
+        return JSON.stringify(this.toJSON(options))
     }
 
+    public toSVG(): string { return undefined }
+
+    public __SVG(_data: IObject): void { }
+
+    public toHTML(): string { return undefined }
+
     // LeafDataProxy rewrite
 
-    public __setAttr(_attrName: string, _newValue: IValue): void { }
+    public __setAttr(_attrName: string, _newValue: IValue): boolean { return true }
 
     public __getAttr(_attrName: string): IValue { return undefined }
 
@@ -182,10 +213,25 @@ export class Leaf implements ILeaf {
 
     public find(_condition: number | string | IFindMethod, _options?: any): ILeaf[] { return undefined }
 
-    public findOne(_condition: number | string | IFindMethod, _options?: any): ILeaf { return undefined }
+    public findTag(_tag: string | string[]): ILeaf[] { return undefined }
+
+    public findOne(_condition: number | string | IFindMethod, _options?: any): ILeaf | undefined { return undefined }
+
+    public findId(_id: number | string): ILeaf | undefined { return undefined }
+
+    // ---
+
+
+    // state
+
+    public focus(_value?: boolean): void { }
 
     // ---
 
+    public updateLayout(): void {
+        this.__layout.update()
+    }
+
     public forceUpdate(attrName?: string): void {
         if (attrName === undefined) attrName = 'width'
         else if (attrName === 'surface') attrName = 'blendMode'
@@ -194,11 +240,10 @@ export class Leaf implements ILeaf {
         (this as any)[attrName] = value
     }
 
-    public updateLayout(): void {
-        this.__layout.update()
+    public forceRender(_bounds?: IBoundsData): void {
+        this.forceUpdate('surface')
     }
 
-
     // LeafMatrix rewrite
 
     public __updateWorldMatrix(): void { }
@@ -224,12 +269,17 @@ export class Leaf implements ILeaf {
 
     public __updateBoxBounds(): void { }
 
+    public __updateContentBounds(): void { }
+
     public __updateStrokeBounds(): void { }
 
     public __updateRenderBounds(): void { }
 
 
     public __updateAutoLayout(): void { }
+
+    public __updateFlowLayout(): void { }
+
     public __updateNaturalSize(): void { }
 
 
@@ -242,28 +292,49 @@ export class Leaf implements ILeaf {
     // ---
 
 
-    // LeafMask rewrite
+    public __updateEraser(value?: boolean): void {
+        this.__hasEraser = value ? true : this.children.some(item => item.__.eraser)
+    }
 
-    public __updateEraser(_value?: boolean): void { }
+    public __renderEraser(canvas: ILeaferCanvas, options: IRenderOptions): void {  // path eraser
+        canvas.save()
+        this.__clip(canvas, options)
+        const { renderBounds: r } = this.__layout
+        canvas.clearRect(r.x, r.y, r.width, r.height)
+        canvas.restore()
+    }
 
-    public __updateMask(_value?: boolean): void { }
+    public __updateMask(value?: boolean): void {
+        this.__hasMask = value ? true : this.children.some(item => item.__.mask)
+    }
 
-    public __renderMask(_canvas: ILeaferCanvas, _content: ILeaferCanvas, _mask: ILeaferCanvas, _recycle?: boolean): void { }
+    // LeafMask rewrite
+
+    public __renderMask(_canvas: ILeaferCanvas, _options: IRenderOptions): void { }
 
-    public __removeMask(_child?: ILeaf): void { }
 
     // ---
 
 
     // convert
 
-    public getWorld(attrName: ILayoutAttr): number {
-        this.__layout.update()
-        if (attrName === 'x') return this.__world.e
-        if (attrName === 'y') return this.__world.f
-        return this.__world[attrName]
+    public __getNowWorld(options: IRenderOptions): IMatrixWithBoundsScaleData {
+        if (options.matrix) {
+            if (!this.__cameraWorld) this.__cameraWorld = {} as IMatrixWithBoundsScaleData
+            const cameraWorld = this.__cameraWorld
+            multiplyParent(this.__world, options.matrix, cameraWorld, undefined, this.__world)
+            toOuterOf(this.__layout.renderBounds, cameraWorld, cameraWorld)
+            return cameraWorld
+        } else {
+            return this.__world
+        }
+    }
+
+    public getTransform(relative?: ILocationType | ILeaf): IMatrixData {
+        return this.__layout.getTransform(relative || 'local')
     }
 
+
     public getBounds(type?: IBoundsType, relative?: ILocationType | ILeaf): IBoundsData {
         return this.__layout.getBounds(type, relative)
     }
@@ -277,6 +348,14 @@ export class Leaf implements ILeaf {
     }
 
 
+    public getWorldBounds(inner: IBoundsData, relative?: ILeaf, change?: boolean): IBoundsData {
+        const matrix = relative ? getRelativeWorld(this, relative) : this.worldTransform
+        const to = change ? inner : {} as IBoundsData
+        toOuterOf(inner, matrix, to)
+        return to
+    }
+
+
     public worldToLocal(world: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void {
         if (this.parent) {
             this.parent.worldToInner(world, to, distance, relative)
@@ -340,8 +419,18 @@ export class Leaf implements ILeaf {
         return point
     }
 
+    public getPagePoint(world: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData {
+        const layer = this.leafer ? this.leafer.zoomLayer : this
+        return layer.getInnerPoint(world, relative, distance, change)
+    }
+
+    public getWorldPointByPage(page: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData {
+        const layer = this.leafer ? this.leafer.zoomLayer : this
+        return layer.getWorldPoint(page, relative, distance, change)
+    }
+
 
-    // transform
+    // transform 
 
     public setTransform(matrix: IMatrixData, resize?: boolean): void {
         setTransform(this, matrix, resize)
@@ -351,47 +440,74 @@ export class Leaf implements ILeaf {
         transform(this, matrix, resize)
     }
 
-
-    public move(x: number, y?: number): void {
+    public move(x: number | IPointData, y?: number): void {
         moveLocal(this, x, y)
     }
 
-    public scaleOf(origin: IPointData, scaleX: number, scaleY?: number, resize?: boolean): void {
-        zoomOfLocal(this, tempToOuterOf(origin, this.localTransform), scaleX, scaleY, resize)
+    public scaleOf(origin: IPointData | IAlign, scaleX: number, scaleY?: number, resize?: boolean): void {
+        zoomOfLocal(this, getLocalOrigin(this, origin), scaleX, scaleY, resize)
     }
 
-    public rotateOf(origin: IPointData, rotation: number): void {
-        rotateOfLocal(this, tempToOuterOf(origin, this.localTransform), rotation)
+    public rotateOf(origin: IPointData | IAlign, rotation: number): void {
+        rotateOfLocal(this, getLocalOrigin(this, origin), rotation)
     }
 
-    public skewOf(origin: IPointData, skewX: number, skewY?: number, resize?: boolean): void {
-        skewOfLocal(this, tempToOuterOf(origin, this.localTransform), skewX, skewY, resize)
+    public skewOf(origin: IPointData | IAlign, skewX: number, skewY?: number, resize?: boolean): void {
+        skewOfLocal(this, getLocalOrigin(this, origin), skewX, skewY, resize)
     }
 
+    public transformWorld(worldTransform?: IMatrixData, resize?: boolean): void {
+        transformWorld(this, worldTransform, resize)
+    }
 
-    public scaleResize(scaleX: number, scaleY = scaleX, noResize?: boolean): void {
-        const data = this as ILeaf
-        if (noResize) {
-            data.scaleX *= scaleX
-            data.scaleY *= scaleY
-        } else {
-            if (scaleX < 0) data.scaleX *= -1, scaleX = -scaleX
-            if (scaleY < 0) data.scaleY *= -1, scaleY = -scaleY
-            this.__scaleResize(scaleX, scaleY)
-        }
+    public moveWorld(x: number | IPointData, y?: number): void {
+        moveWorld(this, x, y)
+    }
+
+    public scaleOfWorld(worldOrigin: IPointData, scaleX: number, scaleY?: number, resize?: boolean): void {
+        zoomOfWorld(this, worldOrigin, scaleX, scaleY, resize)
     }
 
-    public __scaleResize(scaleX: number, scaleY: number): void {
-        if (scaleX !== 1) (this as ILeaf).width *= scaleX
-        if (scaleY !== 1) (this as ILeaf).height *= scaleY // Text auto height
+    public rotateOfWorld(worldOrigin: IPointData, rotation: number): void {
+        rotateOfWorld(this, worldOrigin, rotation)
     }
 
-    // LeafHit rewrite
+    public skewOfWorld(worldOrigin: IPointData, skewX: number, skewY?: number, resize?: boolean): void {
+        skewOfWorld(this, worldOrigin, skewX, skewY, resize)
+    }
+
+    public flip(axis: IAxis): void {
+        transform(this, getFlipTransform(this, axis))
+    }
+
+
+    // @leafer-in/resize rewrite
+
+    public scaleResize(scaleX: number, scaleY = scaleX, _noResize?: boolean): void {
+        (this as ILeaf).scaleX *= scaleX;
+        (this as ILeaf).scaleY *= scaleY
+    }
+
+    public __scaleResize(_scaleX: number, _scaleY: number): void { }
+
+
+    public resizeWidth(_width: number): void { }
+
+    public resizeHeight(_height: number): void { }
+
+
+    // @leafer-ui/hit LeafHit rewrite
 
     public __hitWorld(_point: IRadiusPointData): boolean { return true }
 
     public __hit(_local: IRadiusPointData): boolean { return true }
 
+    public __hitFill(_inner: IRadiusPointData): boolean { return true }
+
+    public __hitStroke(_inner: IRadiusPointData, _strokeWidth: number): boolean { return true }
+
+    public __hitPixel(_inner: IRadiusPointData): boolean { return true }
+
     public __drawHitPath(_canvas: ILeaferCanvas): void { }
 
     public __updateHitCanvas(): void { }
@@ -407,7 +523,10 @@ export class Leaf implements ILeaf {
 
     public __draw(_canvas: ILeaferCanvas, _options: IRenderOptions): void { }
 
-    public __renderShape(_canvas: ILeaferCanvas, _options: IRenderOptions): void { }
+
+    public __clip(_canvas: ILeaferCanvas, _options: IRenderOptions): void { }
+
+    public __renderShape(_canvas: ILeaferCanvas, _options: IRenderOptions, _ignoreFill?: boolean, _ignoreStroke?: boolean): void { }
 
 
     public __updateWorldOpacity(): void { }
@@ -447,11 +566,11 @@ export class Leaf implements ILeaf {
 
     // LeafEventer rewrite
 
-    public on(_type: string | string[], _listener: IEventListener, _options?: IEventListenerOptions | boolean): void { }
+    public on(_type: string | string[], _listener: IEventListener, _options?: IEventOption): void { }
 
-    public off(_type: string | string[], _listener: IEventListener, _options?: IEventListenerOptions | boolean): void { }
+    public off(_type?: string | string[], _listener?: IEventListener, _options?: IEventOption): void { }
 
-    public on_(_type: string | string[], _listener: IEventListener, _bind?: IObject, _options?: IEventListenerOptions | boolean): IEventListenerId { return undefined }
+    public on_(_type: string | string[], _listener: IEventListener, _bind?: IObject, _options?: IEventOption): IEventListenerId { return undefined }
 
     public off_(_id: IEventListenerId | IEventListenerId[]): void { }
 
@@ -465,8 +584,8 @@ export class Leaf implements ILeaf {
 
     // ---
 
-    static changeAttr(attrName: string, defaultValue: IValue): void {
-        defineDataProcessor(this.prototype, attrName, defaultValue)
+    static changeAttr(attrName: string, defaultValue: IValue, fn?: IAttrDecorator): void {
+        fn ? this.addAttr(attrName, defaultValue, fn) : defineDataProcessor(this.prototype, attrName, defaultValue)
     }
 
     static addAttr(attrName: string, defaultValue: IValue, fn?: IAttrDecorator): void {
@@ -477,8 +596,10 @@ export class Leaf implements ILeaf {
 
     public destroy(): void {
         if (!this.destroyed) {
-            if (this.parent) this.remove()
+            const { parent } = this
+            if (parent) this.remove()
             if (this.children) (this as unknown as IBranch).removeAll(true)
+            if (this.hasEvent(ChildEvent.DESTROY)) this.emitEvent(new ChildEvent(ChildEvent.DESTROY, this, parent))
 
             this.__.destroy()
             this.__layout.destroy()

package/types/index.d.ts

@@ -1,4 +1,4 @@
-import { ILeaf, InnerId, ILeaferBase, ILeafData, ILeafLayout, IMatrixWithLayoutData, IMatrixWithBoundsData, IMatrixData, IBoundsData, IHitCanvas, IEventListenerMap, IFunction, ILeafInputData, IObject, IValue, IFindMethod, ILeaferCanvas, ILayoutAttr, IBoundsType, ILocationType, ILayoutBoundsData, IPointData, IRadiusPointData, IRenderOptions, IEventListener, IEventListenerOptions, IEventListenerId, IEvent, IAttrDecorator } from '@leafer/interface';
+import { ILeaf, InnerId, ILeaferBase, ILeafData, ILeafLayout, IMatrixWithBoundsScaleData, IMatrixWithBoundsData, IMatrixData, IBoundsData, IMatrixWithScaleData, IHitCanvas, IEventMap, IEventListenerMap, IFunction, ILeafInputData, IObject, IValue, IJSONOptions, IFindMethod, ILeaferCanvas, IRenderOptions, ILocationType, IBoundsType, ILayoutBoundsData, IPointData, IAlign, IAxis, IRadiusPointData, IEventListener, IEventOption, IEventListenerId, IEvent, IAttrDecorator } from '@leafer/interface';
 import { LeafData } from '@leafer/data';
 import { LeafLayout } from '@leafer/layout';
 
@@ -12,19 +12,22 @@ declare class Leaf implements ILeaf {
     get __LayoutProcessor(): typeof LeafLayout;
     leafer?: ILeaferBase;
     parent?: ILeaf;
-    isLeafer: boolean;
-    isBranch: boolean;
-    isBranchLeaf: boolean;
+    get isLeafer(): boolean;
+    get isBranch(): boolean;
+    get isBranchLeaf(): boolean;
     __: ILeafData;
     __layout: ILeafLayout;
-    __world: IMatrixWithLayoutData;
+    __world: IMatrixWithBoundsScaleData;
     __local?: IMatrixWithBoundsData;
+    __nowWorld?: IMatrixWithBoundsScaleData;
+    __cameraWorld?: IMatrixWithBoundsScaleData;
     get __localMatrix(): IMatrixData;
-    get __localBounds(): IBoundsData;
+    get __localBoxBounds(): IBoundsData;
     __worldOpacity: number;
-    get worldTransform(): IMatrixWithLayoutData;
-    get localTransform(): IMatrixWithBoundsData;
+    get worldTransform(): IMatrixWithScaleData;
+    get localTransform(): IMatrixData;
     get boxBounds(): IBoundsData;
+    get renderBounds(): IBoundsData;
     get worldBoxBounds(): IBoundsData;
     get worldStrokeBounds(): IBoundsData;
     get worldRenderBounds(): IBoundsData;
@@ -38,6 +41,9 @@ declare class Leaf implements ILeaf {
     __hitCanvas?: IHitCanvas;
     get __onlyHitMask(): boolean;
     get __ignoreHitWorld(): boolean;
+    get __inLazyBounds(): boolean;
+    get pathInputed(): boolean;
+    set event(map: IEventMap);
     __captureMap?: IEventListenerMap;
     __bubbleMap?: IEventListenerMap;
     __parentWait?: IFunction[];
@@ -48,22 +54,33 @@ declare class Leaf implements ILeaf {
     constructor(data?: ILeafInputData);
     reset(data?: ILeafInputData): void;
     resetCustom(): void;
-    waitParent(item: IFunction): void;
-    waitLeafer(item: IFunction): void;
-    nextRender(item: IFunction): void;
+    waitParent(item: IFunction, bind?: IObject): void;
+    waitLeafer(item: IFunction, bind?: IObject): void;
+    nextRender(item: IFunction, bind?: IObject, off?: 'off'): void;
+    removeNextRender(item: IFunction): void;
     __bindLeafer(leafer: ILeaferBase | null): void;
     set(_data: IObject): void;
-    get(): ILeafInputData;
-    toJSON(): IObject;
-    toString(): string;
-    __setAttr(_attrName: string, _newValue: IValue): void;
+    get(_name?: string): ILeafInputData | IValue;
+    setAttr(name: string, value: any): void;
+    getAttr(name: string): any;
+    getComputedAttr(name: string): any;
+    toJSON(options?: IJSONOptions): IObject;
+    toString(options?: IJSONOptions): string;
+    toSVG(): string;
+    __SVG(_data: IObject): void;
+    toHTML(): string;
+    __setAttr(_attrName: string, _newValue: IValue): boolean;
     __getAttr(_attrName: string): IValue;
     setProxyAttr(_attrName: string, _newValue: IValue): void;
     getProxyAttr(_attrName: string): IValue;
     find(_condition: number | string | IFindMethod, _options?: any): ILeaf[];
-    findOne(_condition: number | string | IFindMethod, _options?: any): ILeaf;
-    forceUpdate(attrName?: string): void;
+    findTag(_tag: string | string[]): ILeaf[];
+    findOne(_condition: number | string | IFindMethod, _options?: any): ILeaf | undefined;
+    findId(_id: number | string): ILeaf | undefined;
+    focus(_value?: boolean): void;
     updateLayout(): void;
+    forceUpdate(attrName?: string): void;
+    forceRender(_bounds?: IBoundsData): void;
     __updateWorldMatrix(): void;
     __updateLocalMatrix(): void;
     __updateWorldBounds(): void;
@@ -72,21 +89,25 @@ declare class Leaf implements ILeaf {
     __updateLocalStrokeBounds(): void;
     __updateLocalRenderBounds(): void;
     __updateBoxBounds(): void;
+    __updateContentBounds(): void;
     __updateStrokeBounds(): void;
     __updateRenderBounds(): void;
     __updateAutoLayout(): void;
+    __updateFlowLayout(): void;
     __updateNaturalSize(): void;
     __updateStrokeSpread(): number;
     __updateRenderSpread(): number;
     __onUpdateSize(): void;
-    __updateEraser(_value?: boolean): void;
-    __updateMask(_value?: boolean): void;
-    __renderMask(_canvas: ILeaferCanvas, _content: ILeaferCanvas, _mask: ILeaferCanvas, _recycle?: boolean): void;
-    __removeMask(_child?: ILeaf): void;
-    getWorld(attrName: ILayoutAttr): number;
+    __updateEraser(value?: boolean): void;
+    __renderEraser(canvas: ILeaferCanvas, options: IRenderOptions): void;
+    __updateMask(value?: boolean): void;
+    __renderMask(_canvas: ILeaferCanvas, _options: IRenderOptions): void;
+    __getNowWorld(options: IRenderOptions): IMatrixWithBoundsScaleData;
+    getTransform(relative?: ILocationType | ILeaf): IMatrixData;
     getBounds(type?: IBoundsType, relative?: ILocationType | ILeaf): IBoundsData;
     getLayoutBounds(type?: IBoundsType, relative?: ILocationType | ILeaf, unscale?: boolean): ILayoutBoundsData;
     getLayoutPoints(type?: IBoundsType, relative?: ILocationType | ILeaf): IPointData[];
+    getWorldBounds(inner: IBoundsData, relative?: ILeaf, change?: boolean): IBoundsData;
     worldToLocal(world: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void;
     localToWorld(local: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void;
     worldToInner(world: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void;
@@ -97,22 +118,36 @@ declare class Leaf implements ILeaf {
     getLocalPointByInner(inner: IPointData, _relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
     getWorldPoint(inner: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
     getWorldPointByLocal(local: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
+    getPagePoint(world: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
+    getWorldPointByPage(page: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
     setTransform(matrix: IMatrixData, resize?: boolean): void;
     transform(matrix: IMatrixData, resize?: boolean): void;
-    move(x: number, y?: number): void;
-    scaleOf(origin: IPointData, scaleX: number, scaleY?: number, resize?: boolean): void;
-    rotateOf(origin: IPointData, rotation: number): void;
-    skewOf(origin: IPointData, skewX: number, skewY?: number, resize?: boolean): void;
-    scaleResize(scaleX: number, scaleY?: number, noResize?: boolean): void;
-    __scaleResize(scaleX: number, scaleY: number): void;
+    move(x: number | IPointData, y?: number): void;
+    scaleOf(origin: IPointData | IAlign, scaleX: number, scaleY?: number, resize?: boolean): void;
+    rotateOf(origin: IPointData | IAlign, rotation: number): void;
+    skewOf(origin: IPointData | IAlign, skewX: number, skewY?: number, resize?: boolean): void;
+    transformWorld(worldTransform?: IMatrixData, resize?: boolean): void;
+    moveWorld(x: number | IPointData, y?: number): void;
+    scaleOfWorld(worldOrigin: IPointData, scaleX: number, scaleY?: number, resize?: boolean): void;
+    rotateOfWorld(worldOrigin: IPointData, rotation: number): void;
+    skewOfWorld(worldOrigin: IPointData, skewX: number, skewY?: number, resize?: boolean): void;
+    flip(axis: IAxis): void;
+    scaleResize(scaleX: number, scaleY?: number, _noResize?: boolean): void;
+    __scaleResize(_scaleX: number, _scaleY: number): void;
+    resizeWidth(_width: number): void;
+    resizeHeight(_height: number): void;
     __hitWorld(_point: IRadiusPointData): boolean;
     __hit(_local: IRadiusPointData): boolean;
+    __hitFill(_inner: IRadiusPointData): boolean;
+    __hitStroke(_inner: IRadiusPointData, _strokeWidth: number): boolean;
+    __hitPixel(_inner: IRadiusPointData): boolean;
     __drawHitPath(_canvas: ILeaferCanvas): void;
     __updateHitCanvas(): void;
     __render(_canvas: ILeaferCanvas, _options: IRenderOptions): void;
     __drawFast(_canvas: ILeaferCanvas, _options: IRenderOptions): void;
     __draw(_canvas: ILeaferCanvas, _options: IRenderOptions): void;
-    __renderShape(_canvas: ILeaferCanvas, _options: IRenderOptions): void;
+    __clip(_canvas: ILeaferCanvas, _options: IRenderOptions): void;
+    __renderShape(_canvas: ILeaferCanvas, _options: IRenderOptions, _ignoreFill?: boolean, _ignoreStroke?: boolean): void;
     __updateWorldOpacity(): void;
     __updateChange(): void;
     __drawPath(_canvas: ILeaferCanvas): void;
@@ -123,21 +158,20 @@ declare class Leaf implements ILeaf {
     add(_child: ILeaf, _index?: number): void;
     remove(_child?: ILeaf, destroy?: boolean): void;
     dropTo(parent: ILeaf, index?: number, resize?: boolean): void;
-    on(_type: string | string[], _listener: IEventListener, _options?: IEventListenerOptions | boolean): void;
-    off(_type: string | string[], _listener: IEventListener, _options?: IEventListenerOptions | boolean): void;
-    on_(_type: string | string[], _listener: IEventListener, _bind?: IObject, _options?: IEventListenerOptions | boolean): IEventListenerId;
+    on(_type: string | string[], _listener: IEventListener, _options?: IEventOption): void;
+    off(_type?: string | string[], _listener?: IEventListener, _options?: IEventOption): void;
+    on_(_type: string | string[], _listener: IEventListener, _bind?: IObject, _options?: IEventOption): IEventListenerId;
     off_(_id: IEventListenerId | IEventListenerId[]): void;
     once(_type: string | string[], _listener: IEventListener, _capture?: boolean): void;
     emit(_type: string, _event?: IEvent | IObject, _capture?: boolean): void;
     emitEvent(_event?: IEvent, _capture?: boolean): void;
     hasEvent(_type: string, _capture?: boolean): boolean;
-    static changeAttr(attrName: string, defaultValue: IValue): void;
+    static changeAttr(attrName: string, defaultValue: IValue, fn?: IAttrDecorator): void;
     static addAttr(attrName: string, defaultValue: IValue, fn?: IAttrDecorator): void;
     destroy(): void;
 }
 
 declare class Branch extends Leaf {
-    constructor();
     __updateStrokeSpread(): number;
     __updateRenderSpread(): number;
     __updateBoxBounds(): void;
@@ -146,8 +180,9 @@ declare class Branch extends Leaf {
     __updateSortChildren(): void;
     add(child: ILeaf, index?: number): void;
     addMany(...children: ILeaf[]): void;
-    remove(child?: Leaf, destroy?: boolean): void;
+    remove(child?: ILeaf, destroy?: boolean): void;
     removeAll(destroy?: boolean): void;
+    clear(): void;
     protected __preRemove(): void;
     protected __realRemoveChild(child: ILeaf): void;
     protected __emitChildEvent(type: string, child: ILeaf): void;