twitst4tz

reduce.js (5372B)

---

 "use strict";
 module.exports = function(Promise,
                           PromiseArray,
                           apiRejection,
                           tryConvertToPromise,
                           INTERNAL,
                           debug) {
 var util = require("./util");
 var tryCatch = util.tryCatch;
 
 function ReductionPromiseArray(promises, fn, initialValue, _each) {
     this.constructor$(promises);
     var context = Promise._getContext();
     this._fn = util.contextBind(context, fn);
     if (initialValue !== undefined) {
         initialValue = Promise.resolve(initialValue);
         initialValue._attachCancellationCallback(this);
     }
     this._initialValue = initialValue;
     this._currentCancellable = null;
     if(_each === INTERNAL) {
         this._eachValues = Array(this._length);
     } else if (_each === 0) {
         this._eachValues = null;
     } else {
         this._eachValues = undefined;
     }
     this._promise._captureStackTrace();
     this._init$(undefined, -5);
 }
 util.inherits(ReductionPromiseArray, PromiseArray);
 
 ReductionPromiseArray.prototype._gotAccum = function(accum) {
     if (this._eachValues !== undefined &&
         this._eachValues !== null &&
         accum !== INTERNAL) {
         this._eachValues.push(accum);
     }
 };
 
 ReductionPromiseArray.prototype._eachComplete = function(value) {
     if (this._eachValues !== null) {
         this._eachValues.push(value);
     }
     return this._eachValues;
 };
 
 ReductionPromiseArray.prototype._init = function() {};
 
 ReductionPromiseArray.prototype._resolveEmptyArray = function() {
     this._resolve(this._eachValues !== undefined ? this._eachValues
                                                  : this._initialValue);
 };
 
 ReductionPromiseArray.prototype.shouldCopyValues = function () {
     return false;
 };
 
 ReductionPromiseArray.prototype._resolve = function(value) {
     this._promise._resolveCallback(value);
     this._values = null;
 };
 
 ReductionPromiseArray.prototype._resultCancelled = function(sender) {
     if (sender === this._initialValue) return this._cancel();
     if (this._isResolved()) return;
     this._resultCancelled$();
     if (this._currentCancellable instanceof Promise) {
         this._currentCancellable.cancel();
     }
     if (this._initialValue instanceof Promise) {
         this._initialValue.cancel();
     }
 };
 
 ReductionPromiseArray.prototype._iterate = function (values) {
     this._values = values;
     var value;
     var i;
     var length = values.length;
     if (this._initialValue !== undefined) {
         value = this._initialValue;
         i = 0;
     } else {
         value = Promise.resolve(values[0]);
         i = 1;
     }
 
     this._currentCancellable = value;
 
     for (var j = i; j < length; ++j) {
         var maybePromise = values[j];
         if (maybePromise instanceof Promise) {
             maybePromise.suppressUnhandledRejections();
         }
     }
 
     if (!value.isRejected()) {
         for (; i < length; ++i) {
             var ctx = {
                 accum: null,
                 value: values[i],
                 index: i,
                 length: length,
                 array: this
             };
 
             value = value._then(gotAccum, undefined, undefined, ctx, undefined);
 
             if ((i & 127) === 0) {
                 value._setNoAsyncGuarantee();
             }
         }
     }
 
     if (this._eachValues !== undefined) {
         value = value
             ._then(this._eachComplete, undefined, undefined, this, undefined);
     }
     value._then(completed, completed, undefined, value, this);
 };
 
 Promise.prototype.reduce = function (fn, initialValue) {
     return reduce(this, fn, initialValue, null);
 };
 
 Promise.reduce = function (promises, fn, initialValue, _each) {
     return reduce(promises, fn, initialValue, _each);
 };
 
 function completed(valueOrReason, array) {
     if (this.isFulfilled()) {
         array._resolve(valueOrReason);
     } else {
         array._reject(valueOrReason);
     }
 }
 
 function reduce(promises, fn, initialValue, _each) {
     if (typeof fn !== "function") {
         return apiRejection("expecting a function but got " + util.classString(fn));
     }
     var array = new ReductionPromiseArray(promises, fn, initialValue, _each);
     return array.promise();
 }
 
 function gotAccum(accum) {
     this.accum = accum;
     this.array._gotAccum(accum);
     var value = tryConvertToPromise(this.value, this.array._promise);
     if (value instanceof Promise) {
         this.array._currentCancellable = value;
         return value._then(gotValue, undefined, undefined, this, undefined);
     } else {
         return gotValue.call(this, value);
     }
 }
 
 function gotValue(value) {
     var array = this.array;
     var promise = array._promise;
     var fn = tryCatch(array._fn);
     promise._pushContext();
     var ret;
     if (array._eachValues !== undefined) {
         ret = fn.call(promise._boundValue(), value, this.index, this.length);
     } else {
         ret = fn.call(promise._boundValue(),
                               this.accum, value, this.index, this.length);
     }
     if (ret instanceof Promise) {
         array._currentCancellable = ret;
     }
     var promiseCreated = promise._popContext();
     debug.checkForgottenReturns(
         ret,
         promiseCreated,
         array._eachValues !== undefined ? "Promise.each" : "Promise.reduce",
         promise
     );
     return ret;
 }
 };