@leafer/display 1.0.0-beta.9 → 1.0.0-rc.10

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@leafer/display",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0-rc.10",
   "description": "@leafer/display",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
   "main": "src/index.ts",
+  "types": "types/index.d.ts",
   "files": [
-    "src"
+    "src",
+    "types",
+    "dist"
   ],
   "repository": {
     "type": "git",
@@ -19,15 +22,16 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/math": "1.0.0-beta.9",
-    "@leafer/data": "1.0.0-beta.9",
-    "@leafer/layout": "1.0.0-beta.9",
-    "@leafer/display-module": "1.0.0-beta.9",
-    "@leafer/event": "1.0.0-beta.9",
-    "@leafer/decorator": "1.0.0-beta.9",
-    "@leafer/helper": "1.0.0-beta.9"
+    "@leafer/math": "1.0.0-rc.10",
+    "@leafer/data": "1.0.0-rc.10",
+    "@leafer/layout": "1.0.0-rc.10",
+    "@leafer/display-module": "1.0.0-rc.10",
+    "@leafer/event": "1.0.0-rc.10",
+    "@leafer/decorator": "1.0.0-rc.10",
+    "@leafer/helper": "1.0.0-rc.10",
+    "@leafer/platform": "1.0.0-rc.10"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-beta.9"
+    "@leafer/interface": "1.0.0-rc.10"
   }
 }

package/src/Branch.ts

@@ -3,18 +3,17 @@ 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'
 
 
-const { setByListWithHandle } = BoundsHelper
+const { setListWithFn } = BoundsHelper
 const { sort } = BranchHelper
-const { localBoxBounds, localEventBounds, localRenderBounds, maskLocalBoxBounds, maskLocalEventBounds, maskLocalRenderBounds } = LeafBoundsHelper
+const { localBoxBounds, localStrokeBounds, localRenderBounds, maskLocalBoxBounds, maskLocalStrokeBounds, maskLocalRenderBounds } = LeafBoundsHelper
 
 
 @useModule(BranchRender)
