@leafer/display 1.0.0-rc.3 → 1.0.0-rc.30

package/package.json

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

package/src/Branch.ts

@@ -3,25 +3,18 @@ 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() {
-        super()
-        this.isBranch = true
-        this.children = []
-    }
+export class Branch extends Leaf { // tip: rewrited Group
 
     // overwrite
 
@@ -42,15 +35,15 @@ 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)
     }
 
 
@@ -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.positionChange() // 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 { 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, IBranch, IMatrixWithLayoutData } 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, IMatrixData, IAttrDecorator, IMatrixWithBoundsScaleData, IMatrixWithScaleData, IAlign, IJSONOptions } 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'
+import { ChildEvent } from '@leafer/event'
 
 
 const { LEAF, create } = IncrementId
-const { toInnerPoint, toOuterPoint } = MatrixHelper
-const { tempToOuterOf, copy } = PointHelper
-const { moveLocal, zoomOfLocal, rotateOfLocal, skewOfLocal } = LeafHelper
+const { toInnerPoint, toOuterPoint, multiplyParent } = MatrixHelper
+const { toOuterOf } = BoundsHelper
+const { copy } = PointHelper
+const { moveLocal, zoomOfLocal, rotateOfLocal, skewOfLocal, moveWorld, zoomOfWorld, rotateOfWorld, skewOfWorld, transform, transformWorld, setTransform, getLocalOrigin, getRelativeWorld, drop } = LeafHelper
 
 @useModule(LeafDataProxy)
 @useModule(LeafMatrix)
 @useModule(LeafBounds)
