@leafer/event 1.6.2 → 1.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/event",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "description": "@leafer/event",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -22,11 +22,11 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/decorator": "1.6.2",
-    "@leafer/math": "1.6.2",
-    "@leafer/platform": "1.6.2"
+    "@leafer/decorator": "1.6.4",
+    "@leafer/math": "1.6.4",
+    "@leafer/platform": "1.6.4"
   },
   "devDependencies": {
-    "@leafer/interface": "1.6.2"
+    "@leafer/interface": "1.6.4"
   }
 }

package/src/BoundsEvent.ts

@@ -0,0 +1,48 @@
+import { IBoundsEvent, IEventTarget, ILeaf, IObject } from '@leafer/interface'
+
+import { Event } from './Event'
+
+
+export class BoundsEvent extends Event implements IBoundsEvent {
+
+    static RESIZE = 'bounds.resize'
+
+    static INNER = 'bounds.inner'
+
+    static LOCAL = 'bounds.local'
+
+    static WORLD = 'bounds.world'
+
+
+    static checkHas(leaf: IEventTarget, type: string, mode: 'on' | 'off') {
+        if (mode === 'on') {
+            type === WORLD ? leaf.__hasWorldEvent = true : leaf.__hasLocalEvent = true
+        } else {
+            leaf.__hasLocalEvent = leaf.hasEvent(RESIZE) || leaf.hasEvent(INNER) || leaf.hasEvent(LOCAL)
+            leaf.__hasWorldEvent = leaf.hasEvent(WORLD)
+        }
+    }
+
+    static emitLocal(leaf: ILeaf) {
+        if (leaf.leaferIsReady) {
+            const { resized } = leaf.__layout
+            if (resized !== 'local') {
+                leaf.emit(RESIZE, leaf)
+                if (resized === 'inner') leaf.emit(INNER, leaf)
+            }
+            leaf.emit(LOCAL, leaf)
+        }
+    }
+
+    static emitWorld(leaf: ILeaf) {
+        if (leaf.leaferIsReady) leaf.emit(WORLD, this)
+    }
+
+}
+
+const { RESIZE, INNER, LOCAL, WORLD } = BoundsEvent
+
+
+export const boundsEventMap: IObject = {};
+
+[RESIZE, INNER, LOCAL, WORLD].forEach(key => boundsEventMap[key] = 1)

package/src/Eventer.ts

@@ -1,9 +1,12 @@
-import { IEventListener, IEventListenerMap, IEventListenerItem, IEventListenerId, IEvent, IObject, IEventTarget, IEventOption, IEventer, IEventMap, InnerId } from '@leafer/interface'
+import { IEventListener, IEventListenerMap, IEventListenerItem, IEventListenerId, IEvent, IObject, IEventTarget, IEventOption, IEventer, IEventParamsMap, InnerId, IEventParams, IFunction } from '@leafer/interface'
 import { EventCreator } from '@leafer/platform'
 
+import { BoundsEvent, boundsEventMap } from './BoundsEvent'
+
 
 const empty = {}
 
+
 export class Eventer implements IEventer {
 
     public readonly innerId: InnerId
@@ -12,16 +15,20 @@ export class Eventer implements IEventer {
 
     public __bubbleMap?: IEventListenerMap
 
+    public __hasLocalEvent?: boolean
+    public __hasWorldEvent?: boolean
+
     public syncEventer?: IEventer
 
-    public set event(map: IEventMap) { this.on(map) }
+    public set event(map: IEventParamsMap) { this.on(map) }
 
 
-    public on(type: string | string[] | IEventMap, listener?: IEventListener, options?: IEventOption): void {
+    public on(type: string | string[] | IEventParams[] | IEventParamsMap, listener?: IEventListener, options?: IEventOption): void {
 
         if (!listener) {
-            let event, map = type as IEventMap
-            for (let key in map) event = map[key], event instanceof Array ? this.on(key, event[0], event[1]) : this.on(key, event)
+            let event: IFunction | [IFunction, IEventOption]
+            if (type instanceof Array) (type as IEventParams[]).forEach(item => this.on(item[0], item[1], item[2]))
+            else for (let key in type as IEventParamsMap) (event = (type as IEventParamsMap)[key]) instanceof Array ? this.on(key, event[0], event[1]) : this.on(key, event)
             return
         }
 
@@ -50,6 +57,8 @@ export class Eventer implements IEventer {
                 } else {
                     map[type] = [item]
                 }
+
+                if (boundsEventMap[type]) BoundsEvent.checkHas(this, type, 'on')
             }
         })
     }
@@ -74,6 +83,7 @@ export class Eventer implements IEventer {
                             index = events.findIndex(item => item.listener === listener)
                             if (index > -1) events.splice(index, 1)
                             if (!events.length) delete map[type]
+                            if (boundsEventMap[type]) BoundsEvent.checkHas(this, type, 'off')
                         }
                     }
                 })
@@ -97,20 +107,26 @@ export class Eventer implements IEventer {
 
     }
 
