twitst4tz

map.js (5602B)

---

 "use strict";
 module.exports = function(Promise,
                           PromiseArray,
                           apiRejection,
                           tryConvertToPromise,
                           INTERNAL,
                           debug) {
 var util = require("./util");
 var tryCatch = util.tryCatch;
 var errorObj = util.errorObj;
 var async = Promise._async;
 
 function MappingPromiseArray(promises, fn, limit, _filter) {
     this.constructor$(promises);
     this._promise._captureStackTrace();
     var context = Promise._getContext();
     this._callback = util.contextBind(context, fn);
     this._preservedValues = _filter === INTERNAL
         ? new Array(this.length())
         : null;
     this._limit = limit;
     this._inFlight = 0;
     this._queue = [];
     async.invoke(this._asyncInit, this, undefined);
     if (util.isArray(promises)) {
         for (var i = 0; i < promises.length; ++i) {
             var maybePromise = promises[i];
             if (maybePromise instanceof Promise) {
                 maybePromise.suppressUnhandledRejections();
             }
         }
     }
 }
 util.inherits(MappingPromiseArray, PromiseArray);
 
 MappingPromiseArray.prototype._asyncInit = function() {
     this._init$(undefined, -2);
 };
 
 MappingPromiseArray.prototype._init = function () {};
 
 MappingPromiseArray.prototype._promiseFulfilled = function (value, index) {
     var values = this._values;
     var length = this.length();
     var preservedValues = this._preservedValues;
     var limit = this._limit;
 
     if (index < 0) {
         index = (index * -1) - 1;
         values[index] = value;
         if (limit >= 1) {
             this._inFlight--;
             this._drainQueue();
             if (this._isResolved()) return true;
         }
     } else {
         if (limit >= 1 && this._inFlight >= limit) {
             values[index] = value;
             this._queue.push(index);
             return false;
         }
         if (preservedValues !== null) preservedValues[index] = value;
 
         var promise = this._promise;
         var callback = this._callback;
         var receiver = promise._boundValue();
         promise._pushContext();
         var ret = tryCatch(callback).call(receiver, value, index, length);
         var promiseCreated = promise._popContext();
         debug.checkForgottenReturns(
             ret,
             promiseCreated,
             preservedValues !== null ? "Promise.filter" : "Promise.map",
             promise
         );
         if (ret === errorObj) {
             this._reject(ret.e);
             return true;
         }
 
         var maybePromise = tryConvertToPromise(ret, this._promise);
         if (maybePromise instanceof Promise) {
             maybePromise = maybePromise._target();
             var bitField = maybePromise._bitField;
             ;
             if (((bitField & 50397184) === 0)) {
                 if (limit >= 1) this._inFlight++;
                 values[index] = maybePromise;
                 maybePromise._proxy(this, (index + 1) * -1);
                 return false;
             } else if (((bitField & 33554432) !== 0)) {
                 ret = maybePromise._value();
             } else if (((bitField & 16777216) !== 0)) {
                 this._reject(maybePromise._reason());
                 return true;
             } else {
                 this._cancel();
                 return true;
             }
         }
         values[index] = ret;
     }
     var totalResolved = ++this._totalResolved;
     if (totalResolved >= length) {
         if (preservedValues !== null) {
             this._filter(values, preservedValues);
         } else {
             this._resolve(values);
         }
         return true;
     }
     return false;
 };
 
 MappingPromiseArray.prototype._drainQueue = function () {
     var queue = this._queue;
     var limit = this._limit;
     var values = this._values;
     while (queue.length > 0 && this._inFlight < limit) {
         if (this._isResolved()) return;
         var index = queue.pop();
         this._promiseFulfilled(values[index], index);
     }
 };
 
 MappingPromiseArray.prototype._filter = function (booleans, values) {
     var len = values.length;
     var ret = new Array(len);
     var j = 0;
     for (var i = 0; i < len; ++i) {
         if (booleans[i]) ret[j++] = values[i];
     }
     ret.length = j;
     this._resolve(ret);
 };
 
 MappingPromiseArray.prototype.preservedValues = function () {
     return this._preservedValues;
 };
 
 function map(promises, fn, options, _filter) {
     if (typeof fn !== "function") {
         return apiRejection("expecting a function but got " + util.classString(fn));
     }
 
     var limit = 0;
     if (options !== undefined) {
         if (typeof options === "object" && options !== null) {
             if (typeof options.concurrency !== "number") {
                 return Promise.reject(
                     new TypeError("'concurrency' must be a number but it is " +
                                     util.classString(options.concurrency)));
             }
             limit = options.concurrency;
         } else {
             return Promise.reject(new TypeError(
                             "options argument must be an object but it is " +
                              util.classString(options)));
         }
     }
     limit = typeof limit === "number" &&
         isFinite(limit) && limit >= 1 ? limit : 0;
     return new MappingPromiseArray(promises, fn, limit, _filter).promise();
 }
 
 Promise.prototype.map = function (fn, options) {
     return map(this, fn, options, null);
 };
 
 Promise.map = function (promises, fn, options, _filter) {
     return map(promises, fn, options, _filter);
 };
 
 
 };