Implement listener subscription as async iterator protocol

index.js

@@ -8,6 +8,45 @@ function assertEventName(eventName) {
 	}
 }
 
+function iterator(emitter, eventName) {
+	let flush = null;
+	let queue = [];
+	const off = emitter.on(eventName, data => {
+		if (flush) {
+			flush(data);
+		} else {
+			queue.push(data);
+		}
+	});
+
+	return {
+		async next() {
+			if (!queue) {
+				return {done: true};
+			}
+
+			if (queue.length > 0) {
+				return {done: false, value: queue.shift()};
+			}
+
+			const value = await new Promise(resolve => {
+				flush = data => {
+					resolve(data);
+					flush = null;
+				};
+			});
+			return {done: false, value};
+		},
+		return() {
+			off();
+			queue = null;
+		},
+		[Symbol.asyncIterator]() {
+			return this;
+		}
+	};
+}
+
 class Emittery {
 	constructor() {
 		this._events = new Map();
@@ -24,8 +63,13 @@ class Emittery {
 
 	on(eventName, listener) {
 		assertEventName(eventName);
-		this._getListeners(eventName).add(listener);
-		return this.off.bind(this, eventName, listener);
+
+		if (typeof listener === 'function') {
+			this._getListeners(eventName).add(listener);
+			return this.off.bind(this, eventName, listener);
+		}
+
+		return iterator(this, eventName);
 	}
 
 	off(eventName, listener) {

package.json

@@ -54,6 +54,8 @@
 		"ava": "*",
 		"babel-cli": "^6.26.0",
 		"babel-core": "^6.26.0",
+		"babel-eslint": "^8.1.2",
+		"babel-plugin-transform-async-generator-functions": "^6.24.1",
 		"babel-plugin-transform-async-to-generator": "^6.24.1",
 		"babel-plugin-transform-es2015-spread": "^6.22.0",
 		"codecov": "^3.0.0",
@@ -64,6 +66,17 @@
 		"typescript": "^2.6.2",
 		"xo": "*"
 	},
+	"ava": {
+		"babel": {
+			"plugins": [
+				"transform-async-generator-functions"
+			],
+			"presets": [
+				"@ava/stage-4",
+				"@ava/transform-test-files"
+			]
+		}
+	},
 	"babel": {
 		"plugins": [
 			"transform-async-to-generator",
@@ -76,5 +89,8 @@
 			"lcov",
 			"text"
 		]
+	},
+	"xo": {
+		"parser": "babel-eslint"
 	}
 }

readme.md

@@ -47,6 +47,28 @@ Returns an unsubscribe method.
 
 Using the same listener multiple times for the same event will result in only one method call per emitted event.
 
+If you use the method with only the first argument, it will return an asynchronous iterator. Your listener will therefore be the loop body and you'll be able to
+unsubscribe to the event simply by breaking the loop.
+
+```Javascript
+  const emitter = new Emittery();
+  //subscribe
+  (async function () {
+    for await (let t of emitter.on('foo')) {
+     if(t >10){
+       break;//unsubscribe
+     }
+     console.log(t);
+    }
+  })();
+
+  let count = 0;
+  setInterval(function () {
+    count++;
+    emitter.emit('foo', count);
+  }, 1000);
+```
+
 ##### listener(data)
 
 #### off(eventName, [listener])

test/_run.js

@@ -1,6 +1,24 @@
 import test from 'ava';
 import delay from 'delay';
 
+// babel-plugin-transform-async-generator-functions assumes
+// `Symbol.asyncIterator` exists, so stub it for iterator tests.
+function stubAsyncIteratorSymbol(next) {
+	return async (...args) => {
+		if (!Symbol.asyncIterator) {
+			Symbol.asyncIterator = Symbol.for('Emittery.asyncIterator');
+		}
+
+		try {
+			return await next(...args);
+		} finally {
+			if (Symbol.asyncIterator === Symbol.for('Emittery.asyncIterator')) {
+				delete Symbol.asyncIterator;
+			}
+		}
+	};
+}
+
 module.exports = Emittery => {
 	test('on()', t => {
 		const emitter = new Emittery();
@@ -37,6 +55,27 @@ module.exports = Emittery => {
 		t.is(emitter._events.get('🦄').size, 1);
 	});
 
+	test.serial('on() - async iterator', stubAsyncIteratorSymbol(async t => {
+		const emitter = new Emittery();
+		const iterator = emitter.on('🦄');
+
+		await emitter.emit('🦄', '🌈');
+		setTimeout(() => {
+			emitter.emit('🦄', '🌟');
+		}, 10);
+
+		t.plan(3);
+		const expected = ['🌈', '🌟'];
+		for await (const data of iterator) {
+			t.deepEqual(data, expected.shift());
+			if (expected.length === 0) {
+				break;
+			}
+		}
+
+		t.deepEqual(await iterator.next(), {done: true});
+	}));
+
 	test('off()', t => {
 		const emitter = new Emittery();
 		const listener = () => {};