Sample task manager to handle recursion with trampoline

taskManager.js

  /**
   * Task manager to handle queuing up async tasks in an optimal manner
   */
  var TaskManager = {
    _asyncQueue: [],
    asyncTask: function(task) {
      if (TaskManager._asyncQueue.push(task) === 1) {
        async(TaskManager.taskRunner(TaskManager._asyncQueue));
      }
    },
    asyncQueue: function(queue) {
      if (queue.length === 1) {
        TaskManager.asyncTask(queue[0]);
      }
      else {
        TaskManager.asyncTask(TaskManager.taskRunner(queue));
      }
    },
    taskRunner: function(queue) {
      return function runTasks() {
        var task;
        while ((task = queue[0])) {
          TaskManager._runTask(task);
          queue.shift();
        }
      };
    },
    _runTask: function(task) {
      try {
        task();
      }
      catch(ex) {
        printDebug(ex);
      }
    }
  };

  function printDebug(ex) {
    if (Factory.debug) {
      console.error(ex);
      if (ex && ex.stack) {
        console.log(ex.stack);
      }
    }
  }

Task manager used in spromise to manage recursion as a sudo trampoline implementation. Here are part of the code that use the task manager

  /**
   * Figure out if the promise is pending/resolved/rejected and do the appropriate
   * action with the callback based on that.
   */
  StateManager.prototype.enqueue = function (state, cb) {
    if (!this.state) {
      (this.queue || (this.queue = [])).push(TaskAction);
    }
    else {
      // If the promise has already been resolved and its queue has been processed, then
      // we need to schedule the new task for processing ASAP by putting in the asyncQueue
      TaskManager.asyncTask(TaskAction);
    }

    var stateManager = this;
    function TaskAction() {
      if (stateManager.state === state || states.always === state) {
        cb.apply(stateManager.context, stateManager.value);
      }
      else if (states.notify === state) {
        cb.call(stateManager.context, stateManager.state, stateManager.value);
      }
    }
  };

  /**
   * Transitions the state of the promise from pending to either resolved or
   * rejected.  If the promise has already been resolved or rejected, then
   * this is a noop.
   */
  StateManager.prototype.transition = function (state, value, context) {
    if (this.state) {
      return;
    }

    this.state   = state;
    this.context = context;
    this.value   = value;

    var queue = this.queue;
    if (queue) {
      this.queue = null;
      TaskManager.asyncQueue(queue);
    }
  };

Miguel,
Just curious, does TaskAction need to be constructor function?

@vnadoda Not at all. It can also be function expressions. In my particular example it is a function declaration so that I can define it at the bottom of the containing method to make the code a bit cleaner for me.