task-handler/dist/defer.js

Handle Javascript Timers like a boss! https://odo-network.github.io/task-handler/

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = createDeferQueue;

var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));

var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));

function buildDeferTimeoutHandler(timeout) {
  if ((typeof process === "undefined" ? "undefined" : (0, _typeof2.default)(process)) === 'object' && typeof process.nextTick === 'function') {
    var tickCancelID = 0;

    timeout.create = function cancellableNextTick(cb) {
      tickCancelID += 1;
      var id = tickCancelID;
      process.nextTick(function () {
        if (id === tickCancelID) {
          cb();
          tickCancelID = 0;
        }
      });
    };

    timeout.cancel = function cancelNextTick() {
      tickCancelID += 1;
    };
  } else if (typeof setImmediate === 'function') {
    timeout.create = setImmediate;
    timeout.cancel = clearImmediate;
  } else {
    timeout.create = setTimeout;
    timeout.cancel = clearTimeout;
  }

  Object.freeze(timeout);
}

function createDeferQueue(refs) {
  var queue = new Map();
  var i = 0;
  var timerID;
  var timeout = {
    create: undefined,
    cancel: undefined
  };

  function flush() {
    var flushQueue = new Map(queue);
    queue.clear();
    flushQueue.forEach(function (_ref) {
      var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
          ref = _ref2[0],
          cb = _ref2[1];

      refs.delete(ref.id);

      try {
        cb();
      } catch (err) {
        console.error('[task-handler] | ERROR | uncaughtError occurred in a defer flush callback', ref.id);
      }
    });
    return handler;
  }

  var handler = {
    clear: function clear() {
      if (timeout.cancel) {
        timeout.cancel(timerID);
      }

      queue.clear();
    },
    cancel: function cancel(deferID) {
      queue.delete(deferID);

      if (queue.size === 0) {
        handler.clear();
      }
    },
    add: function add(ref, cb) {
      i += 1;
      var deferID = i;

      if (queue.size === 0) {
        if (!timeout.create) {
          buildDeferTimeoutHandler(timeout);
        }

        if (timeout.create) {
          timerID = timeout.create(flush);
        } else {
          throw new Error('[ERROR] | task-handler | defer failed to create a defer handler.  Internal Error.');
        }
      }

      queue.set(deferID, [ref, cb]);
      return function () {
        return handler.cancel(deferID);
      };
    }
  };
  return handler;
}