10 examples of 'bluebird all' in JavaScript

121
all: function all(promises) {
122
  return Parse.Promise.all(promises);
123
}

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
}

66
function promiseAllWithSlowFail(promises) {
67
  let errors = [];
68
69
  let safePromises = promises.map(promise => {
70
    return promise.catch(err => {
71
      errors.push(err);
72
    });
73
  });
74
75
  return Promise.all(safePromises).then(results => {
76
    if (errors.length > 0)
77
      throw { message: `${errors.length} operations failed.`, errors: errors };
78
79
    return results;
80
  });
81
}

169
Promise.all = function all(promiseList)
170
{
171
    var ret = new Promise(function (res, rej)
172
    {
173
        this.__rejector = rej;
174
        this.__resolver = res;
175
        this.__promiseList = promiseList;
176
        this.__done = false;
177
        this.__count = 0;
178
    });
179
180
    for (var i in promiseList)
181
    {
182
        promiseList[i].then(function ()
183
        {
184
            // Success
185
            if(++ret.__count == ret.__promiseList.length)
186
            {
187
                ret.__done = true;
188
                ret.__resolver(ret.__promiseList);
189
            }
190
        }, function (arg)
191
        {
192
            // Failure
193
            if(!ret.__done)
194
            {
195
                ret.__done = true;
196
                ret.__rejector(arg);
197
            }
198
        });
199
    }
200
    if (promiseList.length == 0)
201
    {
202
        ret.__resolver(promiseList);
203
    }
204
    return (ret);
205
};

83
static all(val) {
84
  ++allCalls;
85
  log(`All ${allCalls}`);
86
  return super.all(val);
87
}

37
public static whenAll(promises: Promise[], action: () => void) {
38
    const pending = promises.filter(p => !p.isDone);
39
    if (pending.length === 0) {
40
        action();
41
    }
42
    else {
43
        pending.forEach(p => {
44
            p.whenDone.push(() => {
45
                const index = pending.indexOf(p);
46
                if (index >= 0)
47
                    pending.splice(index, 1);
48
                if (pending.length === 0)
49
                    action();
50
            });
51
        });
52
    }
53
}

5
function all(promises) {
6
  const FP = require('./')
7
  return FP.resolve(Array.isArray(promises)
8
   ? Promise.all(promises)
9
   : promiseAllObject(promises))
10
}

813
function allAsync(callbacks) {
814
  var query = writeQuery();
815
  query += " ORDER BY key";
816
  if (binCount != null) {
817
    cache.queryAsync(query,unBinResults,callbacks);
818
  }
819
  else {
820
    cache.queryAsync(query,undefined,callbacks);
821
  }
822
}

866
function all(iterable) {
867
  var self = this;
868
  if (Object.prototype.toString.call(iterable) !== '[object Array]') {
869
    return this.reject(new TypeError('must be an array'));
870
  }
871
872
  var len = iterable.length;
873
  var called = false;
874
  if (!len) {
875
    return this.resolve([]);
876
  }
877
878
  var values = new Array(len);
879
  var resolved = 0;
880
  var i = -1;
881
  var promise = new this(INTERNAL);
882
883
  while (++i < len) {
884
    allResolver(iterable[i], i);
885
  }
886
  return promise;
887
  function allResolver(value, i) {
888
    self.resolve(value).then(resolveFromAll, function (error) {
889
      if (!called) {
890
        called = true;
891
        handlers.reject(promise, error);
892
      }
893
    });
894
    function resolveFromAll(outValue) {
895
      values[i] = outValue;
896
      if (++resolved === len && !called) {
897
        called = true;
898
        handlers.resolve(promise, values);
899
      }
900
    }
901
  }
902
}

384
return function all() {
385
  for (let i = 0; i < ss.length; i++) ss[i]();
386
};