.npmignore

@@ -0,0 +1,3 @@
+test/
+.gitignore
+.travis.yml

.travis.yml

@@ -1,8 +1,8 @@
 language: node_js
 node_js:
-- "8"
 - "10"
 - "12"
+- "14"
 matrix:
   fast_finish: true
 script: "npm run test-cov"

README.md

@@ -94,6 +94,7 @@ Most of the implementation is fully compatible with the standard `EventEmitter`.
 * [EventEmitter.listenerCount(emitter, eventName)](https://nodejs.org/api/events.html#events_eventemitter_listenercount_emitter_eventname) *deprecated*
 * [EventEmitter.defaultMaxListeners](https://nodejs.org/api/events.html#events_eventemitter_defaultmaxlisteners)
 * **EventEmitter.defaultResultFilter**
+* [EventEmitter.errorMonitor](https://nodejs.org/api/events.html#events_eventemitter_errorMonitor)
 * [emitter.addListener(eventName, listener)](https://nodejs.org/api/events.html#events_emitter_addlistener_eventname_listener)
 
   Returns a `Promise` resolving when all `newListener` events have been emitted.

emitter.d.ts

@@ -0,0 +1,33 @@
+declare type TEventType = string | symbol;
+declare type TListener = (...args: any[]) => Promise<any>;
+declare type TFilter<T = any> = {
+    <S extends T>(callbackfn: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[];
+    (callbackfn: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
+};
+declare class EventEmitter {
+    private _resultFilter;
+    private _events;
+    private _eventsCount;
+    private _domain;
+    get maxListeners(): number;
+    set maxListeners(n: number);
+    getResultFilter(): TFilter | undefined;
+    setResultFilter(filter: TFilter | undefined): this;
+    get resultFilter(): TFilter | undefined;
+    set resultFilter(filter: TFilter | undefined);
+    emit(type: TEventType, ...args: any[]): Promise<any>;
+    addListener(type: TEventType, listener: TListener): Promise<any>;
+    prependListener(type: TEventType, listener: TListener): Promise<any>;
+    once(type: TEventType, listener?: TListener): Promise<any>;
+    prependOnceListener(type: TEventType, listener: TListener): Promise<any>;
+    removeListener(type: TEventType, listener: TListener): Promise<any>;
+    removeAllListeners(type: string | symbol): Promise<any>;
+    on(type: TEventType, listener: TListener): Promise<any>;
+    off(type: TEventType, listener: TListener): Promise<any>;
+
+    static EventEmitter: typeof EventEmitter;
+    static defaultMaxListeners: number | undefined;
+    static usingDomains: boolean | undefined;
+    static listenerCount: (events: EventEmitter, type: TEventType) => number;
+}
+export = EventEmitter;

emitter.js

@@ -2,8 +2,6 @@
 
 const events = require('events');
 
-let handlerProcessor = sequentialHandlerProcessor;
-
 
 class EventEmitter extends events.EventEmitter {
   constructor() {
@@ -45,56 +43,61 @@ class EventEmitter extends events.EventEmitter {
   }
 
 
-  emit(type) {
+  emit(type, ...args) {
     // keep a reference to _resultFilter since the filter function
     // could theoretically set a new result filter, leading to
     // undefined results
     const resultFilter = this.getResultFilter();
-    let er, handlers, len, args, events, domain;
+    const events = this._events;
+    const domain = this._domain;
+    const errorMonitor = EventEmitter.errorMonitor;
+    const results = [];
+    let handlers;
     let needDomainExit = false;
     let doError = (type === 'error');
-    let emitter = this;
-    let promise;
-
-    events = this._events;
+    //let emitter = this;
+    let promise = Promise.resolve();
 
     if (events) {
-      doError = (doError && events.error == null);
+      if (doError && (events[errorMonitor] !== undefined)) {
+        promise = promise.then(() => this.emit(errorMonitor, ...args));
+      }
+      doError = (doError && events.error === undefined);
     } else if (!doError) {
-      return Promise.resolve();
+      return promise.then(() => false);
     }
 
-    domain = this.domain;
-
-    // If there is no 'error' event listener then reject
     if (doError) {
-      er = arguments[1];
-
-      if (er) {
-        if (!(er instanceof Error)) {
-          // At least give some kind of context to the user
-          let err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
-          err.context = er;
-          er = err;
-        }
-      } else {
+      let er;
+      if (args.length > 0) {
+        er = args[0];
+      }
+      if (!er) {
         er = new Error('Uncaught, unspecified "error" event.');
+      } else if (!(er instanceof Error)) {
+        // At least give some kind of context to the user
+        let err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
+        err.context = er;
+        er = err;
       }
 
+      // @deprecated
+      // TODO : remove domains
       if (domain) {
         er.domainEmitter = this;
         er.domain = domain;
         er.domainThrown = false;
-        domain.emit('error', er);
+        promise = promise.then(() => domain.emit('error', er));
       }
 
-      return Promise.reject(er);
+      return promise.then(() => { throw er; });
     }
 
-    handlers = events[type];
+
+    handlers = events && events[type];
 
     if (!handlers) {
-      return Promise.resolve();
+      return promise;
     }
 
     if (domain && this !== process) {
@@ -104,47 +107,17 @@ class EventEmitter extends events.EventEmitter {
 
     if (typeof handlers === 'function') {
       handlers = [handlers];
-    } else {
-      handlers = handlers.slice();
     }
 
-    len = arguments.length;
-    switch (len) {
-      // fast cases
-      case 1:
-        promise = handlerProcessor(handlers, handler => handler.call(emitter));
-        break;
-      case 2:
-        args = arguments;
-        promise = handlerProcessor(handlers, handler => handler.call(emitter, args[1]));
-        break;
-      case 3:
-        args = arguments;
-        promise = handlerProcessor(handlers, handler => handler.call(emitter, args[1], args[2]));
-        break;
-      case 4:
-        args = arguments;
-        promise = handlerProcessor(handlers, handler => handler.call(emitter, args[1], args[2], args[3]));
-        break;
-      // slower
-      default:
-        args = new Array(len - 1);
-        for (let i = 1; i < len; ++i) {
-          args[i - 1] = arguments[i];
-        }
-        promise = handlerProcessor(handlers, handler => handler.apply(emitter, args));
+    if (handlers.length) {
+      promise = handlers.reduce((p, handler) => p.then(() => handler(...args)).then(result => results.push(result)), promise);
     }
 
     if (needDomainExit) {
-      promise.then(() => domain.exit());
+      promise = promise.then(() => domain.exit(), err => { domain.exit(); throw err; });
     }
 
-    if (!resultFilter) {
-      // unfiltered version
-      return promise;
-    } else {
-      return promise.then(results => results.filter(resultFilter));
-    }
+    return promise.then(() => resultFilter ? results.filter(resultFilter) : results);
   }
 
 
@@ -181,7 +154,6 @@ class EventEmitter extends events.EventEmitter {
 
   removeListener(type, listener) {
     let list, events, position;
-    let promise;
 
     if (typeof listener !== 'function') {
       throw new TypeError('"listener" argument must be a function');
@@ -201,7 +173,7 @@ class EventEmitter extends events.EventEmitter {
         delete events[type];
 
         if (events.removeListener) {
-          promise = this.emit('removeListener', type, listener);
+          return this.emit('removeListener', type, listener);
         }
       }
     } else if (typeof list !== 'function') {
@@ -240,11 +212,11 @@ class EventEmitter extends events.EventEmitter {
       --this._eventsCount;
 
       if (events.removeListener) {
-        promise = this.emit('removeListener', type, listener);
+        return this.emit('removeListener', type, listener);
       }
     }
 
-    return promise || Promise.resolve();
+    return Promise.resolve();
   }
 
 
@@ -284,10 +256,10 @@ class EventEmitter extends events.EventEmitter {
         key = keys[i];
         if (key === 'removeListener') continue;
 
-        promise = promise && promise.then(this.removeAllListeners(key)) || this.removeAllListeners(key);
+        promise = promise ? promise.then(this.removeAllListeners(key)) : this.removeAllListeners(key);
       }
 
-      promise = promise && promise.then(this.removeAllListeners('removeListener')) || this.removeAllListeners('removeListener');
+      promise = promise ? promise.then(this.removeAllListeners('removeListener')) : this.removeAllListeners('removeListener');
       this._events = {};
       this._eventsCount = 0;
 
@@ -301,7 +273,7 @@ class EventEmitter extends events.EventEmitter {
     } else if (listeners) {
       // LIFO order
       for (let i = listeners.length - 1; i >= 0; --i) {
-        promise = promise && promise.then(this.removeListener(type, listeners[i])) || this.removeListener(type, listeners[i]);
+        promise = promise ? promise.then(this.removeListener(type, listeners[i])) : this.removeListener(type, listeners[i]);
       }
     }
 
@@ -329,37 +301,15 @@ Object.defineProperties(EventEmitter, {
     set: function setUsingDomains(b) {
       events.EventEmitter.usingDomains = b;
     }
-  },
-  //sequentialHandlers: {
-  //  get: function getSequentialHandlers() {
-  //    return handlerProcessor === sequentialHandlerProcessor;
-  //  },
-  //  set: function setSequentialHandlers(b) {
-  //    handlerProcessor = b ? sequentialHandlerProcessor : concurrentHandlerProcessor;
-  //  }
-  //}
+  }
 });
 
 EventEmitter.defaultResultFilter = undefined;
 EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
 EventEmitter.prototype._resultFilter = undefined;
 
 
-function sequentialHandlerProcessor(handlers, callback) {
-  let results = [];
-  return handlers.reduce((promise, handler) => promise.then(() => callback(handler)).then(result => results.push(result)), Promise.resolve()).then(() => results);
-}
-
-//function concurrentHandlerProcessor(handlers, callback) {
-//  return Promise.all(handlers.map(handler => {
-//    try {
-//      return callback(handler);
-//    } catch (err) {
-//      return Promise.reject(err);
-//    }
-//  }));
-//}
-
 
 function _addListener(target, type, listener, prepend) {
   let m;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "promise-events",
-  "version": "0.1.8",
+  "version": "0.2.4",
   "description": "A promise-based events emitter",
   "author": "Yanick Rochon <yanick.rochon@gmail.com>",
   "keywords": [
@@ -11,8 +11,14 @@
   ],
   "license": "MIT",
   "main": "emitter.js",
+  "files": [
+    "emitter.js",
+    "emitter.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
-    "test": "jest ./test",
+    "test": "jest --detectOpenHandles --forceExit",
     "test-cov": "npm run test -- --coverage"
   },
   "homepage": "https://github.com/yanickrochon/promise-events#readme",
@@ -24,9 +30,12 @@
     "url": "https://github.com/yanickrochon/promise-events/issues"
   },
   "devDependencies": {
-    "jest": "^25.1.0"
+    "jest": "^26.6.3"
   },
   "engines": {
     "node": ">=8.0.0"
+  },
+  "jest": {
+    "testEnvironment": "node"
   }
 }

test/emit.test.js

@@ -61,6 +61,7 @@ describe("Test emitting events", () => {
 
           expect( results ).toHaveLength(1);
           expect( Emitter.listenerCount(events, 'foo') ).toEqual(1);
+          expect( events.listenerCount('foo') ).toEqual(1);
 
           return events.on('foo', fn).then(() => {
             expect( events.listeners('foo') ).toHaveLength(2);
@@ -69,6 +70,7 @@ describe("Test emitting events", () => {
 
               expect( results ).toHaveLength(2);
               expect( Emitter.listenerCount(events, 'foo') ).toEqual(2);
+              expect( events.listenerCount('foo') ).toEqual(2);
 
             });
           });

test/inheritance.test.js

@@ -1,12 +1,13 @@
 
 'use strict';
 
-describe("Test inheritance", function () {
+describe("Test inheritance", () => {
 
   const Emitter = require('../emitter');
+  const NativeEmitter = require('events').EventEmitter;
 
 
-  it("should create valid instance", function () {
+  it("should create valid instance", () => {
     const util = require('util');
     const SubEmitter = function () {};
 
@@ -33,12 +34,42 @@ describe("Test inheritance", function () {
   });
 
 
-  it('should be instance of built-in EventEmitter', function () {
-    const EventEmitter = require('events').EventEmitter;
+  it('should be instance of built-in EventEmitter', () => {
+    const events = new Emitter();
 
-    let events = new Emitter();
+    expect( events ).toBeInstanceOf( NativeEmitter );
+  });
+
+
+  it('should return valid event names', async () => {
+    const events = new Emitter();
+
+    await events.addListener('test', () => {});
+
+    expect( events.eventNames() ).toEqual(['test']);
+  });
+
+
+  it('should use error monitor', async () => {
+    if (Emitter.errorMonitor) {
+      const events = new Emitter();
+      const error = new Error('test');
+
+      let errorMonitored = null;
+      let errorEmitted = null;
+
+      await events.addListener(Emitter.errorMonitor, err => errorMonitored = err);
+      await events.addListener('error', err => errorEmitted = err);
+
+      await events.emit('error', error);
+
+      expect( errorMonitored ).toBe(error);
+      expect( errorEmitted ).toBe(error);
+    }
+  });
 
-    expect( events ).toBeInstanceOf( EventEmitter );
+  it("Emitter should provide self reference", function () {
+    expect(Emitter.EventEmitter).toBe(Emitter)
   });
 
 });

test/listeners.test.js

@@ -5,34 +5,51 @@ describe("Test adding and removing listeners", function () {
 
 
   it("should add and remove listeners", function () {
+    const asArray = (value) => Array.isArray(value) ? value : [value];
     const events = new Emitter();
     let fn = function () {};
 
     expect( events ).toHaveProperty('_eventsCount', 0);
+    expect( events.listenerCount('foo') ).toEqual(0);
+    expect( events.listeners() ).toEqual([])
 
     return events.addListener('foo', fn).then(() => {
       expect( events ).toHaveProperty('_eventsCount', 1);
+      expect( events.listenerCount('foo') ).toEqual(1);
       expect( events._events ).toHaveProperty('foo', fn);
+      expect( events.listeners('foo') ).toEqual(asArray(events._events['foo']))
+      expect( events.rawListeners('foo') ).toEqual(asArray(events._events['foo']))
 
       return events.addListener('foo', fn);
     }).then(() => {
       expect( events ).toHaveProperty('_eventsCount', 2);
+      expect( events.listenerCount('foo') ).toEqual(2);
       expect( events._events ).toHaveProperty('foo', [fn, fn]);
+      expect( events.listeners('foo') ).toEqual(asArray(events._events['foo']))
+      expect( events.rawListeners('foo') ).toEqual(asArray(events._events['foo']))
 
       return events.removeListener('foo', () => {});  // unknown listener
     }).then(() => {
       expect( events ).toHaveProperty('_eventsCount', 2);
+      expect( events.listenerCount('foo') ).toEqual(2);
       expect( events._events ).toHaveProperty('foo', [fn, fn]);
+      expect( events.listeners('foo') ).toEqual(asArray(events._events['foo']))
 
       return events.removeListener('foo', fn);
     }).then(() => {
       expect( events ).toHaveProperty('_eventsCount', 1);
+      expect( events.listenerCount('foo') ).toEqual(1);
       expect( events._events ).toHaveProperty('foo', fn);
+      expect( events.listeners('foo') ).toEqual(asArray(events._events['foo']))
+      expect( events.rawListeners('foo') ).toEqual(asArray(events._events['foo']))
 
       return events.removeListener('foo', fn);
     }).then(() => {
       expect( events ).toHaveProperty('_eventsCount', 0);
+      expect( events.listenerCount('foo') ).toEqual(0);
       expect( events._events ).toEqual({});
+      expect( events.listeners('foo') ).toEqual([])
+      expect( events.rawListeners('foo') ).toEqual([])
 
       return events.removeListener('buz', fn);
     });

test/prototype.test.js

@@ -37,6 +37,7 @@ describe("Test EventEmitter prototype", function () {
     let descriptor;
 
     expect( Emitter.prototype.on ).toBe( Emitter.prototype.addListener );
+    expect( Emitter.prototype.off ).toBe( Emitter.prototype.removeListener );
     expect( Emitter.prototype ).toHaveProperty('maxListeners');
 
     descriptor = Object.getOwnPropertyDescriptor(Emitter.prototype, 'maxListeners');