Add unhandled rejection tracking

q.js

@@ -91,6 +91,7 @@ var nextTick =(function () {
  var flushing = false;
  var requestTick = void 0;
  var isNodeJS = false;
+ var laterQueue = []; // queue for late tasks
 
  function flush() {
  /* jshint loopfunc: true */
@@ -105,43 +106,50 @@ var nextTick =(function () {
  head.domain = void 0;
  domain.enter();
  }
+ runSingle(task);
 
- try {
- task();
-
- } catch (e) {
- if (isNodeJS) {
- // In node, uncaught exceptions are considered fatal errors.
- // Re-throw them synchronously to interrupt flushing!
-
- // Ensure continuation if the uncaught exception is suppressed
- // listening "uncaughtException" events (as domains does).
- // Continue in next event to avoid tick recursion.
- if (domain) {
- domain.exit();
- }
- setTimeout(flush, 0);
- if (domain) {
- domain.enter();
- }
+ }
+ while(laterQueue.length){
+ var fn = laterQueue.pop();
+ runSingle(fn);
+ }
+ flushing = false;
+ }
 
- throw e;
+ function runSingle(task){ // runs a single function in the async queue
+ try {
+ task();
 
- } else {
- // In browsers, uncaught exceptions are not fatal.
- // Re-throw them asynchronously to avoid slow-downs.
- setTimeout(function() {
- throw e;
- }, 0);
+ } catch (e) {
+ if (isNodeJS) {
+ // In node, uncaught exceptions are considered fatal errors.
+ // Re-throw them synchronously to interrupt flushing!
+
+ // Ensure continuation if the uncaught exception is suppressed
+ // listening "uncaughtException" events (as domains does).
+ // Continue in next event to avoid tick recursion.
+ if (domain) {
+ domain.exit();
+ }
+ setTimeout(flush, 0);
+ if (domain) {
+ domain.enter();
  }
- }
 
- if (domain) {
- domain.exit();
+ throw e;
+
+ } else {
+ // In browsers, uncaught exceptions are not fatal.
+ // Re-throw them asynchronously to avoid slow-downs.
+ setTimeout(function() {
+ throw e;
+ }, 0);
  }
  }
 
- flushing = false;
+ if (domain) {
+ domain.exit();
+ }
  }
 
  nextTick = function (task) {
@@ -203,7 +211,13 @@ var nextTick =(function () {
  setTimeout(flush, 0);
  };
  }
-
+ nextTick.runAfter = function(task){
+ laterQueue.push(task);
+ if (!flushing) {
+ flushing = true;
+ requestTick();
+ }
+ };
  return nextTick;
 })();
 
@@ -997,6 +1011,7 @@ Promise.prototype.isRejected = function () {
 // shimmed environments, this would naturally be a `Set`.
 var unhandledReasons = [];
 var unhandledRejections = [];
+var reportedUnhandledRejections = [];
 var trackUnhandledRejections = true;
 
 function resetUnhandledRejections() {
@@ -1012,6 +1027,14 @@ function trackRejection(promise, reason) {
  if (!trackUnhandledRejections) {
  return;
  }
+ if(typeof process === "object" && typeof process.emit === "function"){
+ Q.nextTick.runAfter(function(){
+ if(array_indexOf(unhandledRejections, promise) !== -1){
+ process.emit("unhandledRejection", reason, promise);
+ reportedUnhandledRejections.push(promise);
+ }
+ });
+ }
 
  unhandledRejections.push(promise);
  if (reason && typeof reason.stack !== "undefined") {
@@ -1028,6 +1051,16 @@ function untrackRejection(promise) {
 
  var at = array_indexOf(unhandledRejections, promise);
  if (at !== -1) {
+ if(typeof process === "object" && typeof process.emit === "function"){
+ Q.nextTick.runAfter(function(){
+ var atReport = array_indexOf(reportedUnhandledRejections, promise);
+ if(atReport !== -1) {
+ process.emit("rejectionHandled", unhandledReasons[at], promise);
+ reportedUnhandledRejections.splice(atReport, 1);
+ }
+
+ });
+ }
  unhandledRejections.splice(at, 1);
  unhandledReasons.splice(at, 1);
  }