async-wrappers/cjs/deferred.js

A set of wrapper functions to perform debouncing, throttling, retrying etc.

"use strict";

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

/**
 * @internal
 */

/**
 * @internal
 */
const deferred = callback => {
  let handle = null;
  let clear = clearTimeout;

  const call = () => {
    deferred.called = Date.now();
    deferred.delay = -1;
    callback();
  };

  const defer = delay => {
    delay = delay < 0 ? 0 : delay;
    deferred.deferred = Date.now();

    if (delay === 0 && deferred.delay === 0) {
      // if a delay is 0 it will happen on next execution.
      // so delaying a current delay of 0 should have no effect.
      // This is necessary here as a setTimeout implementation could
      // keep deferring execution, due to it's resolution issues.
      return;
    } // clear existing


    if (handle !== null) clear(handle);
    deferred.delay = delay;
    const useTimeout = !setImmediate || delay ? true : false;
    clear = useTimeout ? clearTimeout : clearImmediate;

    if (useTimeout) {
      handle = setTimeout(call, delay || 0);
    } else {
      handle = setImmediate(call);
    }
  };

  const cancel = () => {
    if (handle !== null) {
      deferred.delay = -1;
      clear(handle);
      handle = null;
    }
  };

  const deferred = {
    called: 0,
    deferred: 0,
    delay: -1,
    defer,
    cancel
  };
  return deferred;
};

var _default = deferred;
exports.default = _default;