Swallow listener errors

- `emit` never reject.
- listener’s errors emit `error` events if there’s any `error` listener registered (including `onAny` listeners).
- if there is no listener for error, let the host emit an unhandled rejection event.

index.js

@@ -25,6 +25,10 @@ function getListeners(instance, eventName) {
 	return events.get(eventName);
 }
 
+function hostReportError(err) {
+	Promise.reject(err);
+}
+
 class Emittery {
 	constructor() {
 		anyMap.set(this, new Set());
@@ -59,35 +63,34 @@ class Emittery {
 
 		const listeners = getListeners(this, eventName);
 		const anyListeners = anyMap.get(this);
-		const staticListeners = [...listeners];
-		const staticAnyListeners = [...anyListeners];
-
-		let rejectionReason;
-		let sawRejection = false;
-		const handleRejection = reason => {
-			if (!sawRejection) {
-				sawRejection = true;
-				rejectionReason = reason;
-			}
-		};
+		let staticListeners = [...listeners];
+		let staticAnyListeners = [...anyListeners];
 
 		await resolvedPromise;
+
+		staticListeners = staticListeners.filter(fn => listeners.has(fn));
+		staticAnyListeners = staticAnyListeners.filter(fn => anyListeners.has(fn));
+
+		const hasListener = staticListeners.length > 0 || staticAnyListeners.length > 0;
+
+		if (eventName === 'error' && !hasListener) {
+			return hostReportError(eventData);
+		}
+
+		const handleRejection = eventName === 'error' ? hostReportError : e => this.emit('error', e);
+
 		await Promise.all([
 			...staticListeners.map(listener => {
-				return listeners.has(listener) && new Promise(resolve => {
+				return new Promise(resolve => {
 					resolve(listener(eventData));
 				}).catch(handleRejection);
 			}),
 			...staticAnyListeners.map(listener => {
-				return anyListeners.has(listener) && new Promise(resolve => {
+				return new Promise(resolve => {
 					resolve(listener(eventName, eventData));
 				}).catch(handleRejection);
 			})
 		]);
-
-		if (sawRejection) {
-			throw rejectionReason;
-		}
 	}
 
 	async emitSerial(eventName, eventData) {

test/_run.js

@@ -147,19 +147,27 @@ module.exports = Emittery => {
 		emitter.on('🦄', () => delay(10).then(() => {
 			settled = true;
 		}));
+		emitter.on('error', () => {});
 
-		await t.throws(emitter.emit('🦄'));
+		await emitter.emit('🦄');
 		t.true(settled);
 	});
 
-	test('emit() - rejects with the first rejection reason', async t => {
+	test('emit() - emit each error', async t => {
 		const emitter = new Emittery();
 		const first = new Error('first rejection');
+		const second = new Error('second rejection');
+		const errors = new Set();
+
 		emitter.on('🦄', () => Promise.reject(first));
-		emitter.on('🦄', () => Promise.reject(new Error('second rejection')));
+		emitter.on('🦄', () => Promise.reject(second));
+		emitter.on('error', e => errors.add(e));
+
+		await emitter.emit('🦄');
 
-		const err = await t.throws(emitter.emit('🦄'));
-		t.is(err, first);
+		t.true(errors.has(first));
+		t.true(errors.has(second));
+		t.is(errors.size, 2);
 	});
 
 	test('emit() - calls listeners subscribed when emit() was invoked', async t => {