-    public on_(type: string | string[], listener: IEventListener, bind?: IObject, options?: IEventOption): IEventListenerId {
-        if (bind) listener = listener.bind(bind)
-        this.on(type, listener, options)
+    public on_(type: string | string[] | IEventParams[], listener?: IEventListener, bind?: IObject, options?: IEventOption): IEventListenerId {
+        if (!listener) (type instanceof Array) && (type as IEventParams[]).forEach(item => this.on(item[0], item[2] ? item[1] = item[1].bind(item[2]) : item[1], item[3]))
+        else this.on(type, bind ? listener = listener.bind(bind) : listener, options)
         return { type, current: this as any, listener, options }
     }
 
     public off_(id: IEventListenerId | IEventListenerId[]): void {
         if (!id) return
         const list = id instanceof Array ? id : [id]
-        list.forEach(item => item.current.off(item.type, item.listener, item.options))
+        list.forEach(item => {
+            if (!item.listener) (item.type instanceof Array) && (item.type as IEventParams[]).forEach(v => item.current.off(v[0], v[1], v[3]))
+            else item.current.off(item.type as string | string[], item.listener, item.options)
+        })
         list.length = 0
     }
 
-    public once(type: string | string[], listener: IEventListener, capture?: boolean): void {
+    public once(type: string | string[] | IEventParams[], listener?: IEventListener, captureOrBind?: boolean | IObject, capture?: boolean): void {
+        if (!listener) return (type instanceof Array) && (type as IEventParams[]).forEach(item => this.once(item[0], item[1], item[2], item[3]))
+        if (typeof captureOrBind === 'object') listener = listener.bind(captureOrBind)
+        else capture = captureOrBind
         this.on(type, listener, { once: true, capture })
     }
 

package/src/index.ts

@@ -1,6 +1,7 @@
 export { ChildEvent } from './ChildEvent'
 export { PropertyEvent } from './PropertyEvent'
 export { ImageEvent } from './ImageEvent'
+export { BoundsEvent } from './BoundsEvent'
 export { ResizeEvent } from './ResizeEvent'
 export { WatchEvent } from './WatchEvent'
 export { LayoutEvent } from './LayoutEvent'

package/types/index.d.ts

@@ -1,4 +1,4 @@
-import { IEvent, IObject, IEventTarget, IChildEvent, ILeaf, IPropertyEvent, IImageEvent, ILeaferImage, IResizeEvent, INumberMap, IScreenSizeData, IWatchEvent, IWatchEventData, ILayoutEvent, ILayoutBlockData, IRenderEvent, IBounds, IRenderOptions, ILeaferEvent, IEventer, InnerId, IEventListenerMap, IEventMap, IEventListener, IEventOption, IEventListenerId } from '@leafer/interface';
+import { IEvent, IObject, IEventTarget, IChildEvent, ILeaf, IPropertyEvent, IImageEvent, ILeaferImage, IBoundsEvent, IResizeEvent, INumberMap, IScreenSizeData, IWatchEvent, IWatchEventData, ILayoutEvent, ILayoutBlockData, IRenderEvent, IBounds, IRenderOptions, ILeaferEvent, IEventer, InnerId, IEventListenerMap, IEventParamsMap, IEventParams, IEventListener, IEventOption, IEventListenerId } from '@leafer/interface';
 
 declare class Event implements IEvent {
     readonly origin: IObject;
@@ -48,6 +48,16 @@ declare class ImageEvent extends Event implements IImageEvent {
     constructor(type: string, data: IImageEvent);
 }
 
+declare class BoundsEvent extends Event implements IBoundsEvent {
+    static RESIZE: string;
+    static INNER: string;
+    static LOCAL: string;
+    static WORLD: string;
+    static checkHas(leaf: IEventTarget, type: string, mode: 'on' | 'off'): void;
+    static emitLocal(leaf: ILeaf): void;
+    static emitWorld(leaf: ILeaf): void;
+}
+
 declare class ResizeEvent extends Event implements IResizeEvent {
     static RESIZE: string;
     static resizingKeys: INumberMap;
@@ -115,17 +125,19 @@ declare class Eventer implements IEventer {
     readonly innerId: InnerId;
     __captureMap?: IEventListenerMap;
     __bubbleMap?: IEventListenerMap;
+    __hasLocalEvent?: boolean;
+    __hasWorldEvent?: boolean;
     syncEventer?: IEventer;
-    set event(map: IEventMap);
-    on(type: string | string[] | IEventMap, listener?: IEventListener, options?: IEventOption): void;
+    set event(map: IEventParamsMap);
+    on(type: string | string[] | IEventParams[] | IEventParamsMap, 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;
+    on_(type: string | string[] | IEventParams[], listener?: IEventListener, bind?: IObject, options?: IEventOption): IEventListenerId;
     off_(id: IEventListenerId | IEventListenerId[]): void;
-    once(type: string | string[], listener: IEventListener, capture?: boolean): void;
+    once(type: string | string[] | IEventParams[], listener?: IEventListener, captureOrBind?: boolean | IObject, capture?: boolean): void;
     emit(type: string, event?: IEvent | IObject, capture?: boolean): void;
     emitEvent(event: IEvent, capture?: boolean): void;
     hasEvent(type: string, capture?: boolean): boolean;
     destroy(): void;
 }
 
-export { ChildEvent, Event, Eventer, ImageEvent, LayoutEvent, LeaferEvent, PropertyEvent, RenderEvent, ResizeEvent, WatchEvent };
+export { BoundsEvent, ChildEvent, Event, Eventer, ImageEvent, LayoutEvent, LeaferEvent, PropertyEvent, RenderEvent, ResizeEvent, WatchEvent };