@leafer/display 1.0.2 → 1.0.4

package/package.json

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

package/src/Branch.ts

@@ -1,7 +1,7 @@
 import { ILeaf } from '@leafer/interface'
 import { ChildEvent } from '@leafer/event'
 import { BoundsHelper } from '@leafer/math'
-import { BranchHelper, LeafBoundsHelper, WaitHelper } from '@leafer/helper'
+import { BranchHelper, LeafBoundsHelper } from '@leafer/helper'
 import { useModule } from '@leafer/decorator'
 import { BranchRender } from '@leafer/display-module'
 
@@ -74,7 +74,7 @@ export class Branch extends Leaf { // tip: rewrited Group
         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)
+        if (child.__bubbleMap) child.__emitLifeEvent(ChildEvent.ADD)
 
         if (this.leafer) {
             child.__bindLeafer(this.leafer)
@@ -90,14 +90,10 @@ export class Branch extends Leaf { // tip: rewrited Group
 
     public remove(child?: ILeaf, destroy?: boolean): void {
         if (child) {
-            const index = this.children.indexOf(child)
-            if (index > -1) {
-                this.children.splice(index, 1)
-                if (child.isBranch) this.__.__childBranchNumber = (this.__.__childBranchNumber || 1) - 1
-                this.__preRemove()
-                this.__realRemoveChild(child)
-                if (destroy) child.destroy()
-            }
+
+            if ((child as ILeaf).animationOut) child.__runAnimation('out', () => this.__remove(child, destroy))
+            else this.__remove(child, destroy)
+
         } else if (child === undefined) {
             super.remove(null, destroy)
         }
@@ -120,6 +116,17 @@ export class Branch extends Leaf { // tip: rewrited Group
         this.removeAll(true)
     }
 
+    protected __remove(child?: ILeaf, destroy?: boolean): void {
+        const index = this.children.indexOf(child)
+        if (index > -1) {
+            this.children.splice(index, 1)
+            if (child.isBranch) this.__.__childBranchNumber = (this.__.__childBranchNumber || 1) - 1
+            this.__preRemove()
+            this.__realRemoveChild(child)
+            if (destroy) child.destroy()
+        }
+    }
+
     protected __preRemove(): void {
         if (this.__hasMask) this.__updateMask()
         if (this.__hasEraser) this.__updateEraser()
@@ -128,6 +135,7 @@ export class Branch extends Leaf { // tip: rewrited Group
     }
 
     protected __realRemoveChild(child: ILeaf): void {
+        child.__emitLifeEvent(ChildEvent.REMOVE)
         child.parent = null
         if (this.leafer) {
             child.__bindLeafer(null)
@@ -140,7 +148,6 @@ export class Branch extends Leaf { // tip: rewrited Group
 
     protected __emitChildEvent(type: string, child: ILeaf): void {
         const event = new ChildEvent(type, child, this)
-        if (child.hasEvent(type)) child.emitEvent(event)
         if (this.hasEvent(type) && !this.isLeafer) this.emitEvent(event)
         this.leafer.emitEvent(event)
     }

package/src/Leaf.ts

@@ -1,17 +1,18 @@
-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 { 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, IMotionPathData, IUnitData, IRotationPointData } 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, LeafEventer, LeafRender } from '@leafer/display-module'
 import { boundsType, useModule, defineDataProcessor } from '@leafer/decorator'
-import { LeafHelper, WaitHelper } from '@leafer/helper'
+import { LeafHelper } from '@leafer/helper'
 import { ChildEvent } from '@leafer/event'
+import { needPlugin } from '@leafer/debug'
 
 
 const { LEAF, create } = IncrementId
 const { toInnerPoint, toOuterPoint, multiplyParent } = MatrixHelper
 const { toOuterOf } = BoundsHelper
-const { copy } = PointHelper
+const { copy, move } = PointHelper
 const { moveLocal, zoomOfLocal, rotateOfLocal, skewOfLocal, moveWorld, zoomOfWorld, rotateOfWorld, skewOfWorld, transform, transformWorld, setTransform, getFlipTransform, getLocalOrigin, getRelativeWorld, drop } = LeafHelper
 
 @useModule(LeafDataProxy)
@@ -39,6 +40,9 @@ export class Leaf implements ILeaf {
     public get isBranch(): boolean { return false }
     public get isBranchLeaf(): boolean { return false }
 
+    public syncEventer?: ILeaf // 同步触发一样事件的元素
+    public lockNormalStyle?: boolean
+
     public __: ILeafData
     public __layout: ILeafLayout
 
@@ -84,14 +88,11 @@ export class Leaf implements ILeaf {
     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 set event(map: IEventMap) { this.on(map) }
 
     public __captureMap?: IEventListenerMap
     public __bubbleMap?: IEventListenerMap
 
-    public __parentWait?: IFunction[]
-    public __leaferWait?: IFunction[]
-
     // branch 
     public children?: ILeaf[]
 
@@ -104,10 +105,12 @@ export class Leaf implements ILeaf {
     constructor(data?: ILeafInputData) {
         this.innerId = create(LEAF)
         this.reset(data)
+        if (this.__bubbleMap) this.__emitLifeEvent(ChildEvent.CREATED)
     }
 
 
     public reset(data?: ILeafInputData): void {
+        if (this.leafer) this.leafer.forceRender(this.__world) // fix: add old bounds rendering
 
         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 }
@@ -132,12 +135,12 @@ export class Leaf implements ILeaf {
 
     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])
+        this.parent ? item() : this.on(ChildEvent.ADD, item, 'once')
     }
 
     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])
+        this.leafer ? item() : this.on(ChildEvent.MOUNTED, item, 'once')
     }
 
     public nextRender(item: IFunction, bind?: IObject, off?: 'off'): void {
@@ -149,9 +152,7 @@ export class Leaf implements ILeaf {
     }
 
     public __bindLeafer(leafer: ILeaferBase | null): void {
-        if (this.isLeafer) {
-            if (leafer !== null) leafer = this as unknown as ILeaferBase
-        }
+        if (this.isLeafer && leafer !== null) leafer = this as unknown as ILeaferBase
 
         if (this.leafer && !leafer) this.leafer.leafs--
 
@@ -160,7 +161,10 @@ export class Leaf implements ILeaf {
         if (leafer) {
             leafer.leafs++
             this.__level = this.parent ? this.parent.__level + 1 : 1
-            if (this.__leaferWait) WaitHelper.run(this.__leaferWait)
+            if ((this as ILeaf).animation) this.__runAnimation('in')
+            if (this.__bubbleMap) this.__emitLifeEvent(ChildEvent.MOUNTED)
+        } else {
+            this.__emitLifeEvent(ChildEvent.UNMOUNTED)
         }
 
         if (this.isBranch) {
@@ -173,7 +177,7 @@ export class Leaf implements ILeaf {
 
     // data
 
-    public set(_data: IObject): void { }
+    public set(_data: IObject, _isTemp?: boolean): void { }
     public get(_name?: string): ILeafInputData | IValue { return undefined }
 
     public setAttr(name: string, value: any): void { (this as IObject)[name] = value }
@@ -222,12 +226,15 @@ export class Leaf implements ILeaf {
     // ---
 
 
-    // state
+    // @leafer-in/state rewrite
 
     public focus(_value?: boolean): void { }
 
+    public updateState(): void { }
+
     // ---
 
+
     public updateLayout(): void {
         this.__layout.update()
     }
@@ -387,12 +394,28 @@ export class Leaf implements ILeaf {
 
     // simple
 
+    public getBoxPoint(world: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData {
+        return this.getBoxPointByInner(this.getInnerPoint(world, relative, distance, change), null, null, true)
+    }
+
+    public getBoxPointByInner(inner: IPointData, _relative?: ILeaf, _distance?: boolean, change?: boolean): IPointData {
+        const point = change ? inner : { ...inner } as IPointData, { x, y } = this.boxBounds
+        move(point, -x, -y)
+        return point
+    }
+
     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 getInnerPointByBox(box: IPointData, _relative?: ILeaf, _distance?: boolean, change?: boolean): IPointData {
+        const point = change ? box : { ...box } as IPointData, { x, y } = this.boxBounds
+        move(point, x, y)
+        return point
+    }
+
     public getInnerPointByLocal(local: IPointData, _relative?: ILeaf, distance?: boolean, change?: boolean): IPointData {
         return this.getInnerPoint(local, this.parent, distance, change)
     }
@@ -407,23 +430,27 @@ export class Leaf implements ILeaf {
         return this.getWorldPoint(inner, this.parent, distance, change)
     }
 
+    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 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 getWorldPointByBox(box: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData {
+        return this.getWorldPoint(this.getInnerPointByBox(box, null, null, change), relative, distance, true)
+    }
+
     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)
@@ -552,6 +579,31 @@ export class Leaf implements ILeaf {
 
     public __updateRenderPath(): void { }
 
+    // ---
+
+
+    // @leafer-in/motion-path rewrite
+
+    public getMotionPathData(): IMotionPathData {
+        return needPlugin('path')
+    }
+
+    public getMotionPoint(_motionDistance: number | IUnitData): IRotationPointData {
+        return needPlugin('path')
+    }
+
+    public getMotionTotal(): number {
+        return 0
+    }
+
+    public __updateMotionPath(): void { }
+
+    // ---
+
+
+    // @leafer-in/animate rewrite
+    public __runAnimation(_type: 'in' | 'out', _complete?: IFunction): void { }
+
 
     // Branch rewrite
 
@@ -572,7 +624,7 @@ export class Leaf implements ILeaf {
 
     // LeafEventer rewrite
 
-    public on(_type: string | string[], _listener: IEventListener, _options?: IEventOption): void { }
+    public on(_type: string | string[] | IEventMap, _listener?: IEventListener, _options?: IEventOption): void { }
 
     public off(_type?: string | string[], _listener?: IEventListener, _options?: IEventOption): void { }
 
@@ -600,17 +652,22 @@ export class Leaf implements ILeaf {
     }
 
 
+    public __emitLifeEvent(type: string): void {
+        if (this.hasEvent(type)) this.emitEvent(new ChildEvent(type, this, this.parent))
+    }
+
+
     public destroy(): void {
         if (!this.destroyed) {
             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.__emitLifeEvent(ChildEvent.DESTROY)
 
             this.__.destroy()
-            this.__layout.destroy()
+            this.__layout.destroy();
 
-            this.__captureMap = this.__bubbleMap = this.__parentWait = this.__leaferWait = null
+            (this as ILeaf).destroyEventer()
             this.destroyed = true
         }
     }

package/types/index.d.ts

@@ -1,4 +1,4 @@
-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 { ILeaf, InnerId, ILeaferBase, ILeafData, ILeafLayout, IMatrixWithBoundsScaleData, IMatrixWithBoundsData, IMatrixData, IBoundsData, IMatrixWithScaleData, IHitCanvas, IEventMap, IEventListenerMap, ILeafInputData, IFunction, IObject, IValue, IJSONOptions, IFindMethod, ILeaferCanvas, IRenderOptions, ILocationType, IBoundsType, ILayoutBoundsData, IPointData, IAlign, IAxis, IRadiusPointData, IMotionPathData, IUnitData, IRotationPointData, IEventListener, IEventOption, IEventListenerId, IEvent, IAttrDecorator } from '@leafer/interface';
 import { LeafData } from '@leafer/data';
 import { LeafLayout } from '@leafer/layout';
 
@@ -15,6 +15,8 @@ declare class Leaf implements ILeaf {
     get isLeafer(): boolean;
     get isBranch(): boolean;
     get isBranchLeaf(): boolean;
+    syncEventer?: ILeaf;
+    lockNormalStyle?: boolean;
     __: ILeafData;
     __layout: ILeafLayout;
     __world: IMatrixWithBoundsScaleData;
@@ -46,8 +48,6 @@ declare class Leaf implements ILeaf {
     set event(map: IEventMap);
     __captureMap?: IEventListenerMap;
     __bubbleMap?: IEventListenerMap;
-    __parentWait?: IFunction[];
-    __leaferWait?: IFunction[];
     children?: ILeaf[];
     noBounds?: boolean;
     destroyed: boolean;
@@ -59,7 +59,7 @@ declare class Leaf implements ILeaf {
     nextRender(item: IFunction, bind?: IObject, off?: 'off'): void;
     removeNextRender(item: IFunction): void;
     __bindLeafer(leafer: ILeaferBase | null): void;
-    set(_data: IObject): void;
+    set(_data: IObject, _isTemp?: boolean): void;
     get(_name?: string): ILeafInputData | IValue;
     setAttr(name: string, value: any): void;
     getAttr(name: string): any;
@@ -78,6 +78,7 @@ declare class Leaf implements ILeaf {
     findOne(_condition: number | string | IFindMethod, _options?: any): ILeaf | undefined;
     findId(_id: number | string): ILeaf | undefined;
     focus(_value?: boolean): void;
+    updateState(): void;
     updateLayout(): void;
     forceUpdate(attrName?: string): void;
     forceRender(_bounds?: IBoundsData): void;
@@ -112,13 +113,17 @@ declare class Leaf implements ILeaf {
     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;
+    getBoxPoint(world: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
+    getBoxPointByInner(inner: IPointData, _relative?: ILeaf, _distance?: boolean, change?: boolean): IPointData;
     getInnerPoint(world: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
+    getInnerPointByBox(box: 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;
+    getPagePoint(world: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
     getWorldPoint(inner: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
+    getWorldPointByBox(box: 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;
@@ -155,11 +160,16 @@ declare class Leaf implements ILeaf {
     __drawRenderPath(_canvas: ILeaferCanvas): void;
     __updatePath(): void;
     __updateRenderPath(): void;
+    getMotionPathData(): IMotionPathData;
+    getMotionPoint(_motionDistance: number | IUnitData): IRotationPointData;
+    getMotionTotal(): number;
+    __updateMotionPath(): void;
+    __runAnimation(_type: 'in' | 'out', _complete?: IFunction): 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?: IEventOption): void;
+    on(_type: string | string[] | IEventMap, _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;
@@ -169,6 +179,7 @@ declare class Leaf implements ILeaf {
     hasEvent(_type: string, _capture?: boolean): boolean;
     static changeAttr(attrName: string, defaultValue: IValue, fn?: IAttrDecorator): void;
     static addAttr(attrName: string, defaultValue: IValue, fn?: IAttrDecorator): void;
+    __emitLifeEvent(type: string): void;
     destroy(): void;
 }
 
@@ -184,6 +195,7 @@ declare class Branch extends Leaf {
     remove(child?: ILeaf, destroy?: boolean): void;
     removeAll(destroy?: boolean): void;
     clear(): void;
+    protected __remove(child?: ILeaf, destroy?: boolean): void;
     protected __preRemove(): void;
     protected __realRemoveChild(child: ILeaf): void;
     protected __emitChildEvent(type: string, child: ILeaf): void;