mapasync.ts

'use strict';

class MapAsyncIterable<T, R> implements AsyncIterable<R> {
  private _source: Iterable<T>;
  private _selector: (value: T) => Promise<R>;

  constructor(source: Iterable<T>, selector: (value: T) => Promise<R>) {
    this._source = source;
    this._selector = selector;
  }

  async *[Symbol.asyncIterator]() {
    for (let item of this._source) {
      let result = await this._selector(item);
      yield result;
    }
  }
}

export function mapAsync<T, R>(
    source: Iterable<T>,
    selector: (value: T) => Promise<R>,
    thisArg?: any): AsyncIterable<R> {
  const fn = selector.bind(thisArg);
  return new MapAsyncIterable<T, R>(source, fn);
}

export function mapAsync<T, R>(
  source: Iterable<T | PromiseLike<T>> | AsyncIterable<T>,
  selector: (this: undefined, value: T) => R | PromiseLike<R>,
  thisArg?: undefined): AsyncIterable<R>;

export function mapAsync<T, R, This>(
  source: Iterable<T | PromiseLike<T>> | AsyncIterable<T>,
  selector: (this: This, value: T) => R | PromiseLike<R>,
  thisArg: This): AsyncIterable<R>;

And why worry about thisArg bindings in a world with arrow functions?

See https://gist.github.com/rbuckton/c60954f23effa3992f9151d72ba7431d for what I'd recommend.