@dnb/eufemia/cjs/shared/helpers/debounce.js

DNB Eufemia Design System UI Library

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.debounce = debounce;
exports.debounceAsync = debounceAsync;
var _push = _interopRequireDefault(require("core-js-pure/stable/instance/push.js"));
var _isAsync = require("./isAsync.js");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
function debounceAsync(debouncedFunction, wait = 500, opts = null) {
  return debounce(debouncedFunction, wait, {
    ...opts,
    async: true
  });
}
function debounce(debouncedFunction, wait = 500, {
  immediate = false,
  instance = null,
  async = false
} = {}) {
  let timeout;
  let recall;
  let resolvePromise;
  let rejectPromise;
  let canceled = false;
  const customCancels = [];
  const cancel = () => {
    var _resolvePromise;
    canceled = true;
    clearTimeout(timeout);
    (_resolvePromise = resolvePromise) === null || _resolvePromise === void 0 || _resolvePromise();
    customCancels.forEach(fn => {
      fn();
    });
  };
  const addCancelEvent = fn => {
    if (!customCancels.includes(fn)) {
      (0, _push.default)(customCancels).call(customCancels, fn);
    }
    return () => {
      return canceled;
    };
  };
  function executedFunction(...args) {
    if (typeof recall === 'function') {
      recall();
    }
    canceled = false;
    const inst = instance || this || {};
    inst.cancel = cancel;
    inst.addCancelEvent = addCancelEvent;
    const later = callNow => {
      timeout = null;
      if (callNow || !immediate) {
        try {
          var _resolvePromise2;
          recall = debouncedFunction.apply(inst, args);
          (_resolvePromise2 = resolvePromise) === null || _resolvePromise2 === void 0 || _resolvePromise2(recall);
        } catch (error) {
          var _rejectPromise;
          (_rejectPromise = rejectPromise) === null || _rejectPromise === void 0 || _rejectPromise(error);
        }
      }
    };
    const callNow = immediate && !timeout;
    clearTimeout(timeout);
    timeout = setTimeout(later, wait);
    if (callNow) {
      later(true);
    }
    if (async) {
      return new Promise((resolve, reject) => {
        resolvePromise = resolve;
        rejectPromise = reject;
      });
    }
    return recall;
  }
  function syncFunction(...args) {
    return executedFunction(...args);
  }
  syncFunction.cancel = cancel;
  syncFunction.addCancelEvent = addCancelEvent;
  async function asyncFunction(...args) {
    return executedFunction(...args);
  }
  asyncFunction.cancel = cancel;
  asyncFunction.addCancelEvent = addCancelEvent;
  if ((0, _isAsync.isAsync)(debouncedFunction)) {
    return asyncFunction;
  }
  return syncFunction;
}
//# sourceMappingURL=debounce.js.map