Implement listener subscription as async iterator protocol

index.js

@@ -8,6 +8,29 @@ function assertEventName(eventName) {
 	}
 }
 
+async function * iterator(emitter, eventName) {
+	const queue = [];
+	const off = emitter.on(eventName, data => {
+		queue.push(data);
+	});
+
+	try {
+		/* eslint-disable no-constant-condition */
+		/* eslint-disable no-await-in-loop */
+		while (true) {
+			if (queue.length > 0) {
+				yield queue.shift();
+			} else {
+				yield await emitter.once(eventName);
+			}
+		}
+		/* eslint-enable no-constant-condition */
+		/* eslint-enable no-await-in-loop */
+	} finally {
+		off();
+	}
+}
+
 module.exports = class Emittery {
 	constructor() {
 		this._events = new Map();
@@ -24,8 +47,13 @@ module.exports = 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

@@ -50,19 +50,32 @@
 		"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",
 		"delay": "^2.0.0",
 		"nyc": "^11.3.0",
 		"xo": "*"
 	},
+	"xo": {
+		"parser": "babel-eslint"
+	},
 	"babel": {
 		"plugins": [
 			"transform-async-to-generator",
-			"transform-es2015-spread"
+			"transform-es2015-spread",
+			"transform-async-generator-functions"
+		],
+		"presets":[
+			"@ava/stage-4"
 		]
 	},
+	"ava": {
+		"require": "babel-register",
+		"babel": "inherit"
+	},
 	"nyc": {
 		"reporter": [
 			"html",

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

@@ -37,6 +37,28 @@ module.exports = Emittery => {
 		t.is(emitter._events.get('🦄').size, 1);
 	});
 
+	test('on() - async iterator', async t => {
+		const fixture = '🌈';
+		const emitter = new Emittery();
+		setTimeout(() => {
+			emitter.emit('🦄', fixture);
+		}, 300);
+		const iterator = emitter.on('🦄');
+		const {value, done} = await iterator.next();
+		t.deepEqual(done, false);
+		t.deepEqual(value, fixture);
+	});
+
+	test('on() - async iterator (queued)', async t => {
+		const fixture = '🌈';
+		const emitter = new Emittery();
+		const iterator = emitter.on('🦄');
+		emitter.emit('🦄', fixture);
+		const {value, done} = await iterator.next();
+		t.deepEqual(done, false);
+		t.deepEqual(value, fixture);
+	});
+
 	test('off()', t => {
 		const emitter = new Emittery();
 		const listener = () => {};