| "use strict"; |
| module.exports = function(Promise, |
| apiRejection, |
| INTERNAL, |
| tryConvertToPromise, |
| Proxyable, |
| debug) { |
| var errors = require("./errors"); |
| var TypeError = errors.TypeError; |
| var util = require("./util"); |
| var errorObj = util.errorObj; |
| var tryCatch = util.tryCatch; |
| var yieldHandlers = []; |
| |
| function promiseFromYieldHandler(value, yieldHandlers, traceParent) { |
| for (var i = 0; i < yieldHandlers.length; ++i) { |
| traceParent._pushContext(); |
| var result = tryCatch(yieldHandlers[i])(value); |
| traceParent._popContext(); |
| if (result === errorObj) { |
| traceParent._pushContext(); |
| var ret = Promise.reject(errorObj.e); |
| traceParent._popContext(); |
| return ret; |
| } |
| var maybePromise = tryConvertToPromise(result, traceParent); |
| if (maybePromise instanceof Promise) return maybePromise; |
| } |
| return null; |
| } |
| |
| function PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) { |
| if (debug.cancellation()) { |
| var internal = new Promise(INTERNAL); |
| var _finallyPromise = this._finallyPromise = new Promise(INTERNAL); |
| this._promise = internal.lastly(function() { |
| return _finallyPromise; |
| }); |
| internal._captureStackTrace(); |
| internal._setOnCancel(this); |
| } else { |
| var promise = this._promise = new Promise(INTERNAL); |
| promise._captureStackTrace(); |
| } |
| this._stack = stack; |
| this._generatorFunction = generatorFunction; |
| this._receiver = receiver; |
| this._generator = undefined; |
| this._yieldHandlers = typeof yieldHandler === "function" |
| ? [yieldHandler].concat(yieldHandlers) |
| : yieldHandlers; |
| this._yieldedPromise = null; |
| this._cancellationPhase = false; |
| } |
| util.inherits(PromiseSpawn, Proxyable); |
| |
| PromiseSpawn.prototype._isResolved = function() { |
| return this._promise === null; |
| }; |
| |
| PromiseSpawn.prototype._cleanup = function() { |
| this._promise = this._generator = null; |
| if (debug.cancellation() && this._finallyPromise !== null) { |
| this._finallyPromise._fulfill(); |
| this._finallyPromise = null; |
| } |
| }; |
| |
| PromiseSpawn.prototype._promiseCancelled = function() { |
| if (this._isResolved()) return; |
| var implementsReturn = typeof this._generator["return"] !== "undefined"; |
| |
| var result; |
| if (!implementsReturn) { |
| var reason = new Promise.CancellationError( |
| "generator .return() sentinel"); |
| Promise.coroutine.returnSentinel = reason; |
| this._promise._attachExtraTrace(reason); |
| this._promise._pushContext(); |
| result = tryCatch(this._generator["throw"]).call(this._generator, |
| reason); |
| this._promise._popContext(); |
| } else { |
| this._promise._pushContext(); |
| result = tryCatch(this._generator["return"]).call(this._generator, |
| undefined); |
| this._promise._popContext(); |
| } |
| this._cancellationPhase = true; |
| this._yieldedPromise = null; |
| this._continue(result); |
| }; |
| |
| PromiseSpawn.prototype._promiseFulfilled = function(value) { |
| this._yieldedPromise = null; |
| this._promise._pushContext(); |
| var result = tryCatch(this._generator.next).call(this._generator, value); |
| this._promise._popContext(); |
| this._continue(result); |
| }; |
| |
| PromiseSpawn.prototype._promiseRejected = function(reason) { |
| this._yieldedPromise = null; |
| this._promise._attachExtraTrace(reason); |
| this._promise._pushContext(); |
| var result = tryCatch(this._generator["throw"]) |
| .call(this._generator, reason); |
| this._promise._popContext(); |
| this._continue(result); |
| }; |
| |
| PromiseSpawn.prototype._resultCancelled = function() { |
| if (this._yieldedPromise instanceof Promise) { |
| var promise = this._yieldedPromise; |
| this._yieldedPromise = null; |
| promise.cancel(); |
| } |
| }; |
| |
| PromiseSpawn.prototype.promise = function () { |
| return this._promise; |
| }; |
| |
| PromiseSpawn.prototype._run = function () { |
| this._generator = this._generatorFunction.call(this._receiver); |
| this._receiver = |
| this._generatorFunction = undefined; |
| this._promiseFulfilled(undefined); |
| }; |
| |
| PromiseSpawn.prototype._continue = function (result) { |
| var promise = this._promise; |
| if (result === errorObj) { |
| this._cleanup(); |
| if (this._cancellationPhase) { |
| return promise.cancel(); |
| } else { |
| return promise._rejectCallback(result.e, false); |
| } |
| } |
| |
| var value = result.value; |
| if (result.done === true) { |
| this._cleanup(); |
| if (this._cancellationPhase) { |
| return promise.cancel(); |
| } else { |
| return promise._resolveCallback(value); |
| } |
| } else { |
| var maybePromise = tryConvertToPromise(value, this._promise); |
| if (!(maybePromise instanceof Promise)) { |
| maybePromise = |
| promiseFromYieldHandler(maybePromise, |
| this._yieldHandlers, |
| this._promise); |
| if (maybePromise === null) { |
| this._promiseRejected( |
| new TypeError( |
| "A value %s was yielded that could not be treated as a promise\u000a\u000a See http://goo.gl/MqrFmX\u000a\u000a".replace("%s", String(value)) + |
| "From coroutine:\u000a" + |
| this._stack.split("\n").slice(1, -7).join("\n") |
| ) |
| ); |
| return; |
| } |
| } |
| maybePromise = maybePromise._target(); |
| var bitField = maybePromise._bitField; |
| ; |
| if (((bitField & 50397184) === 0)) { |
| this._yieldedPromise = maybePromise; |
| maybePromise._proxy(this, null); |
| } else if (((bitField & 33554432) !== 0)) { |
| Promise._async.invoke( |
| this._promiseFulfilled, this, maybePromise._value() |
| ); |
| } else if (((bitField & 16777216) !== 0)) { |
| Promise._async.invoke( |
| this._promiseRejected, this, maybePromise._reason() |
| ); |
| } else { |
| this._promiseCancelled(); |
| } |
| } |
| }; |
| |
| Promise.coroutine = function (generatorFunction, options) { |
| if (typeof generatorFunction !== "function") { |
| throw new TypeError("generatorFunction must be a function\u000a\u000a See http://goo.gl/MqrFmX\u000a"); |
| } |
| var yieldHandler = Object(options).yieldHandler; |
| var PromiseSpawn$ = PromiseSpawn; |
| var stack = new Error().stack; |
| return function () { |
| var generator = generatorFunction.apply(this, arguments); |
| var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler, |
| stack); |
| var ret = spawn.promise(); |
| spawn._generator = generator; |
| spawn._promiseFulfilled(undefined); |
| return ret; |
| }; |
| }; |
| |
| Promise.coroutine.addYieldHandler = function(fn) { |
| if (typeof fn !== "function") { |
| throw new TypeError("expecting a function but got " + util.classString(fn)); |
| } |
| yieldHandlers.push(fn); |
| }; |
| |
| Promise.spawn = function (generatorFunction) { |
| debug.deprecated("Promise.spawn()", "Promise.coroutine()"); |
| if (typeof generatorFunction !== "function") { |
| return apiRejection("generatorFunction must be a function\u000a\u000a See http://goo.gl/MqrFmX\u000a"); |
| } |
| var spawn = new PromiseSpawn(generatorFunction, this); |
| var ret = spawn.promise(); |
| spawn._run(Promise.spawn); |
| return ret; |
| }; |
| }; |