Add "array" and "error" options

README.md

@@ -72,6 +72,26 @@ The name of the event you want to watch.
 
 #### options
 
+##### array
+
+Type: `boolean`
+Default: `undefined`
+
+This option controls how a listener's parameters are resolved by
+its promise.
+
+If true, the parameters are resolved as an array. If false,
+the first parameter is resolved. If undefined (the default),
+an array is resolved if there's more than one parameter;
+otherwise, the first parameter is resolved.
+
+##### error
+
+Type: `string`
+Default: `"error"`
+
+The name of the event which rejects the promise.
+
 ##### ignoreErrors
 
 Type: `boolean`

index.js

@@ -8,7 +8,7 @@ var Bluebird = require('bluebird')
 
 // Faster `Function.bind()`.
 function bind (fn, ctx) {
-  return function bindedFunction () {
+  return function boundFunction () {
     return fn.apply(ctx, arguments)
   }
 }
@@ -21,8 +21,10 @@ var toArray = Array.from || (function (slice) {
 
 // ===================================================================
 
-function eventToPromise (emitter, event, opts) {
-  var ignoreErrors = opts && opts.ignoreErrors
+function eventToPromise (emitter, event, _opts) {
+  var opts = _opts || {}
+  var ignoreErrors = opts.ignoreErrors
+  var errorEvent = opts.error || 'error'
 
   return new Bluebird(function (resolve, reject) {
     var addListener =
@@ -44,7 +46,7 @@ function eventToPromise (emitter, event, opts) {
 
       cleanUp = function cleanUp () {
         removeListener(event, eventListener)
-        errorListener && removeListener('error', errorListener)
+        errorListener && removeListener(errorEvent, errorListener)
       }
     } else {
       cleanUp = noop
@@ -53,20 +55,28 @@ function eventToPromise (emitter, event, opts) {
     function eventListener () {
       cleanUp()
 
-      if (arguments.length < 2) {
-        resolve(arguments[0])
-      } else {
-        resolve(toArray(arguments))
+      if ('array' in opts) {
+        if (opts.array) {
+          resolve(toArray(arguments))
+        } else {
+          resolve(arguments[0])
+        }
+      } else { // legacy behaviour for backwards compatibility
+        if (arguments.length < 2) {
+          resolve(arguments[0])
+        } else {
+          resolve(toArray(arguments))
+        }
       }
     }
-    emitter.on(event, eventListener)
+    addListener(event, eventListener)
 
     if (!ignoreErrors) {
       errorListener = function errorListener (error) {
         cleanUp()
         reject(error)
       }
-      emitter.on('error', errorListener)
+      addListener(errorEvent, errorListener)
     }
   }).bind(emitter)
 }

index.spec.js

@@ -17,8 +17,6 @@ var EventEmitter = require('events').EventEmitter
 // ===================================================================
 
 // TODO:
-// - Forcing the parameters to be forwarded in an array for
-//   consistency and predictability.
 // - Maybe handling multiple events.
 // - Tests the different way to add/remove an event listener.
 
@@ -81,6 +79,57 @@ describe('event-to-promise', function () {
 
   // -----------------------------------------------------------------
 
+  describe('array option', function () {
+    it('array: false: fowards the first parameter', function () {
+      var param0 = {}
+      var param1 = {}
+
+      var promise = eventToPromise(emitter, 'foo', { array: false })
+      emitter.emit('foo', param0, param1)
+
+      return promise.then(function () {
+        expect(arguments).to.have.length(1)
+        expect(arguments[0]).to.equal(param0)
+      })
+    })
+
+    it('array: true: fowards all parameters as an array', function () {
+      var param0 = {}
+      var param1 = {}
+
+      var promise = eventToPromise(emitter, 'foo', { array: true })
+      emitter.emit('foo', param0, param1)
+
+      return promise.then(function (values) {
+        expect(values).to.have.length(2)
+        expect(values[0]).to.equal(param0)
+        expect(values[1]).to.equal(param1)
+      })
+    })
+  })
+
+  // -----------------------------------------------------------------
+
+  describe('error option', function () {
+    it('handles a custom error event', function () {
+      var error = new Error()
+
+      var promise = eventToPromise(emitter, 'foo', { error: 'test-error' })
+      emitter.emit('test-error', error)
+
+      return promise.then(
+        function () {
+          expect('should not be executed').to.be.true
+        },
+        function (err) {
+          expect(err).to.equal(error)
+        }
+      )
+    })
+  })
+
+  // -----------------------------------------------------------------
+
   it('handles error event', function () {
     var error = new Error()
 
@@ -101,7 +150,7 @@ describe('event-to-promise', function () {
     var error = new Error()
 
     // Node requires at least one error listener.
-    emitter.on('error', function noop () {})
+    emitter.once('error', function noop () {})
 
     var promise = eventToPromise(emitter, 'foo', {
       ignoreErrors: true