@lijuhong1981/jsevents 1.1.4 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lijuhong1981/jsevents",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "> TODO: description",
   "author": "lijuhong1981",
   "homepage": "https://github.com/lijuhong1981/jslibs#readme",
@@ -22,5 +22,5 @@
     "@lijuhong1981/jscheck": "^1.0.9",
     "@lijuhong1981/jsdestroy": "^1.1.9"
   },
-  "gitHead": "77fdf1be2d46386741683dfd08eeb27625c5a139"
+  "gitHead": "d20df0ba5bb330d43c7828f8a97b41ca3860a570"
 }

package/src/EventDispatcher.js

@@ -1,46 +1,41 @@
 import Check from "@lijuhong1981/jscheck/src/Check.js";
 import isArray from "@lijuhong1981/jscheck/src/isArray.js";
-import isFunction from "@lijuhong1981/jscheck/src/isFunction.js";
 import isString from "@lijuhong1981/jscheck/src/isString.js";
 import Destroyable from "@lijuhong1981/jsdestroy/src/Destroyable.js";
+import Event from "./EventSubscriber.js";
 
-function indexOfListener(listeners, callback) {
-    for (let i = 0; i < listeners.length; i++) {
-        if (listeners[i].callback === callback)
-            return i;
-    }
-    return -1;
-}
-
-function hasListener(listeners, callback) {
-    return indexOfListener(listeners, callback) !== -1;
-}
-
-function addListener(listenersMap, type, callback, options = {}) {
-    let listeners = listenersMap.get(type);
-    if (!listeners) {
-        listeners = [];
-        listenersMap.set(type, listeners);
-    }
-    if (!hasListener(listeners, callback)) {
-        listeners.push({
-            type: type,
-            callback: callback,
-            options: options,
-        });
+/**
+ * Description
+ * @param {Map<any, Event>} events
+ * @param {any} type
+ * @param {Function} callback
+ * @param {object} options 
+ * @returns {void}
+ */
+function addListener(events, type, callback, options) {
+    let event = events.get(type);
+    if (!event) {
+        event = new Event();
+        events.set(type, event);
     }
+    event.addEventListener(callback, options);
 }
 
-function removeListener(listenersMap, type, callback) {
-    const listeners = listenersMap.get(type);
-    if (listeners) {
-        if (isFunction(callback)) {
-            const index = indexOfListener(listeners, callback);
-            if (index !== -1)
-                listeners.splice(index, 1);
+/**
+ * Description
+ * @param {Map<any, Event>} events
+ * @param {any} type
+ * @param {Function} callback
+ * @returns {void}
+ */
+function removeListener(events, type, callback) {
+    const event = events.get(type);
+    if (event) {
+        if (callback) {
+            event.removeEventListener(callback);
         } else {
-            listeners.length = 0;
-            listenersMap.delete(type);
+            event.destroy();
+            events.delete(type);
         }
     }
 }
@@ -51,16 +46,19 @@ function removeListener(listenersMap, type, callback) {
 class EventDispatcher extends Destroyable {
     constructor() {
         super();
-        this._listenersMap = new Map();
+        /**
+         * @type {Map<any, Event>}
+        */
+        this._events = new Map();
     }
 
     /**
      * 添加事件监听
-     * @param {String|Object} type 事件类型
+     * @param {any} type 事件类型
      * @param {Function} callback 回调函数
-     * @param {Object} options 事件配置项，可不填
-     * @param {Object} options.scope 回调函数<code>this</code>指针对象，可不填
-     * @param {Boolean} options.once 是否单次事件，可不填
+     * @param {object} options 事件配置项，可不填
+     * @param {object} options.scope 回调函数<code>this</code>指针对象，可不填
+     * @param {boolean} options.once 是否单次事件，可不填
      * @returns {this}
      */
     addEventListener(type, callback, options) {
@@ -73,17 +71,17 @@ class EventDispatcher extends Destroyable {
 
         if (isArray(type)) {
             type.forEach(element => {
-                addListener(this._listenersMap, element, callback, options);
+                addListener(this._events, element, callback, options);
             });
         } else
-            addListener(this._listenersMap, type, callback, options);
+            addListener(this._events, type, callback, options);
 
         return this;
     }
 
     /**
      * 移除事件监听
-     * @param {String|Object} type 事件类型
+     * @param {any} type 事件类型
      * @param {Function} callback 回调函数，不填时可移除type下所有的事件监听
      * @returns {this}
      */
@@ -96,38 +94,46 @@ class EventDispatcher extends Destroyable {
 
         if (isArray(type)) {
             type.forEach(element => {
-                removeListener(this._listenersMap, element, callback);
+                removeListener(this._events, element, callback);
             });
         } else
-            removeListener(this._listenersMap, type, callback);
+            removeListener(this._events, type, callback);
 
         return this;
     }
 
+    /**
+     * 注册的事件数量
+     * @returns {number}
+     */
+    get numberOfEvents() {
+        return this._events.size;
+    }
+
     /**
      * 获取某类型事件监听器数量
-     * @param {String|Object} type 事件类型
-     * @returns {Number} 监听器数量
+     * @param {any} type 事件类型
+     * @returns {number} 监听器数量
      */
-    getEventListenersCount(type) {
+    numberOfListeners(type) {
         Check.valid('type', type);
 
-        const listeners = this._listenersMap.get(type);
+        const event = this._events.get(type);
 
-        return listeners ? listeners.length : 0;
+        return event ? event.numberOfListeners : 0;
     }
 
     /**
      * 判断是否已添加某类型的事件监听器
-     * @param {String|Object} type 事件类型
-     * @returns {Boolean} 判断结果
+     * @param {string|object} type 事件类型
+     * @returns {boolean} 判断结果
      */
     hasEventListener(type) {
         Check.valid('type', type);
 
-        const listeners = this._listenersMap.get(type);
+        const event = this._events.get(type);
 
-        return listeners && listeners.length > 0;
+        return event && event.numberOfListeners > 0;
     }
 
     /**
@@ -135,33 +141,28 @@ class EventDispatcher extends Destroyable {
      * @returns {this}
      */
     clear() {
-        this._listenersMap.forEach(function (listeners, type) {
-            listeners.length = 0;
+        this._events.forEach(function (event, type) {
+            event.destroy();
         });
-        this._listenersMap.clear();
+        this._events.clear();
 
         return this;
     }
 
     /**
      * 发送事件参数
-     * @param {String|Object} type 事件类型
+     * @param {string|object} type 事件类型
      * @param {...any} ...args 事件参数 
      * @returns {this}
      */
     dispatch(type, ...args) {
         Check.valid('type', type);
 
-        const listeners = this._listenersMap.get(type);
-        if (listeners && listeners.length > 0) {
-            const _listeners = listeners.slice();
-            _listeners.forEach(listener => {
-                listener.callback.call(listener.options.scope, type, ...args);
-                if (listener.options.once) {
-                    const index = listeners.indexOf(listener);
-                    listeners.splice(index, 1);
-                }
-            });
+        const event = this._events.get(type);
+        if (event)
+            event.raiseEvent(type, ...args);
+        else {
+            console.warn('Not found the ' + type + ' type`s event.');
         }
 
         return this;
@@ -169,8 +170,8 @@ class EventDispatcher extends Destroyable {
 
     /**
      * 发送事件对象
-     * @param {Object} event 事件对象
-     * @param {Object} owner 事件对象所有者，可不填
+     * @param {object} event 事件对象
+     * @param {object} owner 事件对象所有者，可不填
      * @returns {this}
      */
     dispatchEvent(event, owner) {
@@ -179,16 +180,11 @@ class EventDispatcher extends Destroyable {
 
         event.owner = event.owner || owner || this;
 
-        const listeners = this._listenersMap.get(event.type);
-        if (listeners && listeners.length > 0) {
-            const _listeners = listeners.slice();
-            _listeners.forEach(listener => {
-                listener.callback.call(listener.options.scope, event);
-                if (listener.options.once) {
-                    const index = listeners.indexOf(listener);
-                    listeners.splice(index, 1);
-                }
-            });
+        const event = this._events.get(event.type);
+        if (event)
+            event.raiseEvent(event);
+        else {
+            console.warn('Not found the ' + type + ' type`s event.');
         }
 
         return this;

package/src/EventEmitter.js

@@ -9,31 +9,36 @@ class EventEmitter extends Destroyable {
 
     /**
      * 添加事件监听
-     * @param {String|Object} type 事件类型
+     * @param {any} type 事件类型
      * @param {Function} callback 回调函数
+     * @param {object} options 事件配置项，可不填
+     * @param {object} options.scope 回调函数<code>this</code>指针对象，可不填
+     * @param {boolean} options.once 是否单次事件，可不填
      * @returns {this}
      */
-    on(type, callback) {
-        this._dispatcher.addEventListener(type, callback);
+    on(type, callback, options) {
+        this._dispatcher.addEventListener(type, callback, options);
         return this;
     }
 
     /**
      * 添加单次事件监听
-     * @param {String|Object} type 事件类型
-     * @param {Function} callback 事件回调函数
+     * @param {any} type 事件类型
+     * @param {Function} callback 回调函数
+     * @param {object} scope 回调函数<code>this</code>指针对象，可不填
      * @returns {this}
      */
-    once(type, callback) {
+    once(type, callback, scope) {
         this._dispatcher.addEventListener(type, callback, {
-            once: true
+            once: true,
+            scope: scope,
         });
         return this;
     }
 
     /**
      * 移除事件监听
-     * @param {String|Object} type 事件类型
+     * @param {any} type 事件类型
      * @param {Function} callback 回调函数，不填时可移除type下所有的事件监听
      * @returns {this}
      */
@@ -44,20 +49,28 @@ class EventEmitter extends Destroyable {
 
     /**
      * 判断是否已添加某类型的事件监听
-     * @param {String|Object} type 事件类型
-     * @returns {Boolean} 判断结果
+     * @param {any} type 事件类型
+     * @returns {boolean} 判断结果
      */
     hasListener(type) {
         return this._dispatcher.hasEventListener(type);
     }
 
+    /**
+     * 注册的事件数量
+     * @returns {number}
+     */
+    get numberOfEvents() {
+        return this._dispatcher.numberOfEvents;
+    }
+
     /**
      * 获取某类型事件监听器数量
-     * @param {String|Object} type 事件类型
-     * @returns {Number} 监听器数量
+     * @param {any} type 事件类型
+     * @returns {number} 监听器数量
      */
-    listenersCount(type) {
-        return this._dispatcher.getEventListenersCount(type);
+    numberOfListeners(type) {
+        return this._dispatcher.numberOfListeners(type);
     }
 
     /**
@@ -71,7 +84,7 @@ class EventEmitter extends Destroyable {
 
     /**
      * 发送事件参数
-     * @param {String|Object} type 事件类型
+     * @param {any} type 事件类型
      * @param {...any} ...args 事件参数 
      * @returns {this}
      */
@@ -82,8 +95,8 @@ class EventEmitter extends Destroyable {
 
     /**
      * 发送事件对象
-     * @param {Object} event 事件对象
-     * @param {Object} owner 事件对象所有者，可不填
+     * @param {object} event 事件对象
+     * @param {object} owner 事件对象所有者，可不填
      * @returns {this}
      */
     emitEvent(event, owner) {

package/src/EventSubscriber.js

@@ -7,7 +7,6 @@ import Destroyable from "@lijuhong1981/jsdestroy/src/Destroyable.js";
 class EventSubscriber extends Destroyable {
     constructor() {
         super();
-        this._listeners = [];
         this._listenersMap = new Map();
     }
 
@@ -16,13 +15,13 @@ class EventSubscriber extends Destroyable {
      * @returns {Number}
      */
     get numberOfListeners() {
-        return this._listeners.length;
+        return this._listenersMap.size;
     }
 
     /**
      * 判断事件监听器是否已存在
      * @param {Function} callback 事件监听回调函数
-     * @returns {Boolean}
+     * @returns {boolean}
      */
     hasEventListener(callback) {
         return this._listenersMap.has(callback);
@@ -31,9 +30,9 @@ class EventSubscriber extends Destroyable {
     /**
      * 添加事件监听
      * @param {Function} callback 回调函数
-     * @param {Object} options 事件配置项，可不填
-     * @param {Object} options.scope 回调函数<code>this</code>指针对象，可不填
-     * @param {Boolean} options.once 是否单次事件，可不填
+     * @param {object} options 事件配置项，可不填
+     * @param {object} options.scope 回调函数<code>this</code>指针对象，可不填
+     * @param {boolean} options.once 是否单次事件，可不填
      * @returns {Function} 移除函数，调用该函数可直接移除事件监听
      */
     addEventListener(callback, options = {}) {
@@ -49,7 +48,6 @@ class EventSubscriber extends Destroyable {
                     this.removeEventListener(callback);
                 }
             };
-            this._listeners.push(listener);
             this._listenersMap.set(callback, listener);
         } else {
             listener.options = options;
@@ -61,20 +59,41 @@ class EventSubscriber extends Destroyable {
     /**
      * 移除事件监听
      * @param {Function} callback 回调函数
-     * @returns {this}
+     * @returns {boolean}
      */
     removeEventListener(callback) {
         Check.typeOf.func('callback', callback);
 
-        for (let i = 0, length = this._listeners.length; i < length; i++) {
-            if (this._listeners[i].callback === callback) {
-                this._listeners.splice(i, 1);
-                this._listenersMap.delete(callback);
-                break;
-            }
-        }
+        return this._listenersMap.delete(callback);
+    }
 
-        return this;
+    /**
+     * @see addEventListener
+    */
+    on(callback, options) {
+        return this.addEventListener(callback, options);
+    }
+
+    /**
+     * @see removeEventListener
+    */
+    off(callback) {
+        return this.removeEventListener(callback);
+    }
+
+    /**
+     * 添加一次事件监听
+     * @param {Function} callback 回调函数
+     * @param {object} scope 回调函数<code>this</code>指针对象，可不填
+     * @returns {Function} 移除函数，调用该函数可直接移除事件监听
+     * 
+     * @see addEventListener
+     */
+    once(callback, scope) {
+        return this.addEventListener(callback, {
+            once: true,
+            scope: scope,
+        });
     }
 
     /**
@@ -82,7 +101,6 @@ class EventSubscriber extends Destroyable {
      * @returns {this}
      */
     clear() {
-        this._listeners.length = 0;
         this._listenersMap.clear();
         return this;
     }
@@ -93,14 +111,15 @@ class EventSubscriber extends Destroyable {
      * @returns {this}
      */
     raiseEvent(...args) {
-        const listeners = this._listeners.slice();
-        listeners.forEach(listener => {
-            listener.callback.call(listener.options.scope, ...args);
-            if (listener.options.once) {
-                const index = this._listeners.indexOf(listener);
-                this._listeners.splice(index, 1);
+        const listeners = this._listenersMap.values();
+        for (const listener of listeners) {
+            const options = listener.options;
+            const callback = listener.callback;
+            callback.apply(options.scope, arguments);
+            if (options.once) {
+                this._listenersMap.delete(callback);
             }
-        });
+        }
 
         return this;
     }