@lijuhong1981/jsevents 1.0.0

package/index.js

@@ -0,0 +1,9 @@
+import Event from "./src/Event";
+import EventDispatcher from "./src/EventDispatcher";
+import EventEmitter from "./src/EventEmitter";
+
+export {
+    Event,
+    EventDispatcher,
+    EventEmitter,
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@lijuhong1981/jsevents",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "module": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lijuhong1981/jsevents.git"
+  },
+  "author": "lijuhong1981",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/lijuhong1981/jsevents/issues"
+  },
+  "homepage": "https://github.com/lijuhong1981/jsevents#readme",
+  "dependencies": {
+    "@lijuhong1981/jscheck": "^1.0.2",
+    "@lijuhong1981/jsdestroy": "^1.0.1"
+  }
+}

package/src/Event.js

@@ -0,0 +1,118 @@
+import Check from "@lijuhong1981/jscheck";
+import { Destroyable } from "@lijuhong1981/jsdestroy";
+
+class Event extends Destroyable {
+    constructor() {
+        super();
+        this._listeners = [];
+    }
+
+    /**
+     * 事件监听器数量
+     * @returns {Number}
+     */
+    get numberOfListeners() {
+        return this._listeners.length;
+    }
+
+    /**
+     * 判断事件监听器是否已存在
+     * @param {Function} callback 事件监听回调函数
+     * @returns {Boolean}
+     */
+    hasEventListener(callback) {
+        for (let i = 0, length = this._listeners.length; i < length; i++) {
+            if (this._listeners[i].callback === callback) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * 添加事件监听
+     * @param {Function} callback 回调函数
+     * @param {Object} options 事件配置项，如once等，可不填
+     * @returns {Function} 移除函数，调用该函数可直接移除事件监听
+     */
+    addEventListener(callback, options) {
+        Check.typeOf.func('callback', callback);
+
+        let listener;
+        for (let i = 0, length = this._listeners.length; i < length; i++) {
+            if (this._listeners[i].callback === callback) {
+                listener = this._listeners[i];
+                break;
+            }
+        }
+
+        if (!listener) {
+            listener = {
+                callback: callback,
+                options: options,
+                removeFunc: () => {
+                    this.removeEventListener(callback);
+                }
+            };
+            this._listeners.push(listener);
+        }
+
+        return listener.removeFunc;
+    }
+
+    /**
+     * 移除事件监听
+     * @param {Function} callback 回调函数
+     * @returns {this}
+     */
+    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);
+                break;
+            }
+        }
+
+        return this;
+    }
+
+    /**
+     * 清除所有事件监听
+     * @returns {this}
+     */
+    clear() {
+        this._listeners.length = 0;
+        return this;
+    }
+
+    /**
+     * 发送事件
+     * @param {...any} ...args 事件参数 
+     * @returns {this}
+     */
+    raiseEvent(...args) {
+        const listeners = this._listeners.slice();
+        listeners.forEach(listener => {
+            listener.callback(...args);
+            if (listener.options.once) {
+                const index = this._listeners.indexOf(listener);
+                this._listeners.splice(index, 1);
+            }
+        });
+
+        return this;
+    }
+
+    /**
+     * 销毁
+     * @returns {this}
+     */
+    destroy() {
+        this.clear();
+        return super.destroy();
+    }
+};
+
+export default Event;

package/src/EventDispatcher.js

