js-hoverintent/build/umd/hoverintent.js

Hover intent in javascript

(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
typeof define === 'function' && define.amd ? define(factory) :
(global = global || self, global.HoverIntent = factory());
}(this, function () { 'use strict';

function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _defineProperties(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor = props[i];
    descriptor.enumerable = descriptor.enumerable || false;
    descriptor.configurable = true;
    if ("value" in descriptor) descriptor.writable = true;
    Object.defineProperty(target, descriptor.key, descriptor);
  }
}

function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  if (staticProps) _defineProperties(Constructor, staticProps);
  return Constructor;
}

function _slicedToArray(arr, i) {
  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
}

function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}

function _iterableToArrayLimit(arr, i) {
  var _arr = [];
  var _n = true;
  var _d = false;
  var _e = undefined;

  try {
    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
      _arr.push(_s.value);

      if (i && _arr.length === i) break;
    }
  } catch (err) {
    _d = true;
    _e = err;
  } finally {
    try {
      if (!_n && _i["return"] != null) _i["return"]();
    } finally {
      if (_d) throw _e;
    }
  }

  return _arr;
}

function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance");
}

var debounce = function debounce(callback, wait) {
  var timeout;

  var cancel = function cancel() {
    clearTimeout(timeout);
  };

  var debounced = function debounced() {
    cancel();

    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    timeout = setTimeout.apply(void 0, [callback, +wait].concat(args));
  };

  debounced.cancel = cancel;
  return debounced;
};

var intent = function intent(startDebounceEvent, cancelDebounceEvent, elements, callback, wait) {
  if (typeof callback !== 'function') {
    throw new TypeError('Expected a function');
  }

  var debouncer = debounce(callback, +wait);
  /**
   * Add startDebounceEvent listener to the given element via debouncer callback.
   *
   * @param {HTMLElement} elm A dom element.
   *
   * @returns {Function} A function to remove debouncer callback from startDebounceEvent listener.
   */

  var startDebouncer = function startDebouncer(elm) {
    elm.addEventListener(startDebounceEvent, debouncer);
    return function () {
      return elm.removeEventListener(startDebounceEvent, debouncer);
    };
  };
  /**
   * Add cancelDebounceEvent listener to the given element via debouncer.cancel callback.
   *
   * @param {HTMLElement} elm A dom element.
   *
   * @returns {Function} A function to remove debouncer.cancel callback from cancelDebounceEvent listener.
   */


  var cancelDebouncer = function cancelDebouncer(elm) {
    elm.addEventListener(cancelDebounceEvent, debouncer.cancel);
    return function () {
      return elm.removeEventListener(cancelDebounceEvent, debouncer.cancel);
    };
  };

  var removeEventListener = [];
  elements.forEach(function (elm) {
    removeEventListener.push([startDebouncer(elm), cancelDebouncer(elm)]);
  });

  var cancel = function cancel() {
    removeEventListener.forEach(function (_ref) {
      var _ref2 = _slicedToArray(_ref, 2),
          removeStart = _ref2[0],
          removeCancel = _ref2[1];

      removeStart();
      removeCancel();
    });
    debouncer.cancel();
  };

  return cancel;
};

var enter = function enter() {
  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
    args[_key2] = arguments[_key2];
  }

  return intent.apply(void 0, ['mouseenter', 'mouseleave'].concat(args));
};

var leave = function leave() {
  for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
    args[_key3] = arguments[_key3];
  }

  return intent.apply(void 0, ['mouseleave', 'mouseenter'].concat(args));
};

var HoverIntent =
/*#__PURE__*/
function () {
  function HoverIntent(selector, enterCallback, leaveCallback, options) {
    _classCallCheck(this, HoverIntent);

    var defaultOptions = {
      enterWait: 100,
      leaveWait: 100
    };
    this.selector = document.querySelectorAll(selector);
    this.options = Object.assign({}, defaultOptions, options);
    this.cancelEnter = enter(this.selector, enterCallback, this.options.enterWait);
    this.cancelLeave = leave(this.selector, leaveCallback, this.options.leaveWait);
  }

  _createClass(HoverIntent, [{
    key: "cancel",
    value: function cancel() {
      this.cancelEnter();
      this.cancelLeave();
    }
  }]);

  return HoverIntent;
}();

return HoverIntent;

}));