Function wrapPromise

lib/script.js:196–266

(promiseable, sandbox, events, done, sandboxRoot)

}

function wrapPromise(promiseable, sandbox, events, done, sandboxRoot) {
  var realPromise = promiseable;
  var ret = null;
  if(!promiseable.then && promiseable.promise && isPromise(promiseable.promise)) {
    realPromise = bluebird.cast(promiseable.promise);
    ret = { promise: realPromise, resolve: promiseable.resolve, reject: promiseable.reject };
  }
  if (!ret) {
    ret = bluebird.cast(realPromise);
    realPromise = ret;
  }

  var realThen = realPromise._then;
  var addCallback = function () {
    events.emit('addCallback');
  };
  var finishCallback = function() {
    events.emit('finishCallback');
  };

  addCallback();
  realPromise.then(finishCallback, finishCallback);

  realPromise._then = function (onFulfilled, onRejected) {
    var args = [undefined, undefined];

    if (onFulfilled) {
      // wrappedOnFulfilled
      args[0] = function (res) {
        addCallback();
        try {
          var result = onFulfilled.apply(this, arguments);
          return isPromise(result)? wrapPromise(result, sandbox, events, done, sandboxRoot) : result;
        } catch (err) {
          sandboxRoot._error = err;
          throw err;
        } finally {
          finishCallback();
        }
      };
    }

    if(onRejected) {
      args[1] =
        // wrappedOnRejected
        function (error) {
          if (error === sandboxRoot._error) {
            // if we're handling a previously uncaught error, remove it
            sandboxRoot._error = null;
          }
          addCallback();
          try {
            var result = onRejected.apply(this, arguments);
            return isPromise(result)? wrapPromise(result, sandbox, events, done, sandboxRoot) : result;
          } catch (err) {
            sandboxRoot._error = wrapError(err);
            throw err;
          } finally {