@@ -0,0 +1,176 @@
+import Check, { isArray, isFunction, isString, isValid } from "@lijuhong1981/jscheck";
+const { Destroyable } = require("@lijuhong1981/jsdestroy");
+
+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,
+        });
+    }
+}
+
+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);
+        } else {
+            listeners.length = 0;
+            listenersMap.delete(type);
+        }
+    }
+}
+
+/**
+ * 事件分发管理器
+*/
+class EventDispatcher extends Destroyable {
+    constructor() {
+        super();
+        this._listenersMap = new Map();
+    }
+
+    /**
+     * 添加事件监听
+     * @param {String|Object} type 事件类型
+     * @param {Function} callback 回调函数
+     * @param {Object} options 事件配置项，如once等，可不填
+     * @returns {this}
+     */
+    addEventListener(type, callback, options) {
+        Check.isValid('type', type);
+        Check.typeOf.func('callback', callback);
+
+        if (isString(type) && type.match(/\s+/)) {
+            type = type.split(/\s+/);
+        }
+
+        if (isArray(type)) {
+            type.forEach(element => {
+                addListener(this._listenersMap, element, callback, options);
+            });
+        } else
+            addListener(this._listenersMap, type, callback, options);
+
+        return this;
+    }
+
+    /**
+     * 移除事件监听
+     * @param {String|Object} type 事件类型
+     * @param {Function} callback 回调函数，不填时可移除type下所有的事件监听
+     * @returns {this}
+     */
+    removeEventListener(type, callback) {
+        Check.isValid('type', type);
+
+        if (isString(type) && type.match(/\s+/)) {
+            type = type.split(/\s+/);
+        }
+
+        if (isArray(type)) {
+            type.forEach(element => {
+                removeListener(this._listenersMap, element, callback);
+            });
+        } else
+            removeListener(this._listenersMap, type, callback);
+
+        return this;
+    }
+
+    /**
+     * 清除所有事件监听
+     * @returns {this}
+     */
+    clear() {
+        this._listenersMap.forEach(function (listeners, type) {
+            listeners.length = 0;
+        });
+        this._listenersMap.clear();
+
+        return this;
+    }
+
+    /**
+     * 发送事件参数
+     * @param {String|Object} type 事件类型
+     * @param {...any} ...args 事件参数 
+     * @returns {this}
+     */
+    dispatch(type, ...args) {
+        Check.isValid('type', type);
+
+        const listeners = this._listenersMap.get(type);
+        if (listeners && listeners.length > 0) {
+            const _listeners = listeners.slice();
+            _listeners.forEach(listener => {
+                listener.callback(type, ...args);
+                if (listener.options.once) {
+                    const index = listeners.indexOf(listener);
+                    listeners.splice(index, 1);
+                }
+            });
+        }
+
+        return this;
+    }
+
+    /**
+     * 发送事件对象
+     * @param {Object} event 事件对象
+     * @param {Object} owner 事件对象所有者，可不填
+     * @returns {this}
+     */
+    dispatchEvent(event, owner) {
+        Check.typeOf.object('event', event);
+        Check.isValid('event.type', event.type);
+
+        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(event);
+                if (listener.options.once) {
+                    const index = listeners.indexOf(listener);
+                    listeners.splice(index, 1);
+                }
+            });
+        }
+
+        return this;
+    }
+
+    /**
+     * 销毁
+     * @returns {this}
+     */
+    destroy() {
+        this.clear();
+        return super.destroy();
+    }
+};
+
+export default EventDispatcher;

package/src/EventEmitter.js

@@ -0,0 +1,86 @@
+import { Destroyable } from "@lijuhong1981/jsdestroy";
+import EventDispatcher from "./EventDispatcher";
+
+class EventEmitter extends Destroyable {
+    constructor() {
+        super();
+        this._dispatcher = new EventDispatcher();
+    }
+
+    /**
+     * 添加事件监听
+     * @param {String|Object} type 事件类型
+     * @param {Function} callback 回调函数
+     * @returns {this}
+     */
+    on(type, callback) {
+        this._dispatcher.addEventListener(type, callback);
+        return this;
+    }
+
+    /**
+     * 添加单次事件监听
+     * @param {String|Object} type 事件类型
+     * @param {Function} callback 事件回调函数
+     * @returns {this}
+     */
+    once(type, callback) {
+        this._dispatcher.addEventListener(type, callback, {
+            once: true
+        });
+        return this;
+    }
+
+    /**
+     * 移除事件监听
+     * @param {String|Object} type 事件类型
+     * @param {Function} callback 回调函数，不填时可移除type下所有的事件监听
+     * @returns {this}
+     */
+    off(type, callback) {
+        this._dispatcher.removeEventListener(type, callback);
+        return this;
+    }
+
+    /**
+     * 清除所有事件监听
+     * @returns {this}
+     */
+    clear() {
+        this._dispatcher.clear();
+        return this;
+    }
+
+    /**
+     * 发送事件参数
+     * @param {String|Object} type 事件类型
+     * @param {...any} ...args 事件参数 
+     * @returns {this}
+     */
+    emit(type, ...args) {
+        this._dispatcher.dispatch(type, ...args);
+        return this;
+    }
+
+    /**
+     * 发送事件对象
+     * @param {Object} event 事件对象
+     * @param {Object} owner 事件对象所有者，可不填
+     * @returns {this}
+     */
+    emitEvent(event) {
+        this._dispatcher.dispatchEvent(event);
+        return this;
+    }
+
+    /**
+     * 销毁
+     * @returns {this}
+     */
+    destroy() {
+        this._dispatcher.destroy();
+        return super.destroy();
+    }
+};
+
+export default EventEmitter;