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

DNB Eufemia Design System UI Library

import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
import { isAsync } from './isAsync';
export function debounceAsync(debouncedFunction, wait = 500, opts = null) {
  return debounce(debouncedFunction, wait, _objectSpread(_objectSpread({}, opts), {}, {
    async: true
  }));
}
export 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 ? void 0 : _resolvePromise();
    customCancels.forEach(fn => {
      fn();
    });
  };
  const addCancelEvent = fn => {
    if (!customCancels.includes(fn)) {
      customCancels.push(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 ? void 0 : _resolvePromise2(recall);
        } catch (error) {
          var _rejectPromise;
          (_rejectPromise = rejectPromise) === null || _rejectPromise === void 0 ? 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 (isAsync(debouncedFunction)) {
    return asyncFunction;
  }
  return syncFunction;
}
//# sourceMappingURL=debounce.js.map