resolve-on.es5.js

// A more straight forward es5 version

function resolveOn(eventEmmiter, resolveEvent, rejectEvent) {
  rejectEvent = rejectEvent === undefined ? "error" : rejectEvent;

  return new Promise(function(resolve, reject) {
    function resolveHandler(value) {
      eventEmmiter.removeListener(rejectEvent, rejectHandler);
      resolve(value);
    }

    function rejectHandler(value) {
      eventEmmiter.removeListener(resolveEvent, resolveHandler);
      reject(value);
    }

    eventEmmiter.once(resolveEvent, resolveHandler);
    eventEmmiter.once(rejectEvent, rejectHandler);
  });
}

resolve-on.js

/*
resolveOn

Simple function to turn an event emitter in to a promise.
"error" events will reject the promise.

I have seen some similar packages but none rejected on an error event causing the promise to hang unresolved.

Made for generator/async functions

function* main() {
  const db = new Db(config);

  // waits here until the 'connected' event is emmited
  yield resolveOn(db, 'connected');
  
  // db now connected and ready to use
  // All event listeners added by resolveOn have been removed before resolving
  
  let request = db.query('SELECT * FROM users');
  
  let rowCount = 0;
  request.on('row', user => {
    console.log(user.name);
    rowCount++;
  });
  
  yield resolveOn(request, 'done');
  console.log(`${rowCount} users`);
}

co(main)
  .catch(err => {
    // Connection errors will be caught here
  })

*/


const resolveOn = (eventEmmiter, resolveEvent, rejectEvent = "error") =>
  new Promise((resolve, reject) => {
    const eventHandlers = [
      {
        event: resolveEvent,
        callback(value) {
          removeListeners();
          resolve(value);
        }
      },
      {
        event: rejectEvent,
        callback(err) {
          removeListeners();
          reject(err);
        }
      }
    ];

    const removeListeners = () => {
      eventHandlers.forEach(({ event, callback }) =>
        eventEmmiter.removeListener(event, callback)
      );
    };

    eventHandlers.forEach(({ event, callback }) =>
      eventEmmiter.once(event, callback)
    );
  });

module.exports = {
  resolveOn
};