-@useModule(LeafHit)
 @useModule(LeafEventer)
 @useModule(LeafRender)
 export class Leaf implements ILeaf {
@@ -31,47 +32,56 @@ 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
-    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 __local: 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
-    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') }
 
     // 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 resizeable(): boolean { return true }
-
-    public get __hasMirror(): boolean { return this.__world.scaleX < 0 || this.__world.scaleY < 0 }
+    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
 
     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 __captureMap?: IEventListenerMap
@@ -83,52 +93,70 @@ export class Leaf implements ILeaf {
     // branch 
     public children?: ILeaf[]
 
+    // other
+    public noBounds?: boolean
 
     public destroyed: boolean
 
 
     constructor(data?: ILeafInputData) {
-
         this.innerId = create(LEAF)
+        this.reset(data)
+    }
 
-        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.__local = { 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 (this.__level) this.resetCustom()
         if (data) {
-            if (data.children) {
-                this.set(data)
-            } else {
-                Object.assign(this, data)
-            }
+            if ((data as ILeaf).__) data = (data as ILeaf).toJSON()
+            data.children ? this.set(data) : Object.assign(this, data)
         }
     }
 
+    public resetCustom(): void {
+        this.__hasMask = this.__hasEraser = null
+        this.forceUpdate()
+    }
+
 
-    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: ILeafer | null): void {
+    public __bindLeafer(leafer: ILeaferBase | null): void {
         if (this.isLeafer) {
-            if (leafer !== null) leafer = this as unknown as ILeafer
+            if (leafer !== null) leafer = this as unknown as ILeaferBase
         }
 
+        if (this.leafer && !leafer) this.leafer.leafs--
+
         this.leafer = leafer
 
         if (leafer) {
+            leafer.leafs++
             this.__level = this.parent ? this.parent.__level + 1 : 1
             if (this.__leaferWait) WaitHelper.run(this.__leaferWait)
         }
@@ -144,31 +172,75 @@ export class Leaf implements ILeaf {
     // data
 
     public set(_data: IObject): void { }
+    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: __Value): void { }
+    public __setAttr(_attrName: string, _newValue: IValue): boolean { return true }
+
+    public __getAttr(_attrName: string): IValue { 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 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 }
 
-    public __getAttr(_attrName: string): __Value { return undefined }
+    // ---
+
+
+    // state
+
+    public focus(_value?: boolean): void { }
 
     // ---
 
+    public updateLayout(): void {
+        this.__layout.update()
+    }
+
     public forceUpdate(attrName?: string): void {
-        if (attrName === undefined) attrName = 'scaleX'
+        if (attrName === undefined) attrName = 'width'
         else if (attrName === 'surface') attrName = 'blendMode'
-        const value = this.__.__getInput(attrName)
-        this.__[attrName] = value === undefined ? null : undefined;
+        const value = this.__.__getInput(attrName);
+        (this.__ as any)[attrName] = value === undefined ? null : undefined;
         (this as any)[attrName] = value
     }
 
+    public forceRender(_bounds?: IBoundsData): void {
+        this.forceUpdate('surface')
+    }
 
     // LeafMatrix rewrite
 
@@ -182,6 +254,8 @@ export class Leaf implements ILeaf {
 
     public __updateWorldBounds(): void { }
 
+    public __updateLocalBounds(): void { }
+
 
     public __updateLocalBoxBounds(): void { }
 
@@ -193,11 +267,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 { }
 
 
@@ -210,30 +290,67 @@ export class Leaf implements ILeaf {
     // ---
 
 
-    // LeafMask rewrite
+    public __updateEraser(value?: boolean): void {
+        this.__hasEraser = value ? true : this.children.some(item => item.__.eraser)
+    }
+
+    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 __updateEraser(_value?: boolean): void { }
+    public __updateMask(value?: boolean): void {
+        this.__hasMask = value ? true : this.children.some(item => item.__.mask)
+    }
 
-    public __updateMask(_value?: boolean): void { }
+    // LeafMask rewrite
 
-    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 {
-        this.__layout.checkUpdate()
-        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)
     }
 
-    public getBounds(type: ILayoutBoundsType, locationType: ILayoutLocationType = 'world'): IBoundsData {
-        return this.__layout.getBounds(type, locationType)
+    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 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
     }
 
 
@@ -300,32 +417,91 @@ 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 
+
+    public setTransform(matrix: IMatrixData, resize?: boolean): void {
+        setTransform(this, matrix, resize)
+    }
 
-    // transform
+    public transform(matrix: IMatrixData, resize?: boolean): void {
+        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, x: number, y?: number): void {
-        zoomOfLocal(this, tempToOuterOf(origin, this.localTransform), x, y)
+    public scaleOf(origin: IPointData | IAlign, scaleX: number, scaleY?: number, resize?: boolean): void {
+        zoomOfLocal(this, getLocalOrigin(this, origin), scaleX, scaleY, resize)
+    }
+
+    public rotateOf(origin: IPointData | IAlign, rotation: number): void {
+        rotateOfLocal(this, getLocalOrigin(this, origin), rotation)
+    }
+
+    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 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 rotateOfWorld(worldOrigin: IPointData, rotation: number): void {
+        rotateOfWorld(this, worldOrigin, rotation)
     }
 
-    public rotateOf(origin: IPointData, angle: number): void {
-        rotateOfLocal(this, tempToOuterOf(origin, this.localTransform), angle)
+    public skewOfWorld(worldOrigin: IPointData, skewX: number, skewY?: number, resize?: boolean): void {
+        skewOfWorld(this, worldOrigin, skewX, skewY, resize)
     }
 
-    public skewOf(origin: IPointData, x: number, y: number): void {
-        skewOfLocal(this, tempToOuterOf(origin, this.localTransform), x, y)
+
+    // @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 { }
 
-    // LeafHit rewrite
+
+    // @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 { }
@@ -341,7 +517,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 { }
@@ -372,6 +551,10 @@ export class Leaf implements ILeaf {
         if (this.parent) this.parent.remove(this, destroy)
     }
 
+    public dropTo(parent: ILeaf, index?: number, resize?: boolean): void {
+        drop(this, parent, index, resize)
+    }
+
     // ---
 
 
@@ -379,7 +562,7 @@ export class Leaf implements ILeaf {
 
     public on(_type: string | string[], _listener: IEventListener, _options?: IEventListenerOptions | boolean): void { }
 
-    public off(_type: string | string[], _listener: IEventListener, _options?: IEventListenerOptions | boolean): void { }
+    public off(_type?: string | string[], _listener?: IEventListener, _options?: IEventListenerOptions | boolean): void { }
 
     public on_(_type: string | string[], _listener: IEventListener, _bind?: IObject, _options?: IEventListenerOptions | boolean): IEventListenerId { return undefined }
 
@@ -395,11 +578,22 @@ export class Leaf implements ILeaf {
 
     // ---
 
+    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 {
+        if (!fn) fn = boundsType
+        fn(defaultValue)(this.prototype, attrName)
+    }
+
 
     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, ILeafer, ILeafData, ILeafLayout, IMatrixWithLayoutData, IMatrixWithBoundsData, IBoundsData, IHitCanvas, IEventListenerMap, IFunction, ILeafInputData, IObject, __Value, ILeaferCanvas, IMatrixDecompositionAttr, ILayoutBoundsType, ILayoutLocationType, IPointData, IRadiusPointData, IRenderOptions, IEventListener, IEventListenerOptions, IEventListenerId, IEvent } from '@leafer/interface';
+import { ILeaf, InnerId, ILeaferBase, ILeafData, ILeafLayout, IMatrixWithBoundsScaleData, IMatrixWithBoundsData, IMatrixData, IBoundsData, IMatrixWithScaleData, IHitCanvas, IEventListenerMap, IFunction, ILeafInputData, IObject, IValue, IJSONOptions, IFindMethod, ILeaferCanvas, IRenderOptions, ILocationType, IBoundsType, ILayoutBoundsData, IPointData, IAlign, IRadiusPointData, IEventListener, IEventListenerOptions, IEventListenerId, IEvent, IAttrDecorator } from '@leafer/interface';
 import { LeafData } from '@leafer/data';
 import { LeafLayout } from '@leafer/layout';
 
@@ -10,68 +10,103 @@ declare class Leaf implements ILeaf {
     get innerName(): string;
     get __DataProcessor(): typeof LeafData;
     get __LayoutProcessor(): typeof LeafLayout;
-    leafer?: ILeafer;
+    leafer?: ILeaferBase;
     parent?: ILeaf;
-    isLeafer: boolean;
-    isBranch: boolean;
-    isBranchLeaf: boolean;
+    get isLeafer(): boolean;
+    get isBranch(): boolean;
+    get isBranchLeaf(): boolean;
     __: ILeafData;
     __layout: ILeafLayout;
-    __world: IMatrixWithLayoutData;
-    __local: IMatrixWithBoundsData;
+    __world: IMatrixWithBoundsScaleData;
+    __local?: IMatrixWithBoundsData;
+    __nowWorld?: IMatrixWithBoundsScaleData;
+    __cameraWorld?: IMatrixWithBoundsScaleData;
+    get __localMatrix(): IMatrixData;
+    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;
     get worldOpacity(): number;
     __level: number;
     __tempNumber: number;
-    get resizeable(): boolean;
-    get __hasMirror(): boolean;
+    get __worldFlipped(): boolean;
+    __hasAutoLayout?: boolean;
     __hasMask?: boolean;
     __hasEraser?: boolean;
     __hitCanvas?: IHitCanvas;
     get __onlyHitMask(): boolean;
     get __ignoreHitWorld(): boolean;
+    get __inLazyBounds(): boolean;
+    get pathInputed(): boolean;
     __captureMap?: IEventListenerMap;
     __bubbleMap?: IEventListenerMap;
     __parentWait?: IFunction[];
     __leaferWait?: IFunction[];
     children?: ILeaf[];
+    noBounds?: boolean;
     destroyed: boolean;
     constructor(data?: ILeafInputData);
-    waitParent(item: IFunction): void;
-    waitLeafer(item: IFunction): void;
-    nextRender(item: IFunction): void;
-    __bindLeafer(leafer: ILeafer | null): void;
+    reset(data?: ILeafInputData): void;
+    resetCustom(): 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;
-    toJSON(): IObject;
-    toString(): string;
-    __setAttr(_attrName: string, _newValue: __Value): void;
-    __getAttr(_attrName: string): __Value;
+    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[];
+    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;
+    __updateLocalBounds(): void;
     __updateLocalBoxBounds(): void;
     __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): void;
-    __removeMask(_child?: ILeaf): void;
-    getWorld(attrName: IMatrixDecompositionAttr): number;
-    getBounds(type: ILayoutBoundsType, locationType?: ILayoutLocationType): IBoundsData;
+    __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;
@@ -82,18 +117,35 @@ 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;
-    move(x: number, y?: number): void;
-    scaleOf(origin: IPointData, x: number, y?: number): void;
-    rotateOf(origin: IPointData, angle: number): void;
-    skewOf(origin: IPointData, x: number, y: number): void;
+    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 | 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;
+    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;
@@ -103,19 +155,21 @@ declare class Leaf implements ILeaf {
     __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;
+    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, 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;
@@ -124,8 +178,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;