add Event class

Author: Steffan

README.md

@@ -37,13 +37,13 @@ new Vue({
   events: {
 
     // event handler (priority 0)
-    someEvent(param) { ... },
+    someEvent(event, param) { ... },
 
     // event handler (priority 10)
     earlyEvent: {
 
         // handler callback
-        handler(param) { ... },
+        handler(event, param) { ... },
 
         // a higher priority, means earlier execution
         priority: 10
@@ -54,7 +54,7 @@ new Vue({
     lateEvent: {
 
         // handler callback
-        handler(param) { ... },
+        handler(event, param) { ... },
 
         // a lower priority, means late execution
         priority: -10

build/build.js

@@ -32,7 +32,7 @@ rollup.rollup({
   bundle.generate({
       format: 'es',
       banner: banner
-  }).then(({code}) => write('dist/vue-event-manager.es2015.js', code, bundle))
+  }).then(({code}) => write('dist/vue-event-manager.esm.js', code, bundle))
 )
 .then(bundle =>
   bundle.generate({

package.json

@@ -2,7 +2,7 @@
   "name": "vue-event-manager",
   "version": "1.0.6",
   "main": "dist/vue-event-manager.common.js",
-  "module": "dist/vue-event-manager.es2015.js",
+  "module": "dist/vue-event-manager.esm.js",
   "unpkg": "dist/vue-event-manager.min.js",
   "jsdelivr": "dist/vue-event-manager.min.js",
   "description": "The event manager for Vue.js",
@@ -24,24 +24,25 @@
     "karma": "karma start test/karma.conf.js --single-run",
     "build": "node ./build/build.js",
     "release": "node ./build/release.js",
+    "webpack": "webpack",
     "eslint": "eslint .",
     "eslint-fix": "eslint . --fix"
   },
   "devDependencies": {
-    "buble": "^0.18.0",
+    "buble": "^0.19.3",
     "buble-loader": "^0.4.1",
     "eslint": "^4.13.1",
-    "jasmine": "^2.8.0",
-    "jasmine-core": "^2.8.0",
+    "jasmine": "^3.1.0",
+    "jasmine-core": "^3.1.0",
     "karma": "^2.0.0",
     "karma-chrome-launcher": "^2.2.0",
     "karma-firefox-launcher": "^1.1.0",
     "karma-jasmine": "^1.1.1",
     "karma-safari-launcher": "^1.0.0",
     "karma-webpack": "^2.0.9",
     "replace-in-file": "^3.1.0",
-    "rollup": "^0.55.3",
-    "rollup-plugin-buble": "^0.18.0",
+    "rollup": "^0.57.0",
+    "rollup-plugin-buble": "^0.19.2",
     "uglify-js": "^3.3.9",
     "vue": "^2.5.13",
     "webpack": "^3.10.0"

src/EventManager.js

@@ -2,7 +2,7 @@
  * Event manager class.
  */
 
-import {isArray} from './util';
+import {isArray, isUndefined} from './util';
 
 export default class EventManager {
 
@@ -44,34 +44,60 @@ export default class EventManager {
         }
     }
 
-    trigger(event, params = [], asynch = false) {
+    trigger(event, params, asynch = false) {
 
-        if (!isArray(params)) {
-            params = [params];
-        }
+        const $event = new Event(event, params);
+        const reject = result => Promise.reject(result);
+        const resolve = result => !isUndefined(result) ? result : $event.result;
+        const reducer = (result, {callback}) => {
 
-        return ((this.listeners[event] || []).concat()).reduce((result, listener) => {
+            const next = result => {
 
-            const callback = result => {
+                if (!isUndefined(result)) {
+                    $event.result = result;
+                }
 
                 if (result === false) {
-                    return result;
+                    $event.stopPropagation();
                 }
 
-                if (isArray(result)) {
-                    params = result;
+                if ($event.isPropagationStopped()) {
+                    return $event.result;
                 }
 
-                return listener.callback.apply(listener.callback, params);
+                return callback.apply(callback, [$event].concat($event.params));
             };
 
-            if (asynch) {
-                return result.then(callback);
-            }
+            return asynch ? result.then(next, reject) : next(result);
+        };
+
+        const listeners = (this.listeners[event] || []).concat();
+        const result = listeners.reduce(reducer, asynch ? Promise.resolve() : undefined);
+
+        return asynch ? result.then(resolve, reject) : resolve(result);
+    }
+
+}
 
-            return callback(result);
+export class Event {
+
+    constructor(name, params = []) {
+
+        if (!isArray(params)) {
+            params = [params];
+        }
+
+        this.name = name;
+        this.params = params;
+        this.result = undefined;
+    }
+
+    stopPropagation() {
+        this.stop = true;
+    }
 
-        }, asynch ? Promise.resolve() : undefined);
+    isPropagationStopped() {
+        return this.stop === true;
     }
 
 }

src/util.js

@@ -8,6 +8,10 @@ export function isObject(obj) {
     return obj !== null && typeof obj === 'object';
 }
 
+export function isUndefined(obj) {
+    return typeof obj === 'undefined';
+}
+
 export function forEach(collection, callback) {
     Object.keys(collection || {}).forEach(key => {
         callback.call(null, collection[key], key);

test/event.js

@@ -8,8 +8,9 @@ describe('Vue.events', () => {
         this.$trigger('someEvent', 'foo');
       },
       events: {
-        someEvent(param) {
+        someEvent(event, param) {
           expect(param).toBe('foo');
+          expect(event.name).toBe('someEvent');
         }
       }
     });
@@ -21,7 +22,7 @@ describe('Vue.events', () => {
         this.$trigger('paramArray', ['foo', 'bar']);
       },
       events: {
-        paramArray(param, param2) {
+        paramArray(event, param, param2) {
           expect(param).toBe('foo');
           expect(param2).toBe('bar');
         }
@@ -35,7 +36,7 @@ describe('Vue.events', () => {
         this.$trigger('paramObject', { foo : 'bar' });
       },
       events: {
-        paramObject(param) {
+        paramObject(event, param) {
           expect(param.foo).toBe('bar');
         }
       }
@@ -54,15 +55,15 @@ describe('Vue.events', () => {
         prioHandler: [
           {
             // handler callback
-            handler(param) {
+            handler(event, param) {
               this.lastPrio = 10;
             },
             // a higher priority, means earlier execution
             priority: 10
           },
           {
             // handler callback
-            handler(param) {
+            handler(event, param) {
               expect(this.lastPrio).toBe(10);
               this.lastPrio = -10;
             },
@@ -85,7 +86,7 @@ describe('Vue.events', () => {
         }
       },
       events: {
-        testEvent(param) {
+        testEvent(event, param) {
           this.isLoaded = true;
           expect(this.isLoaded).toBe(true);
         }
@@ -95,7 +96,7 @@ describe('Vue.events', () => {
     var vm2 = new Vue({
       events: {
         testEvent:{
-          handler(param) {
+          handler(event, param) {
            expect(param).toBe('foo');
           },
           priority: 10
@@ -114,7 +115,7 @@ describe('Vue.events', () => {
         }
       },
       events: {
-        actionCancel(param) {
+        actionCancel(event, param) {
           this.isLoaded = true;
           return "lastAction";
         }
@@ -124,7 +125,7 @@ describe('Vue.events', () => {
     var vm2 = new Vue({
       events: {
         actionCancel:{
-          handler(param) {
+          handler(event, param) {
            expect(param).toBe('foo');
            return false;
           },

test/eventAsync.js

@@ -17,7 +17,7 @@ describe('Vue.events Async', () => {
           this.isRun = true;
           expect(this.isRun).toBe(true);
         },
-        sendParam(param) {
+        sendParam(event, param) {
           expect(this.isRun).toBe(false);
         }
       }
@@ -33,7 +33,7 @@ describe('Vue.events Async', () => {
         }
       },
       events: {
-        testEvent(param) {
+        testEvent(event, param) {
           this.isLoaded = true;
           expect(this.isLoaded).toBe(true);
           done();
@@ -44,7 +44,7 @@ describe('Vue.events Async', () => {
     var vm2 = new Vue({
       events: {
         testEvent:{
-          handler(param) {
+          handler(event, param) {
            expect(param).toBe('foo');
            return new Promise((resolve) => {
             setTimeout(resolve, 300);