-@useModule(LeafMask)
 export class Branch extends Leaf {
 
     constructor() {
@@ -42,27 +41,30 @@ export class Branch extends Leaf {
     }
 
     public __updateBoxBounds(): void {
-        setByListWithHandle(this.__layout.boxBounds, this.children, this.__hasMask ? maskLocalBoxBounds : localBoxBounds)
+        setListWithFn(this.__layout.boxBounds, this.children, this.__hasMask ? maskLocalBoxBounds : localBoxBounds)
     }
 
     public __updateStrokeBounds(): void {
-        setByListWithHandle(this.__layout.strokeBounds, this.children, this.__hasMask ? maskLocalEventBounds : localEventBounds)
+        setListWithFn(this.__layout.strokeBounds, this.children, this.__hasMask ? maskLocalStrokeBounds : localStrokeBounds)
     }
 
     public __updateRenderBounds(): void {
-        setByListWithHandle(this.__layout.renderBounds, this.children, this.__hasMask ? maskLocalRenderBounds : localRenderBounds)
+        setListWithFn(this.__layout.renderBounds, this.children, this.__hasMask ? maskLocalRenderBounds : localRenderBounds)
     }
 
 
     // own
 
     public __updateSortChildren(): void {
+        let affectSort: boolean
         const { children } = this
         if (children.length > 1) {
             for (let i = 0, len = children.length; i < len; i++) {
                 children[i].__tempNumber = i
+                if (children[i].__.zIndex) affectSort = true
             }
             children.sort(sort)
+            this.__layout.affectChildrenSort = affectSort
         }
     }
 
@@ -72,17 +74,23 @@ export class Branch extends Leaf {
 
         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.positionChange() // layouted(removed), need update
+        child.__layout.boundsChanged || child.__layout.matrixChange() // layouted(removed), need update
 
         if (child.__parentWait) WaitHelper.run(child.__parentWait)
 
         if (this.leafer) {
             child.__bindLeafer(this.leafer)
-            if (this.leafer.ready) this.__emitChildEvent(ChildEvent.ADD, child)
+            if (this.leafer.created) this.__emitChildEvent(ChildEvent.ADD, child)
         }
+
+        this.__layout.affectChildrenSort && this.__layout.childrenSortChange()
+    }
+
+    public addMany(...children: ILeaf[]): void {
+        children.forEach(child => this.add(child))
     }
 
-    public remove(child?: Leaf): void {
+    public remove(child?: Leaf, destroy?: boolean): void {
         if (child) {
             const index = this.children.indexOf(child)
             if (index > -1) {
@@ -90,31 +98,45 @@ export class Branch extends Leaf {
                 if (child.isBranch) this.__.__childBranchNumber = (this.__.__childBranchNumber || 1) - 1
                 this.__preRemove()
                 this.__realRemoveChild(child)
+                if (destroy) child.destroy()
             }
         } else if (child === undefined) {
-            super.remove()
+            super.remove(null, destroy)
         }
     }
 
-    public removeAll(): void {
+    public removeAll(destroy?: boolean): void {
         const { children } = this
-        this.children = []
-        this.__preRemove()
-        this.__.__childBranchNumber = 0
-        children.forEach(child => { this.__realRemoveChild(child) })
+        if (children.length) {
+            this.children = []
+            this.__preRemove()
+            this.__.__childBranchNumber = 0
+            children.forEach(child => {
+                this.__realRemoveChild(child)
+                if (destroy) child.destroy()
+            })
+        }
+    }
+
+    public clear(): void {
+        this.removeAll(true)
     }
 
     protected __preRemove(): void {
         if (this.__hasMask) this.__updateMask()
         if (this.__hasEraser) this.__updateEraser()
         this.__layout.boxChange()
+        this.__layout.affectChildrenSort && this.__layout.childrenSortChange()
     }
 
     protected __realRemoveChild(child: ILeaf): void {
         child.parent = null
         if (this.leafer) {
             child.__bindLeafer(null)
-            if (this.leafer.ready) this.__emitChildEvent(ChildEvent.REMOVE, child)
+            if (this.leafer.created) {
+                this.__emitChildEvent(ChildEvent.REMOVE, child)
+                if (this.leafer.hitCanvasManager) this.leafer.hitCanvasManager.clear()
+            }
         }
     }
 
@@ -124,4 +146,5 @@ export class Branch extends Leaf {
         if (this.hasEvent(type) && !this.isLeafer) this.emitEvent(event)
         this.leafer.emitEvent(event)
     }
+
 }

package/src/Leaf.ts

@@ -1,18 +1,21 @@
-import { ILeafer, ILeaf, ILeafInputData, ILeafData, ILeaferCanvas, IRenderOptions, IMatrixWithBoundsData, __Number, __Boolean, __Value, ILeafLayout, InnerId, IHitCanvas, IRadiusPointData, IEventListenerMap, IEventListener, IEventListenerOptions, IEventListenerId, IEvent, IObject, IFunction, __String, IPointData, IMatrixDecompositionAttr, ILayoutBoundsType, ILayoutLocationType, IBoundsData, IMatrixData } 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, IEventListenerOptions, IEventListenerId, IEvent, IObject, IFunction, IPointData, IBoundsData, IBranch, IFindMethod, ILayoutAttr, IMatrixData, IAttrDecorator, IMatrixWithBoundsScaleData } 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 { useModule } from '@leafer/decorator'
+import { LeafDataProxy, LeafMatrix, LeafBounds, LeafEventer, LeafRender } from '@leafer/display-module'
+import { boundsType, useModule, defineDataProcessor } from '@leafer/decorator'
 import { LeafHelper, WaitHelper } from '@leafer/helper'
 
 
 const { LEAF, create } = IncrementId
+const { toInnerPoint, toOuterPoint, multiplyParent } = MatrixHelper
+const { toOuterOf } = BoundsHelper
+const { tempToOuterOf, copy } = PointHelper
+const { moveLocal, zoomOfLocal, rotateOfLocal, skewOfLocal, transform, setTransform, drop } = LeafHelper
 
 @useModule(LeafDataProxy)
 @useModule(LeafMatrix)
 @useModule(LeafBounds)
-@useModule(LeafHit)
 @useModule(LeafEventer)
 @useModule(LeafRender)
 export class Leaf implements ILeaf {
@@ -28,7 +31,7 @@ export class Leaf implements ILeaf {
     public get __DataProcessor() { return LeafData }
     public get __LayoutProcessor() { return LeafLayout }
 
-    public leafer?: ILeafer
+    public leafer?: ILeaferBase
     public parent?: ILeaf
 
     public isLeafer: boolean
@@ -38,8 +41,15 @@ export class Leaf implements ILeaf {
     public __: ILeafData
     public __layout: ILeafLayout
 
-    public __local: IMatrixWithBoundsData
-    public __world: IMatrixWithBoundsData
+    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 __localBoxBounds(): IBoundsData { return this.__local || this.__layout }
+
     public __worldOpacity: number
 
     // now transform
@@ -47,16 +57,21 @@ export class Leaf implements ILeaf {
     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') }
 
     // now opacity
-    public get worldOpacity(): number { this.__layout.checkUpdate(); return this.__worldOpacity }
+    public get worldOpacity(): number { this.__layout.update(); return this.__worldOpacity }
 
     public __level: number // layer level  0 -> branch -> branch -> deep
     public __tempNumber: number // temp sort
 
+    public get __worldFlipped(): boolean { return this.__world.scaleX < 0 || this.__world.scaleY < 0 }
+
+    public __hasAutoLayout?: boolean
     public __hasMask?: boolean
     public __hasEraser?: boolean
     public __hitCanvas?: IHitCanvas
@@ -74,19 +89,35 @@ export class Leaf implements ILeaf {
     // branch 
     public children?: ILeaf[]
 
-    constructor(data?: ILeafInputData) {
+    // other
+    public noBounds?: boolean
+
+    public destroyed: boolean
 
+
+    constructor(data?: ILeafInputData) {
         this.innerId = create(LEAF)
+        this.reset(data)
+    }
 
-        this.__local = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0, x: 0, y: 0, width: 0, height: 0 }
-        this.__world = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0, x: 0, y: 0, width: 0, height: 0 }
+
+    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 }
+        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
 
         this.__ = new this.__DataProcessor(this)
         this.__layout = new this.__LayoutProcessor(this)
 
-        if (data) Object.assign(this, data)
+        if (this.__level) this.resetCustom()
+        if (data) data.children ? this.set(data) : Object.assign(this, data)
+    }
+
+    public resetCustom(): void {
+        this.__hasMask = this.__hasEraser = null
+        this.forceUpdate()
     }
 
 
@@ -98,14 +129,24 @@ export class Leaf implements ILeaf {
         this.leafer ? item() : (this.__leaferWait ? this.__leaferWait.push(item) : this.__leaferWait = [item])
     }
 
+    public nextRender(item: IFunction, off?: 'off'): void {
+        this.leafer ? this.leafer.nextRender(item, off) : this.waitLeafer(() => this.leafer.nextRender(item, off))
+    }
+
+    public __bindLeafer(leafer: ILeaferBase | null): void {
+        if (this.isLeafer) {
+            if (leafer !== null) leafer = this as unknown as ILeaferBase
+        }
 
-    public __bindLeafer(leafer: ILeafer | null): void {
-        if (this.isLeafer) leafer = this as unknown as ILeafer
+        if (this.leafer && !leafer) this.leafer.leafs--
 
         this.leafer = leafer
-        this.__level = this.parent ? this.parent.__level + 1 : 1
 
-        if (this.__leaferWait && leafer) WaitHelper.run(this.__leaferWait)
+        if (leafer) {
+            leafer.leafs++
+            this.__level = this.parent ? this.parent.__level + 1 : 1
+            if (this.__leaferWait) WaitHelper.run(this.__leaferWait)
+        }
 
         if (this.isBranch) {
             const { children } = this
@@ -115,25 +156,52 @@ export class Leaf implements ILeaf {
         }
     }
 
+    // data
+
     public set(_data: IObject): void { }
+    public get(): ILeafInputData { return undefined }
 
-    public get(_attrNames?: string[]): IObject { return undefined }
+    public toJSON(): IObject {
+        return this.__.__getInputData()
+    }
 
+    public toString(): string {
+        return JSON.stringify(this.toJSON())
+    }
 
     // LeafDataProxy rewrite
 
-    public __setAttr(_attrName: string, _newValue: __Value): void { }
+    public __setAttr(_attrName: string, _newValue: IValue): void { }
+
+    public __getAttr(_attrName: string): IValue { return undefined }
 
-    public __getAttr(_attrName: string): __Value { return undefined }
+    public setProxyAttr(_attrName: string, _newValue: IValue): void { }
+
+    public getProxyAttr(_attrName: string): IValue { return undefined }
+
+    // ---
+
+
+    // find
+
+    public find(_condition: number | string | IFindMethod, _options?: any): ILeaf[] { return undefined }
+
+    public findOne(_condition: number | string | IFindMethod, _options?: any): ILeaf { return undefined }
 
     // ---
 
     public forceUpdate(attrName?: string): void {
-        if (!attrName) attrName = 'x'
+        if (attrName === undefined) attrName = 'width'
+        else if (attrName === 'surface') attrName = 'blendMode'
         const value = this.__.__getInput(attrName);
+        (this.__ as any)[attrName] = value === undefined ? null : undefined;
         (this as any)[attrName] = value
     }
 
+    public updateLayout(): void {
+        this.__layout.update()
+    }
+
 
     // LeafMatrix rewrite
 
@@ -147,6 +215,8 @@ export class Leaf implements ILeaf {
 
     public __updateWorldBounds(): void { }
 
+    public __updateLocalBounds(): void { }
+
 
     public __updateLocalBoxBounds(): void { }
 
@@ -163,6 +233,10 @@ export class Leaf implements ILeaf {
     public __updateRenderBounds(): void { }
 
 
+    public __updateAutoLayout(): void { }
+    public __updateNaturalSize(): void { }
+
+
     public __updateStrokeSpread(): number { return 0 }
 
     public __updateRenderSpread(): number { return 0 }
@@ -174,70 +248,163 @@ export class Leaf implements ILeaf {
 
     // LeafMask rewrite
 
-    public __updateEraser(_value?: boolean): void { }
+    public __updateEraser(value?: boolean): void {
+        this.__hasEraser = value ? true : this.children.some(item => item.__.eraser)
+    }
 
-    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): void { }
+    public __renderMask(_canvas: ILeaferCanvas, _options: IRenderOptions): void { }
 
-    public __removeMask(_child?: ILeaf): void { }
 
     // ---
 
 
     // convert
 
-    public getWorld(attrName: IMatrixDecompositionAttr): number {
-        return this.__layout.decomposeTransform('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 getBounds(type: ILayoutBoundsType, locationType: ILayoutLocationType = 'world'): IBoundsData {
-        return this.__layout.getBounds(type, locationType)
+
+    public getWorld(attrName: ILayoutAttr): number {
+        this.__layout.update()
+        if (attrName === 'x') return this.__world.e
+        if (attrName === 'y') return this.__world.f
+        return this.getLayoutBounds()[attrName]
     }
 
+    public getBounds(type?: IBoundsType, relative?: ILocationType | ILeaf): IBoundsData {
+        return this.__layout.getBounds(type, relative)
+    }
 
-    public worldToLocal(world: IPointData, to?: IPointData, isMovePoint?: boolean): void {
+    public getLayoutBounds(type?: IBoundsType, relative?: ILocationType | ILeaf, unscale?: boolean): ILayoutBoundsData {
+        return this.__layout.getLayoutBounds(type, relative, unscale)
+    }
+
+    public getLayoutPoints(type?: IBoundsType, relative?: ILocationType | ILeaf): IPointData[] {
+        return this.__layout.getLayoutPoints(type, relative)
+    }
+
+
+    public worldToLocal(world: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void {
         if (this.parent) {
-            MatrixHelper.toInnerPoint(this.parent.worldTransform, world, to, isMovePoint)
+            this.parent.worldToInner(world, to, distance, relative)
         } else {
-            if (to) PointHelper.copy(to, world)
+            if (to) copy(to, world)
         }
     }
 
-    public localToWorld(local: IPointData, to?: IPointData, isMovePoint?: boolean): void {
+    public localToWorld(local: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void {
         if (this.parent) {
-            MatrixHelper.toOuterPoint(this.parent.worldTransform, local, to, isMovePoint)
+            this.parent.innerToWorld(local, to, distance, relative)
         } else {
-            if (to) PointHelper.copy(to, local)
+            if (to) copy(to, local)
         }
     }
 
-    public worldToInner(world: IPointData, to?: IPointData, isMovePoint?: boolean): void {
-        MatrixHelper.toInnerPoint(this.worldTransform, world, to, isMovePoint)
+    public worldToInner(world: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void {
+        if (relative) {
+            relative.innerToWorld(world, to, distance)
+            world = to ? to : world
+        }
+        toInnerPoint(this.worldTransform, world, to, distance)
     }
 
-    public innerToWorld(inner: IPointData, to?: IPointData, isMovePoint?: boolean): void {
-        MatrixHelper.toOuterPoint(this.worldTransform, inner, to, isMovePoint)
+    public innerToWorld(inner: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void {
+        toOuterPoint(this.worldTransform, inner, to, distance)
+        if (relative) relative.worldToInner(to ? to : inner, null, distance)
+    }
+
+    // simple
+
+    public getInnerPoint(world: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData {
+        const point = change ? world : {} as IPointData
+        this.worldToInner(world, point, distance, relative)
+        return point
+    }
+
+    public getInnerPointByLocal(local: IPointData, _relative?: ILeaf, distance?: boolean, change?: boolean): IPointData {
+        return this.getInnerPoint(local, this.parent, distance, change)
+    }
+
+    public getLocalPoint(world: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData {
+        const point = change ? world : {} as IPointData
+        this.worldToLocal(world, point, distance, relative)
+        return point
+    }
+
+    public getLocalPointByInner(inner: IPointData, _relative?: ILeaf, distance?: boolean, change?: boolean): IPointData {
+        return this.getWorldPoint(inner, this.parent, distance, change)
+    }
+
+    public getWorldPoint(inner: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData {
+        const point = change ? inner : {} as IPointData
+        this.innerToWorld(inner, point, distance, relative)
+        return point
+    }
+
+    public getWorldPointByLocal(local: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData {
+        const point = change ? local : {} as IPointData
+        this.localToWorld(local, point, distance, relative)
+        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
 
+    public setTransform(matrix: IMatrixData, resize?: boolean): void {
+        setTransform(this, matrix, resize)
+    }
+
+    public transform(matrix: IMatrixData, resize?: boolean): void {
+        transform(this, matrix, resize)
+    }
+
     public move(x: number, y?: number): void {
-        LeafHelper.moveLocal(this, x, y)
+        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 rotateOf(origin: IPointData, rotation: number): void {
+        rotateOfLocal(this, tempToOuterOf(origin, this.localTransform), rotation)
     }
 
-    public scaleOf(origin: IPointData, x: number, y?: number): void {
-        this.__layout.checkUpdate()
-        if (y === undefined) y = x
-        LeafHelper.zoomOfLocal(this, PointHelper.tempToOuterOf(origin, this.__local), x, y)
+    public skewOf(origin: IPointData, skewX: number, skewY?: number, resize?: boolean): void {
+        skewOfLocal(this, tempToOuterOf(origin, this.localTransform), skewX, skewY, resize)
     }
 
-    public rotateOf(origin: IPointData, angle: number): void {
-        this.__layout.checkUpdate()
-        LeafHelper.rotateOfLocal(this, PointHelper.tempToOuterOf(origin, this.__local), angle)
+    // @leafer-in/scale 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 { }
 
     // LeafHit rewrite
 
@@ -245,7 +412,17 @@ export class Leaf implements ILeaf {
 
     public __hit(_local: IRadiusPointData): boolean { return true }
 
-    public __drawHitPath(_canvas: ILeaferCanvas): void { }
+    public __hitFill(inner: IRadiusPointData, windingRule?: string): boolean {
+        return this.__hitCanvas?.hitFill(inner, windingRule)
+    }
+
+    public __hitStroke(inner: IRadiusPointData, strokeWidth: number): boolean {
+        return this.__hitCanvas?.hitStroke(inner, strokeWidth)
+    }
+
+    public __drawHitPath(canvas: ILeaferCanvas): void {
+        if (canvas) this.__drawRenderPath(canvas)
+    }
 
     public __updateHitCanvas(): void { }
 
@@ -260,6 +437,9 @@ export class Leaf implements ILeaf {
 
     public __draw(_canvas: ILeaferCanvas, _options: IRenderOptions): void { }
 
+
+    public __clip(_canvas: ILeaferCanvas, _options: IRenderOptions): void { }
+
     public __renderShape(_canvas: ILeaferCanvas, _options: IRenderOptions): void { }
 
 
@@ -287,8 +467,12 @@ export class Leaf implements ILeaf {
 
     public add(_child: ILeaf, _index?: number): void { }
 
-    public remove(_child?: ILeaf): void {
-        if (this.parent) this.parent.remove(this)
+    public remove(_child?: ILeaf, destroy?: boolean): void {
+        if (this.parent) this.parent.remove(this, destroy)
+    }
+
+    public dropTo(parent: ILeaf, index?: number, resize?: boolean): void {
+        drop(this, parent, index, resize)
     }
 
     // ---
@@ -314,28 +498,26 @@ export class Leaf implements ILeaf {
 
     // ---
 
-    public destroy(): void {
-        if (this.__) {
-            if (this.__hitCanvas) {
-                this.__hitCanvas.destroy()
-                this.__hitCanvas = null
-            }
+    static changeAttr(attrName: string, defaultValue: IValue): void {
+        defineDataProcessor(this.prototype, attrName, defaultValue)
+    }
 
-            this.leafer = null
-            this.parent = null
+    static addAttr(attrName: string, defaultValue: IValue, fn?: IAttrDecorator): void {
+        if (!fn) fn = boundsType
+        fn(defaultValue)(this.prototype, attrName)
+    }
+
+
+    public destroy(): void {
+        if (!this.destroyed) {
+            if (this.parent) this.remove()
+            if (this.children) (this as unknown as IBranch).removeAll(true)
 
             this.__.destroy()
             this.__layout.destroy()
-            this.__ = null
-            this.__layout = null
 
-            this.__captureMap = null
-            this.__bubbleMap = null
-
-            if (this.children) {
-                this.children.forEach(child => { child.destroy() })
-                this.children.length = 0
-            }
+            this.__captureMap = this.__bubbleMap = this.__parentWait = this.__leaferWait = null
+            this.destroyed = true
         }
     }
 

package/types/index.d.ts

@@ -0,0 +1,165 @@
+import { ILeaf, InnerId, ILeaferBase, ILeafData, ILeafLayout, IMatrixWithBoundsScaleData, IMatrixWithBoundsData, IMatrixData, IBoundsData, IHitCanvas, IEventListenerMap, IFunction, ILeafInputData, IObject, IValue, IFindMethod, ILeaferCanvas, IRenderOptions, ILayoutAttr, IBoundsType, ILocationType, ILayoutBoundsData, IPointData, IRadiusPointData, IEventListener, IEventListenerOptions, IEventListenerId, IEvent, IAttrDecorator } from '@leafer/interface';
+import { LeafData } from '@leafer/data';
+import { LeafLayout } from '@leafer/layout';
+
+declare class Leaf implements ILeaf {
+    get tag(): string;
+    set tag(_value: string);
+    get __tag(): string;
+    readonly innerId: InnerId;
+    get innerName(): string;
+    get __DataProcessor(): typeof LeafData;
+    get __LayoutProcessor(): typeof LeafLayout;
+    leafer?: ILeaferBase;
+    parent?: ILeaf;
+    isLeafer: boolean;
+    isBranch: boolean;
+    isBranchLeaf: boolean;
+    __: ILeafData;
+    __layout: ILeafLayout;
+    __world: IMatrixWithBoundsScaleData;
+    __local?: IMatrixWithBoundsData;
+    __nowWorld?: IMatrixWithBoundsScaleData;
+    __cameraWorld?: IMatrixWithBoundsScaleData;
+    get __localMatrix(): IMatrixData;
+    get __localBoxBounds(): IBoundsData;
+    __worldOpacity: number;
+    get worldTransform(): IMatrixData;
+    get localTransform(): IMatrixData;
+    get boxBounds(): IBoundsData;
+    get renderBounds(): IBoundsData;
+    get worldBoxBounds(): IBoundsData;
+    get worldStrokeBounds(): IBoundsData;
+    get worldRenderBounds(): IBoundsData;
+    get worldOpacity(): number;
+    __level: number;
+    __tempNumber: number;
+    get __worldFlipped(): boolean;
+    __hasAutoLayout?: boolean;
+    __hasMask?: boolean;
+    __hasEraser?: boolean;
+    __hitCanvas?: IHitCanvas;
+    get __onlyHitMask(): boolean;
+    get __ignoreHitWorld(): boolean;
+    __captureMap?: IEventListenerMap;
+    __bubbleMap?: IEventListenerMap;
+    __parentWait?: IFunction[];
+    __leaferWait?: IFunction[];
+    children?: ILeaf[];
+    noBounds?: boolean;
+    destroyed: boolean;
+    constructor(data?: ILeafInputData);
+    reset(data?: ILeafInputData): void;
+    resetCustom(): void;
+    waitParent(item: IFunction): void;
+    waitLeafer(item: IFunction): void;
+    nextRender(item: IFunction, off?: 'off'): void;
+    __bindLeafer(leafer: ILeaferBase | null): void;
+    set(_data: IObject): void;
+    get(): ILeafInputData;
+    toJSON(): IObject;
+    toString(): string;
+    __setAttr(_attrName: string, _newValue: IValue): void;
+    __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;
+    updateLayout(): void;
+    __updateWorldMatrix(): void;
+    __updateLocalMatrix(): void;
+    __updateWorldBounds(): void;
+    __updateLocalBounds(): void;
+    __updateLocalBoxBounds(): void;
+    __updateLocalStrokeBounds(): void;
+    __updateLocalRenderBounds(): void;
+    __updateBoxBounds(): void;
+    __updateStrokeBounds(): void;
+    __updateRenderBounds(): void;
+    __updateAutoLayout(): void;
+    __updateNaturalSize(): void;
+    __updateStrokeSpread(): number;
+    __updateRenderSpread(): number;
+    __onUpdateSize(): void;
+    __updateEraser(value?: boolean): void;
+    __updateMask(value?: boolean): void;
+    __renderMask(_canvas: ILeaferCanvas, _options: IRenderOptions): void;
+    __getNowWorld(options: IRenderOptions): IMatrixWithBoundsScaleData;
+    getWorld(attrName: ILayoutAttr): number;
+    getBounds(type?: IBoundsType, relative?: ILocationType | ILeaf): IBoundsData;
+    getLayoutBounds(type?: IBoundsType, relative?: ILocationType | ILeaf, unscale?: boolean): ILayoutBoundsData;
+    getLayoutPoints(type?: IBoundsType, relative?: ILocationType | ILeaf): IPointData[];
+    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;
+    innerToWorld(inner: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void;
+    getInnerPoint(world: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
+    getInnerPointByLocal(local: IPointData, _relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
+    getLocalPoint(world: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
+    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;
+    __hitWorld(_point: IRadiusPointData): boolean;
+    __hit(_local: IRadiusPointData): boolean;
+    __hitFill(inner: IRadiusPointData, windingRule?: string): boolean;
+    __hitStroke(inner: IRadiusPointData, strokeWidth: number): 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;
+    __clip(_canvas: ILeaferCanvas, _options: IRenderOptions): void;
+    __renderShape(_canvas: ILeaferCanvas, _options: IRenderOptions): void;
+    __updateWorldOpacity(): void;
+    __updateChange(): void;
+    __drawPath(_canvas: ILeaferCanvas): void;
+    __drawRenderPath(_canvas: ILeaferCanvas): void;
+    __updatePath(): void;
+    __updateRenderPath(): void;
+    __updateSortChildren(): void;
+    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;
+    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 addAttr(attrName: string, defaultValue: IValue, fn?: IAttrDecorator): void;
+    destroy(): void;
+}
+
+declare class Branch extends Leaf {
+    constructor();
+    __updateStrokeSpread(): number;
+    __updateRenderSpread(): number;
+    __updateBoxBounds(): void;
+    __updateStrokeBounds(): void;
+    __updateRenderBounds(): void;
+    __updateSortChildren(): void;
+    add(child: ILeaf, index?: number): void;
+    addMany(...children: ILeaf[]): void;
+    remove(child?: Leaf, destroy?: boolean): void;
+    removeAll(destroy?: boolean): void;
+    clear(): void;
+    protected __preRemove(): void;
+    protected __realRemoveChild(child: ILeaf): void;
+    protected __emitChildEvent(type: string, child: ILeaf): void;
+}
+
+export { Branch, Leaf };