index.js

'use strict'

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

var _react = _interopRequireDefault(require('react'))

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

function _typeof(obj) {
  '@babel/helpers - typeof'
  if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') {
    _typeof = function _typeof(obj) {
      return typeof obj
    }
  } else {
    _typeof = function _typeof(obj) {
      return obj &&
        typeof Symbol === 'function' &&
        obj.constructor === Symbol &&
        obj !== Symbol.prototype
        ? 'symbol'
        : typeof obj
    }
  }
  return _typeof(obj)
}

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 _inherits(subClass, superClass) {
  if (typeof superClass !== 'function' && superClass !== null) {
    throw new TypeError('Super expression must either be null or a function')
  }
  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: { value: subClass, writable: true, configurable: true }
  })
  if (superClass) _setPrototypeOf(subClass, superClass)
}

function _setPrototypeOf(o, p) {
  _setPrototypeOf =
    Object.setPrototypeOf ||
    function _setPrototypeOf(o, p) {
      o.__proto__ = p
      return o
    }
  return _setPrototypeOf(o, p)
}

function _createSuper(Derived) {
  var hasNativeReflectConstruct = _isNativeReflectConstruct()
  return function _createSuperInternal() {
    var Super = _getPrototypeOf(Derived)
    var result
    if (hasNativeReflectConstruct) {
      var NewTarget = _getPrototypeOf(this).constructor
      result = Reflect.construct(Super, arguments, NewTarget)
    } else {
      result = Super.apply(this, arguments)
    }
    return _possibleConstructorReturn(this, result)
  }
}

function _possibleConstructorReturn(self, call) {
  if (call && (_typeof(call) === 'object' || typeof call === 'function')) {
    return call
  }
  return _assertThisInitialized(self)
}

function _assertThisInitialized(self) {
  if (self === void 0) {
    throw new ReferenceError(
      "this hasn't been initialised - super() hasn't been called"
    )
  }
  return self
}

function _isNativeReflectConstruct() {
  if (typeof Reflect === 'undefined' || !Reflect.construct) return false
  if (Reflect.construct.sham) return false
  if (typeof Proxy === 'function') return true
  try {
    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}))
    return true
  } catch (e) {
    return false
  }
}

function _getPrototypeOf(o) {
  _getPrototypeOf = Object.setPrototypeOf
    ? Object.getPrototypeOf
    : function _getPrototypeOf(o) {
        return o.__proto__ || Object.getPrototypeOf(o)
      }
  return _getPrototypeOf(o)
}

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    })
  } else {
    obj[key] = value
  }
  return obj
}

var _default = /* #__PURE__ */ (function (_React$Component) {
  _inherits(_default, _React$Component)

  var _super = _createSuper(_default)

  function _default(props) {
    var _this

    _classCallCheck(this, _default)

    _this = _super.call(this, props)

    _defineProperty(_assertThisInitialized(_this), 'timerIds', void 0)

    _this.onMouseEnter = _this.onMouseEnter.bind(_assertThisInitialized(_this))
    _this.onMouseLeave = _this.onMouseLeave.bind(_assertThisInitialized(_this))
    _this.timerIds = []
    return _this
  }

  _createClass(_default, [
    {
      key: 'onMouseEnter',
      value: function onMouseEnter() {
        this.props.onMouseEnter()
        this.setIsHover()
      }
    },
    {
      key: 'onMouseLeave',
      value: function onMouseLeave() {
        this.props.onMouseLeave()
        this.clearTimers()
      }
    },
    {
      key: 'setIsHover',
      value: function setIsHover() {
        var _this2 = this

        this.clearTimers()
        var hoverScheduleId = setTimeout(function () {
          _this2.props.action()
        }, this.props.timer)
        this.timerIds.push(hoverScheduleId)
      }
    },
    {
      key: 'clearTimers',
      value: function clearTimers() {
        var ids = this.timerIds

        while (ids.length) {
          clearTimeout(ids.pop())
        }
      }
    },
    {
      key: 'render',
      value: function render() {
        var _this$props = this.props
        var children = _this$props.children
        var className = _this$props.className
        return /* #__PURE__ */ _react.default.createElement(
          'div',
          {
            className: className,
            onMouseEnter: this.onMouseEnter,
            onMouseLeave: this.onMouseLeave
          },
          children
        )
      }
    }
  ])

  return _default
})(_react.default.Component)

exports.default = _default

_defineProperty(_default, 'displayName', 'HoverComponent')

_defineProperty(_default, 'defaultProps', {
  onMouseEnter: function onMouseEnter() {},
  onMouseLeave: function onMouseLeave() {}
})