async-wrappers/cjs/wait.js

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

"use strict";

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

var _pending = _interopRequireDefault(require("./pending"));

var _deferred = _interopRequireDefault(require("./deferred"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Resolves after a given delay, optionally with a value.
 *
 * If the delay is `0` the promises will resolve after the current
 * runtime event loop.
 *
 * @param delay The time in milliseconds before the value is returned.
 * @param func A function or value that will be returned after waiting.
 *
 * @returns A promise that resolves with the value/function result.
 * The promise has 2 extra functions defined:
 *  - `cancel` cancels the result and rejects the promise.
 *  - `stop` stops waiting and resolves the promised value.
 *
 * @category Wrapper
 */
const wait = (delay, func) => {
  const result = (0, _pending.default)();
  const execute = (0, _deferred.default)(() => {
    // Typescript doesn't accept the function type guard here
    // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
    // @ts-ignore
    result.complete(typeof func === 'function' ? func() : func);
  });
  execute.defer(delay);
  const promise = result.promise;

  promise.cancel = error => {
    execute.cancel();
    result.error(error ? error : new Error('Cancelled'));
  };

  promise.stop = () => {
    // execute has already finished
    if (execute.delay < 0) {
      return;
    } // call right away


    execute.defer(0);
  };

  return promise;
};

var _default = wait;
exports.default = _default;