10 examples of 'bluebird promise map' in JavaScript

162
return new Promise(function promiseFn(resolve, reject) {
163
  resolve(response);
164
  reject('mock request failed');
165
});

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
}

39
return new Promise(function resolvePromise(resolve) {
40
  return resolve(saveLanguageWiki(langObject, saveDir, doWikitext));
41
});

92
function chainPromise(promises) {
93
  var chain = Promise.resolve()
94
  promises.forEach(function (promise) {
95
    chain = chain.then(function (o) {
96
      return typeof promise === 'function' ? promise(o) : promise
97
    })
98
  })
99
  return chain
100
}

181
function all(promises) {
182
	/*jshint maxcomplexity:8*/
183
	var resolver = new Pending();
184
	var pending = promises.length >>> 0;
185
	var results = new Array(pending);
186
187
	var i, h, x, s;
188
	for (i = 0; i < promises.length; ++i) {
189
		x = promises[i];
190
191
		if (x === void 0 && !(i in promises)) {
192
			--pending;
193
			continue;
194
		}
195
196
		if (maybeThenable(x)) {
197
			h = getHandlerMaybeThenable(x);
198
199
			s = h.state();
200
			if (s === 0) {
201
				h.fold(settleAt, i, results, resolver);
202
			} else if (s > 0) {
203
				results[i] = h.value;
204
				--pending;
205
			} else {
206
				unreportRemaining(promises, i+1, h);
207
				resolver.become(h);
208
				break;
209
			}
210
211
		} else {
212
			results[i] = x;
213
			--pending;
214
		}
215
	}
216
217
	if(pending === 0) {
218
		resolver.become(new Fulfilled(results));
219
	}
220
221
	return new Promise(Handler, resolver);
222
223
	function settleAt(i, x, resolver) {
224
		/*jshint validthis:true*/
225
		this[i] = x;
226
		if(--pending === 0) {
227
			resolver.become(new Fulfilled(this));
228
		}
229
	}
230
}

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
}

92
function rejectPromise(e) {
93
    return reject(e);
94
}

56
mapIfResolved(f = payload => payload, valueIfNotResolved = null) {
57
  if (this.isResolved()) {
58
    return f(this.payload);
59
  } else {
60
    return valueIfNotResolved;
61
  }
62
}

20
function handleMap (promise, result) {
21
  promise._fulfill(result)
22
}

29
export function promiseOr(promises: Array>): Promise {
30
    let resolved = false;
31
    let rejected = 0;
32
    return new Promise((resolve, reject) => {
33
        for (const promise of promises) {
34
            promise.then((res) => {
35
                if (!resolved) {
36
                    resolved = true;
37
                    resolve(res);
38
                }
39
            }).catch(() => {
40
                rejected++;
41
                if (!resolved && rejected >= promises.length) reject();
42
            });
43
        }
44
    });
45
}