primereact 9.0.0-beta.1 → 9.0.0

package/hooks/hooks.cjs.js

@@ -6,25 +6,80 @@ var React = require('react');
 var utils = require('primereact/utils');
 
 function _interopNamespace(e) {
-    if (e && e.__esModule) return e;
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
         });
-    }
-    n["default"] = e;
-    return Object.freeze(n);
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
 }
 
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+function _iterableToArrayLimit(arr, i) {
+  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
+  if (null != _i) {
+    var _s,
+      _e,
+      _x,
+      _r,
+      _arr = [],
+      _n = !0,
+      _d = !1;
+    try {
+      if (_x = (_i = _i.call(arr)).next, 0 === i) {
+        if (Object(_i) !== _i) return;
+        _n = !1;
+      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return;
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+
 var usePrevious = function usePrevious(newValue) {
   var ref = React__namespace.useRef(undefined);
   React__namespace.useEffect(function () {
@@ -33,25 +88,6 @@ var usePrevious = function usePrevious(newValue) {
   return ref.current;
 };
 
-/* eslint-disable */
-var useMountEffect = function useMountEffect(fn) {
-  return React__namespace.useEffect(fn, []);
-};
-/* eslint-enable */
-
-/* eslint-disable */
-var useUpdateEffect = function useUpdateEffect(fn, deps) {
-  var mounted = React__namespace.useRef(false);
-  return React__namespace.useEffect(function () {
-    if (!mounted.current) {
-      mounted.current = true;
-      return;
-    }
-    return fn && fn();
-  }, deps);
-};
-/* eslint-enable */
-
 /* eslint-disable */
 var useUnmountEffect = function useUnmountEffect(fn) {
   return React__namespace.useEffect(function () {
@@ -112,63 +148,499 @@ var useEventListener = function useEventListener(_ref) {
 };
 /* eslint-enable */
 
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return arr;
-}
+var useClickOutside = function useClickOutside(ref, callback) {
+  var isOutsideClicked = function isOutsideClicked(event) {
+    if (!ref.current || ref.current.contains(event.target)) {
+      return;
+    }
+    callback(event);
+  };
+  var _useEventListener = useEventListener({
+      type: 'mousedown',
+      listener: isOutsideClicked
+    }),
+    _useEventListener2 = _slicedToArray(_useEventListener, 2),
+    bindMouseDownListener = _useEventListener2[0],
+    unbindMouseDownListener = _useEventListener2[1];
+  var _useEventListener3 = useEventListener({
+      type: 'touchstart',
+      listener: isOutsideClicked
+    }),
+    _useEventListener4 = _slicedToArray(_useEventListener3, 2),
+    bindTouchStartListener = _useEventListener4[0],
+    unbindTouchStartListener = _useEventListener4[1];
+  React__namespace.useEffect(function () {
+    if (!ref.current) {
+      return;
+    }
+    bindMouseDownListener();
+    bindTouchStartListener();
+    return function () {
+      unbindMouseDownListener();
+      unbindTouchStartListener();
+    };
+  });
+  return [ref, callback];
+};
 
-function _iterableToArrayLimit(arr, i) {
-  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
-  if (null != _i) {
-    var _s,
-      _e,
-      _x,
-      _r,
-      _arr = [],
-      _n = !0,
-      _d = !1;
-    try {
-      if (_x = (_i = _i.call(arr)).next, 0 === i) {
-        if (Object(_i) !== _i) return;
-        _n = !1;
-      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0) {
-        ;
-      }
-    } catch (err) {
-      _d = !0, _e = err;
-    } finally {
-      try {
-        if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return;
-      } finally {
-        if (_d) throw _e;
-      }
+var useCounter = function useCounter() {
+  var initialValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+    step: 1
+  };
+  var _React$useState = React__namespace.useState(initialValue),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    count = _React$useState2[0],
+    setCount = _React$useState2[1];
+  var increment = function increment() {
+    if (options.max && count >= options.max) {
+      return;
     }
-    return _arr;
-  }
+    setCount(count + options.step);
+  };
+  var decrement = function decrement() {
+    if (options.min || options.min === 0 && count <= options.min) {
+      return null;
+    }
+    setCount(count - options.step);
+  };
+  var reset = function reset() {
+    setCount(0);
+  };
+  return {
+    count: count,
+    increment: increment,
+    decrement: decrement,
+    reset: reset
+  };
+};
+
+/* eslint-disable */
+var useTimeout = function useTimeout(fn) {
+  var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var when = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  var timeout = React__namespace.useRef(null);
+  var savedCallback = React__namespace.useRef(null);
+  var clear = React__namespace.useCallback(function () {
+    return clearTimeout(timeout.current);
+  }, [timeout.current]);
+  React__namespace.useEffect(function () {
+    savedCallback.current = fn;
+  });
+  React__namespace.useEffect(function () {
+    function callback() {
+      savedCallback.current();
+    }
+    if (when) {
+      timeout.current = setTimeout(callback, delay);
+      return clear;
+    } else {
+      clear();
+    }
+  }, [delay, when]);
+  useUnmountEffect(function () {
+    clear();
+  });
+  return [clear];
+};
+/* eslint-enable */
+
+var useDebounce = function useDebounce(initialValue, delay) {
+  var _React$useState = React__namespace.useState(initialValue),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    inputValue = _React$useState2[0],
+    setInputValue = _React$useState2[1];
+  var _React$useState3 = React__namespace.useState(initialValue),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    debouncedValue = _React$useState4[0],
+    setDebouncedValue = _React$useState4[1];
+  useTimeout(function () {
+    setDebouncedValue(inputValue);
+  }, delay, inputValue !== debouncedValue);
+  return [inputValue, debouncedValue, setInputValue];
+};
+
+var TYPE_MAP = {
+  ico: 'image/x-icon',
+  png: 'image/png',
+  svg: 'image/svg+xml',
+  gif: 'image/gif'
+};
+var useFavicon = function useFavicon() {
+  var newIcon = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  var rel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'shortcut icon';
+  React__namespace.useLayoutEffect(function () {
+    if (newIcon) {
+      var linkElements = document.querySelectorAll("link[rel*='icon']");
+      linkElements.forEach(function (linkEl) {
+        document.head.removeChild(linkEl);
+      });
+      var link = document.createElement('link');
+      link.setAttribute('type', TYPE_MAP[newIcon.split('.').pop()]);
+      link.setAttribute('rel', rel);
+      link.setAttribute('href', newIcon);
+      document.head.appendChild(link);
+    }
+  }, [newIcon, rel]);
+};
+
+var useIntersectionObserver = function useIntersectionObserver(ref) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var _React$useState = React__namespace.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    isElementVisible = _React$useState2[0],
+    setIsElementVisible = _React$useState2[1];
+  React__namespace.useEffect(function () {
+    if (!ref.current) return;
+    var observer = new IntersectionObserver(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 1),
+        entry = _ref2[0];
+      setIsElementVisible(entry.isIntersecting);
+    }, options);
+    observer.observe(ref.current);
+    return function () {
+      observer.disconnect();
+    };
+  }, [options, ref]);
+  return isElementVisible;
+};
+
+/* eslint-disable */
+var useInterval = function useInterval(fn) {
+  var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var when = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  var timeout = React__namespace.useRef(null);
+  var savedCallback = React__namespace.useRef(null);
+  var clear = React__namespace.useCallback(function () {
+    return clearInterval(timeout.current);
+  }, [timeout.current]);
+  React__namespace.useEffect(function () {
+    savedCallback.current = fn;
+  });
+  React__namespace.useEffect(function () {
+    function callback() {
+      savedCallback.current();
+    }
+    if (when) {
+      timeout.current = setInterval(callback, delay);
+      return clear;
+    } else {
+      clear();
+    }
+  }, [delay, when]);
+  useUnmountEffect(function () {
+    clear();
+  });
+  return [clear];
+};
+/* eslint-enable */
+
+/* eslint-disable */
+var useMountEffect = function useMountEffect(fn) {
+  return React__namespace.useEffect(fn, []);
+};
+/* eslint-enable */
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
 }
 
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) {
-    arr2[i] = arr[i];
+function _toPrimitive(input, hint) {
+  if (_typeof(input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
   }
-  return arr2;
+  return (hint === "string" ? String : Number)(input);
 }
 
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
 }
 
-function _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
 }
 
-function _slicedToArray(arr, i) {
-  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var useMouse = function useMouse() {
+  var _React$useState = React__namespace.useState({
+      x: 0,
+      y: 0
+    }),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    position = _React$useState2[0],
+    setPosition = _React$useState2[1];
+  var ref = React__namespace.useRef(null);
+  var handleMouseMove = React__namespace.useCallback(function (event) {
+    var x, y;
+    if (ref.current) {
+      var rect = event.currentTarget.getBoundingClientRect();
+      x = event.pageX - rect.left - (window.pageXOffset || window.scrollX);
+      y = event.pageY - rect.top - (window.pageYOffset || window.scrollY);
+    } else {
+      x = event.clientX;
+      y = event.clientY;
+    }
+    setPosition({
+      x: Math.max(0, Math.round(x)),
+      y: Math.max(0, Math.round(y))
+    });
+  }, []);
+  var _useEventListener = useEventListener({
+      target: ref,
+      type: 'mousemove',
+      listener: handleMouseMove
+    }),
+    _useEventListener2 = _slicedToArray(_useEventListener, 2),
+    bindMouseMoveEventListener = _useEventListener2[0],
+    unbindMouseMoveEventListener = _useEventListener2[1];
+  var _useEventListener3 = useEventListener({
+      type: 'mousemove',
+      listener: handleMouseMove
+    }),
+    _useEventListener4 = _slicedToArray(_useEventListener3, 2),
+    bindDocumentMoveEventListener = _useEventListener4[0],
+    unbindDocumentMoveEventListener = _useEventListener4[1];
+  var reset = function reset() {
+    return setPosition({
+      x: 0,
+      y: 0
+    });
+  };
+  React__namespace.useEffect(function () {
+    bindMouseMoveEventListener();
+    if (!ref.current) {
+      bindDocumentMoveEventListener();
+    }
+    return function () {
+      unbindMouseMoveEventListener();
+
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      if (!ref.current) {
+        unbindDocumentMoveEventListener();
+      }
+    };
+  }, [bindDocumentMoveEventListener, bindMouseMoveEventListener, unbindDocumentMoveEventListener, unbindMouseMoveEventListener]);
+  return _objectSpread$1(_objectSpread$1({
+    ref: ref
+  }, position), {}, {
+    reset: reset
+  });
+};
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function useMove(_ref) {
+  var _ref$mode = _ref.mode,
+    mode = _ref$mode === void 0 ? 'both' : _ref$mode,
+    _ref$initialValue = _ref.initialValue,
+    initialValue = _ref$initialValue === void 0 ? {
+      x: 0,
+      y: 0
+    } : _ref$initialValue;
+  var _React$useState = React__namespace.useState(initialValue),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    positions = _React$useState2[0],
+    setPositions = _React$useState2[1];
+  var _React$useState3 = React__namespace.useState(false),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    active = _React$useState4[0],
+    setActive = _React$useState4[1];
+  var isMounted = React__namespace.useRef(false);
+  var isSliding = React__namespace.useRef(false);
+  var ref = React__namespace.useRef(null);
+  var onMouseMove = function onMouseMove(event) {
+    return updateMousePosition({
+      x: event.clientX,
+      y: event.clientY
+    });
+  };
+  var handlePositionChange = function handlePositionChange(_ref2) {
+    var clampedX = _ref2.clampedX,
+      clampedY = _ref2.clampedY;
+    if (mode === 'vertical') {
+      setPositions({
+        y: 1 - clampedY
+      });
+    } else if (mode === 'horizontal') {
+      setPositions({
+        x: clampedX
+      });
+    } else if (mode === 'both') {
+      setPositions({
+        x: clampedX,
+        y: clampedY
+      });
+    }
+  };
+  var onMouseDown = function onMouseDown(event) {
+    startScrubbing();
+    event.preventDefault();
+    onMouseMove(event);
+  };
+  var stopScrubbing = function stopScrubbing() {
+    if (isSliding.current && isMounted.current) {
+      isSliding.current = false;
+      setActive(false);
+      unbindListeners();
+    }
+  };
+  var onTouchMove = function onTouchMove(event) {
+    if (event.cancelable) {
+      event.preventDefault();
+    }
+    updateMousePosition({
+      x: event.changedTouches[0].clientX,
+      y: event.changedTouches[0].clientY
+    });
+  };
+  var onTouchStart = function onTouchStart(event) {
+    if (event.cancelable) {
+      event.preventDefault();
+    }
+    startScrubbing();
+    onTouchMove(event);
+  };
+  var _useEventListener = useEventListener({
+      type: 'mousemove',
+      listener: onMouseMove
+    }),
+    _useEventListener2 = _slicedToArray(_useEventListener, 2),
+    bindDocumentMouseMoveListener = _useEventListener2[0],
+    unbindDocumentMouseMoveListener = _useEventListener2[1];
+  var _useEventListener3 = useEventListener({
+      type: 'mouseup',
+      listener: stopScrubbing
+    }),
+    _useEventListener4 = _slicedToArray(_useEventListener3, 2),
+    bindDocumentMouseUpListener = _useEventListener4[0],
+    unbindDocumentMouseUpListener = _useEventListener4[1];
+  var _useEventListener5 = useEventListener({
+      type: 'touchmove',
+      listener: onTouchMove
+    }),
+    _useEventListener6 = _slicedToArray(_useEventListener5, 2),
+    bindDocumentTouchMoveListener = _useEventListener6[0],
+    unbindDocumentTouchMoveListener = _useEventListener6[1];
+  var _useEventListener7 = useEventListener({
+      type: 'touchend',
+      listener: stopScrubbing
+    }),
+    _useEventListener8 = _slicedToArray(_useEventListener7, 2),
+    bindDocumentTouchEndListener = _useEventListener8[0],
+    unbindDocumentTouchEndListener = _useEventListener8[1];
+  var _useEventListener9 = useEventListener({
+      target: ref,
+      type: 'mousedown',
+      listener: onMouseDown
+    }),
+    _useEventListener10 = _slicedToArray(_useEventListener9, 2),
+    bindMouseDownListener = _useEventListener10[0],
+    unbindMouseDownListener = _useEventListener10[1];
+  var _useEventListener11 = useEventListener({
+      target: ref,
+      type: 'touchstart',
+      listener: onTouchStart,
+      options: {
+        passive: false
+      }
+    }),
+    _useEventListener12 = _slicedToArray(_useEventListener11, 2),
+    bindTouchStartListener = _useEventListener12[0],
+    unbindTouchStartListener = _useEventListener12[1];
+  var clamp = function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+  };
+  var clampPositions = function clampPositions(_ref3) {
+    var x = _ref3.x,
+      y = _ref3.y;
+    return {
+      clampedX: clamp(x, 0, 1),
+      clampedY: clamp(y, 0, 1)
+    };
+  };
+  var bindListeners = function bindListeners() {
+    bindDocumentMouseMoveListener();
+    bindDocumentMouseUpListener();
+    bindDocumentTouchMoveListener();
+    bindDocumentTouchEndListener();
+  };
+  var unbindListeners = function unbindListeners() {
+    unbindDocumentMouseMoveListener();
+    unbindDocumentMouseUpListener();
+    unbindDocumentTouchMoveListener();
+    unbindDocumentTouchEndListener();
+  };
+  var reset = function reset() {
+    setPositions(initialValue);
+  };
+  React__namespace.useEffect(function () {
+    isMounted.current = true;
+  }, []);
+  var startScrubbing = function startScrubbing() {
+    if (!isSliding.current && isMounted.current) {
+      isSliding.current = true;
+      setActive(true);
+      bindListeners();
+    }
+  };
+  var updateMousePosition = function updateMousePosition(_ref4) {
+    var x = _ref4.x,
+      y = _ref4.y;
+    if (isSliding.current) {
+      var rect = ref.current.getBoundingClientRect();
+      var _clampPositions = clampPositions({
+          x: (x - rect.left) / rect.width,
+          y: (y - rect.top) / rect.height
+        }),
+        clampedX = _clampPositions.clampedX,
+        clampedY = _clampPositions.clampedY;
+      handlePositionChange({
+        clampedX: clampedX,
+        clampedY: clampedY
+      });
+    }
+  };
+  React__namespace.useEffect(function () {
+    if (ref.current) {
+      bindMouseDownListener();
+      bindTouchStartListener();
+    }
+    return function () {
+      if (ref.current) {
+        unbindMouseDownListener();
+        unbindTouchStartListener();
+      }
+    };
+  }, [bindMouseDownListener, bindTouchStartListener, positions, unbindMouseDownListener, unbindTouchStartListener]);
+  return _objectSpread(_objectSpread({
+    ref: ref
+  }, positions), {}, {
+    active: active,
+    reset: reset
+  });
 }
 
 /* eslint-disable */
@@ -319,36 +791,6 @@ var useOverlayListener = function useOverlayListener(_ref) {
 };
 /* eslint-enable */
 
-/* eslint-disable */
-var useInterval = function useInterval(fn) {
-  var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  var when = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-  var timeout = React__namespace.useRef(null);
-  var savedCallback = React__namespace.useRef(null);
-  var clear = React__namespace.useCallback(function () {
-    return clearInterval(timeout.current);
-  }, [timeout.current]);
-  React__namespace.useEffect(function () {
-    savedCallback.current = fn;
-  });
-  React__namespace.useEffect(function () {
-    function callback() {
-      savedCallback.current();
-    }
-    if (when) {
-      timeout.current = setInterval(callback, delay);
-      return clear;
-    } else {
-      clear();
-    }
-  }, [delay, when]);
-  useUnmountEffect(function () {
-    clear();
-  });
-  return [clear];
-};
-/* eslint-enable */
-
 /**
  * Hook to wrap around useState that stores the value in the browser local/session storage.
  *
@@ -378,18 +820,7 @@ var useStorage = function useStorage(initialValue, key) {
     _useEventListener2 = _slicedToArray(_useEventListener, 2),
     bindWindowStorageListener = _useEventListener2[0],
     unbindWindowStorageListener = _useEventListener2[1];
-  var _React$useState = React__namespace.useState(function () {
-      if (!storageAvailable) {
-        return initialValue;
-      }
-      try {
-        var item = storage === 'local' ? window.localStorage.getItem(key) : window.sessionStorage.getItem(key);
-        return item ? JSON.parse(item) : initialValue;
-      } catch (error) {
-        // If error also return initialValue
-        return initialValue;
-      }
-    }),
+  var _React$useState = React__namespace.useState(undefined),
     _React$useState2 = _slicedToArray(_React$useState, 2),
     storedValue = _React$useState2[0],
     setStoredValue = _React$useState2[1];
@@ -407,6 +838,16 @@ var useStorage = function useStorage(initialValue, key) {
     }
   };
   React__namespace.useEffect(function () {
+    if (!storageAvailable) {
+      setStoredValue(initialValue);
+    }
+    try {
+      var item = storage === 'local' ? window.localStorage.getItem(key) : window.sessionStorage.getItem(key);
+      setStoredValue(item ? JSON.parse(item) : initialValue);
+    } catch (error) {
+      // If error also return initialValue
+      setStoredValue(initialValue);
+    }
     bindWindowStorageListener();
     return function () {
       return unbindWindowStorageListener();
@@ -439,39 +880,29 @@ var useSessionStorage = function useSessionStorage(initialValue, key) {
 /* eslint-enable */
 
 /* eslint-disable */
-var useTimeout = function useTimeout(fn) {
-  var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  var when = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-  var timeout = React__namespace.useRef(null);
-  var savedCallback = React__namespace.useRef(null);
-  var clear = React__namespace.useCallback(function () {
-    return clearTimeout(timeout.current);
-  }, [timeout.current]);
-  React__namespace.useEffect(function () {
-    savedCallback.current = fn;
-  });
-  React__namespace.useEffect(function () {
-    function callback() {
-      savedCallback.current();
-    }
-    if (when) {
-      timeout.current = setTimeout(callback, delay);
-      return clear;
-    } else {
-      clear();
+var useUpdateEffect = function useUpdateEffect(fn, deps) {
+  var mounted = React__namespace.useRef(false);
+  return React__namespace.useEffect(function () {
+    if (!mounted.current) {
+      mounted.current = true;
+      return;
     }
-  }, [delay, when]);
-  useUnmountEffect(function () {
-    clear();
-  });
-  return [clear];
+    return fn && fn();
+  }, deps);
 };
 /* eslint-enable */
 
+exports.useClickOutside = useClickOutside;
+exports.useCounter = useCounter;
+exports.useDebounce = useDebounce;
 exports.useEventListener = useEventListener;
+exports.useFavicon = useFavicon;
+exports.useIntersectionObserver = useIntersectionObserver;
 exports.useInterval = useInterval;
 exports.useLocalStorage = useLocalStorage;
 exports.useMountEffect = useMountEffect;
+exports.useMouse = useMouse;
+exports.useMove = useMove;
 exports.useOverlayListener = useOverlayListener;
 exports.useOverlayScrollListener = useOverlayScrollListener;
 exports.usePrevious = usePrevious;