Reimagining events as async iterables

example.ts

const EventEmitter = require('events').EventEmitter;
const fromEventPattern = require('ix/asynciterable/fromeventpattern').fromEventPattern;

// Get Async Iterable
const e = new EventEmitter();
const ai = fromEventPattern(
  h => e.addListener('data', h),
  h => e.removeListener('data', h)
);

const it = ai[Symbol.asyncIterator]();

// Emit some data
e.emit('data', 'foo');
e.emit('data', 'bar');
e.emit('data', 'baz');

// Get some data back out
let result = await it.next();
console.log(result.value); // 'foo'
result = await it.next();
console.log(result.value); // 'bar'
result = await it.next();
console.log(result.value); // 'baz'

// Close it off
await it.return();

fromeventpattern.ts

'use strict';

import { AsyncSink } from '../asyncsink';
import { memoize } from './memoize';

export function fromEventPattern<TSource>(
    addHandler: (handler: Function) => void,
    removeHandler: (handler: Function) => void): AsyncIterable<TSource> {
  const sink = new AsyncSink<TSource>();
  const handler = function (e: TSource) {
    sink.write(e);
  };

  addHandler(handler);

  return memoize({
    [Symbol.asyncIterator]() {
      return {
        next() {
          return sink.next();
        },

        return() {
          removeHandler(handler);
          sink.end();
          return Promise.resolve({ done: true } as IteratorResult<TSource>);
        }
      };
    }
  });
}