Implement listener subscription as async iterator protocol

index.js

@@ -8,27 +8,43 @@ function assertEventName(eventName) {
 	}
 }
 
-async function * iterator(emitter, eventName) {
-	const queue = [];
+function iterator(emitter, eventName) {
+	let flush = null;
+	let queue = [];
 	const off = emitter.on(eventName, data => {
-		queue.push(data);
+		if (flush) {
+			flush(data);
+		} else {
+			queue.push(data);
+		}
 	});
 
-	try {
-		/* eslint-disable no-constant-condition */
-		/* eslint-disable no-await-in-loop */
-		while (true) {
+	return {
+		async next() {
+			if (!queue) {
+				return {done: true};
+			}
+
 			if (queue.length > 0) {
-				yield queue.shift();
-			} else {
-				yield await emitter.once(eventName);
+				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;
 		}
-		/* eslint-enable no-constant-condition */
-		/* eslint-enable no-await-in-loop */
-	} finally {
-		off();
-	}
+	};
 }
 
 class Emittery {

package.json

@@ -66,28 +66,31 @@
 		"typescript": "^2.6.2",
 		"xo": "*"
 	},
-	"xo": {
-		"parser": "babel-eslint"
+	"ava": {
+		"babel": {
+			"plugins": [
+				"transform-async-generator-functions"
+			],
+			"presets": [
+				"@ava/stage-4",
+				"@ava/transform-test-files"
+			]
+		}
 	},
 	"babel": {
 		"plugins": [
 			"transform-async-to-generator",
-			"transform-es2015-spread",
-			"transform-async-generator-functions"
-		],
-		"presets":[
-			"@ava/stage-4"
+			"transform-es2015-spread"
 		]
 	},
-	"ava": {
-		"require": "babel-register",
-		"babel": "inherit"
-	},
 	"nyc": {
 		"reporter": [
 			"html",
 			"lcov",
 			"text"
 		]
+	},
+	"xo": {
+		"parser": "babel-eslint"
 	}
 }

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,27 +55,26 @@ module.exports = Emittery => {
 		t.is(emitter._events.get('🦄').size, 1);
 	});
 
-	test('on() - async iterator', async t => {
-		const fixture = '🌈';
+	test.serial('on() - async iterator', stubAsyncIteratorSymbol(async t => {
 		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);
-	});
+		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();