10 examples of 'bluebird mapseries' in JavaScript

56
function mapSeries(arr, iterator) {
57
    // create a empty promise to start our series (so we can use `then`)
58
    var currentPromise = Q();
59
    var promises = arr.map(function(el) {
60
        return currentPromise = currentPromise.then(function() {
61
            // execute the next function after the previous has resolved successfully
62
            return iterator(el);
63
        });
64
    });
65
    // group the results and return the group promise
66
    return Q.all(promises);
67
}

113
export function promiseSeries(
114
    tasks: Function[],
115
    initial?: any
116
): Promise {
117
    return tasks
118
        .reduce(
119
            (current, next) => (current as any).then(next),
120
            Promise.resolve(initial)
121
        );
122
}

8
function mapSeries(things, fn) {
9
  var results = [];
10
  return P.each(things, function (value, index, length) {
11
    var ret = fn(value, index, length);
12
    results.push(ret);
13
    return ret;
14
  }).thenReturn(results).all();
15
}

1
function promiseMap(collection, functor, concurrency) {
2
  return new Promise((resolve, reject) => {
3
    let running = 0
4
    let index = 0
5
    let rejected = false
6
    const iterator = collection[Symbol.iterator]()
7
8
    function doNext() {
9
      if (rejected) {
10
        return false
11
      }
12
13
      const current = iterator.next()
14
      if (current.done) {
15
        if (running === 0 && !rejected) {
16
          resolve()
17
        }
18
        return false
19
      }
20
21
      Promise.resolve(functor(current.value, index))
22
        .then(onResolved)
23
        .catch(onRejected)
24
      index++
25
      running++
26
      return true
27
    }
28
29
    function onRejected(reason) {
30
      rejected = true
31
      reject(reason)
32
    }
33
34
    function onResolved() {
35
      running--
36
      doNext()
37
    }
38
39
    while (running < concurrency && doNext());
40
  })
41
}

48
map(arr, fnOrModulePath, options) {
49
  return new P((resolve, reject) =>
50
    this._queuePush(arr, fnOrModulePath, options,
51
      (err, data) => err ? reject(err) : resolve(data))
52
  )
53
}

85
export function map(f: (val: T) =&gt; U, seq: Sequence): Sequence<u> {
86
  const newSource: Source<u> = source<u>();
87
  forEach(function(val: T) {
88
    newSource.nextValue(f(val));
89
  }, seq);
90
  Promise.then(function() {
91
    newSource.finished();
92
  }, evaluate(seq));
93
  return newSource.getSequence();
94
}</u></u></u>

23
export function asyncMap(array: T[], asyncFn: (x: T) => T2): Promise {
24
  return Promise.all(array.map(asyncFn));
25
}

16
function asyncMap(arr, func, done) {
17
    var results = [],
18
        length = arr.length,
19
        i = 0;
20
21
    if (!length) task(function () { done(results); });
22
    else {
23
        forEach(arr, function (item, index) {
24
            task(function () {
25
                func(item, function (result) {
26
                    i++;
27
                    results[index] = result;
28
                    if (i == length) done(results);
29
                });
30
            });
31
        });
32
    }
33
}

61
map<u>(f: (v: T) =&gt; U): Future<u> {
62
  return map(f, this);
63
}</u></u>

7
export default function mapAsyncIterator(
8
  iterator: AsyncIterator,
9
  callback: (value: T) =&gt; Promise<u> | U,
10
  rejectCallback?: any,
11
): AsyncIterator<u> {
12
  let $return: any
13
  let abruptClose: any
14
15
  if (typeof iterator.return === 'function') {
16
    $return = iterator.return
17
    abruptClose = (error: any) =&gt; {
18
      const rethrow = () =&gt; Promise.reject(error)
19
      return $return.call(iterator).then(rethrow, rethrow)
20
    }
21
  }
22
23
  function mapResult(result: any) {
24
    return result.done
25
      ? result
26
      : asyncMapValue(result.value, callback).then(iteratorResult, abruptClose)
27
  }
28
29
  let mapReject: any
30
  if (rejectCallback) {
31
    // Capture rejectCallback to ensure it cannot be null.
32
    const reject = rejectCallback
33
    mapReject = (error: any) =&gt;
34
      asyncMapValue(error, reject).then(iteratorResult, abruptClose)
35
  }
36
37
  return {
38
    next() {
39
      return iterator.next().then(mapResult, mapReject)
40
    },
41
    return() {
42
      return $return
43
        ? $return.call(iterator).then(mapResult, mapReject)
44
        : Promise.resolve({ value: undefined, done: true })
45
    },
46
    throw(error: any) {
47
      if (typeof iterator.throw === 'function') {
48
        return iterator.throw(error).then(mapResult, mapReject)
49
      }
50
      return Promise.reject(error).catch(abruptClose)
51
    },
52
    [$$asyncIterator]() {
53
      return this
54
    },
55
  } as any
56
}</u></u>