react-kanca 1.2.0 → 1.3.1

package/dist/index.modern.js

@@ -40,19 +40,23 @@ var useWindowSize = function useWindowSize() {
   return size;
 };
 
-var useDebounce = function useDebounce(value, delay) {
-  var _useState = useState(''),
-    debounce = _useState[0],
-    setDebounce = _useState[1];
-  useEffect(function () {
+var useDebounce = function useDebounce() {
+  var _useState = useState(null),
+    debouncedValue = _useState[0],
+    setDebouncedValue = _useState[1];
+  var debounce = function debounce(value, delay) {
     var handler = setTimeout(function () {
-      setDebounce(value);
+      if (typeof value === 'function') {
+        value();
+      } else {
+        setDebouncedValue(value);
+      }
     }, delay);
     return function () {
       clearTimeout(handler);
     };
-  }, [value, delay]);
-  return debounce;
+  };
+  return [debouncedValue, debounce];
 };
 
 var usePrevious = function usePrevious(value) {
@@ -186,16 +190,16 @@ var useThrottle = function useThrottle(value, ms) {
   useEffect(function () {
     if (!timeout.current) {
       setState(value);
-      var timeoutCallback = function timeoutCallback() {
+      var _timeoutCallback = function timeoutCallback() {
         if (hasNextValue.current) {
           hasNextValue.current = false;
           setState(nextValue.current);
-          timeout.current = setTimeout(timeoutCallback, ms);
+          timeout.current = setTimeout(_timeoutCallback, ms);
         } else {
           timeout.current = undefined;
         }
       };
-      timeout.current = setTimeout(timeoutCallback, ms);
+      timeout.current = setTimeout(_timeoutCallback, ms);
     } else {
       nextValue.current = value;
       hasNextValue.current = true;
@@ -262,7 +266,7 @@ var useLocalStorage = function useLocalStorage(key, initialValue, options) {
   return [state, set, remove];
 };
 
-var useEqualObject = function useEqualObject(obj1, obj2) {
+var _useEqualObject = function useEqualObject(obj1, obj2) {
   if (obj1 === obj2) return true;
   if (typeof obj1 !== 'object' || typeof obj2 !== 'object' || obj1 === null || obj2 === null) return false;
   var keys1 = Object.keys(obj1);
@@ -270,7 +274,7 @@ var useEqualObject = function useEqualObject(obj1, obj2) {
   if (keys1.length !== keys2.length) return false;
   for (var _i = 0, _keys = keys1; _i < _keys.length; _i++) {
     var key = _keys[_i];
-    if (!keys2.includes(key) || !useEqualObject(obj1[key], obj2[key])) return false;
+    if (!keys2.includes(key) || !_useEqualObject(obj1[key], obj2[key])) return false;
   }
   return true;
 };
@@ -293,18 +297,13 @@ var useCookie = function useCookie(cookieName) {
 };
 
 function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
     }
-    return target;
-  };
-  return _extends.apply(this, arguments);
+    return n;
+  }, _extends.apply(null, arguments);
 }
 
 var useGeolocation = function useGeolocation(options) {
@@ -415,11 +414,8 @@ var useBatteryInfo = function useBatteryInfo() {
     isCharging = _useState2[0],
     setIsCharging = _useState2[1];
   var _useState3 = useState(null),
-    chargingTime = _useState3[0],
-    setChargingTime = _useState3[1];
-  var _useState4 = useState(null),
-    dischargingTime = _useState4[0],
-    setDischargingTime = _useState4[1];
+    dischargingTime = _useState3[0],
+    setDischargingTime = _useState3[1];
   useEffect(function () {
     var getBatteryInfo = function getBatteryInfo() {
       try {
@@ -428,7 +424,6 @@ var useBatteryInfo = function useBatteryInfo() {
             var updateBatteryInfo = function updateBatteryInfo() {
               setBatteryLevel(Math.round(battery.level * 100));
               setIsCharging(battery.charging);
-              setChargingTime(battery.chargingTime);
               setDischargingTime(battery.dischargingTime);
             };
             updateBatteryInfo();
@@ -456,7 +451,6 @@ var useBatteryInfo = function useBatteryInfo() {
   return {
     batteryLevel: batteryLevel,
     isCharging: isCharging,
-    chargingTime: chargingTime,
     dischargingTime: dischargingTime
   };
 };
@@ -654,5 +648,200 @@ var useForceUpdate = function useForceUpdate() {
   return update;
 };
 
-export { useBatteryInfo, useBeforeUnload, useClickOutside, useColorScheme, useConnection, useCookie, useCopyToClipboard, useDebounce, useEqualObject, useForceUpdate, useFullScreen, useGeolocation, useHover, useIsFirstRender, useLocalStorage, useMedia, useMousePageLeave, usePageLeave, usePageVisible, usePreferredLanguage, usePrevious, useScrollLock, useScrolling, useSessionStorage, useThrottle, useWindowSize };
+var useInterval = function useInterval(callback, delay) {
+  var savedCallback = useRef(function () {});
+  useEffect(function () {
+    savedCallback.current = callback;
+  });
+  useEffect(function () {
+    if (delay !== null) {
+      var interval = setInterval(function () {
+        return savedCallback.current();
+      }, delay || 0);
+      return function () {
+        return clearInterval(interval);
+      };
+    }
+    return undefined;
+  }, [delay]);
+};
+
+var useIntersectionObserver = function useIntersectionObserver(targetRef, options) {
+  var _useState = useState(false),
+    isIntersecting = _useState[0],
+    setIsIntersecting = _useState[1];
+  useEffect(function () {
+    var observer = new IntersectionObserver(function (_ref) {
+      var entry = _ref[0];
+      setIsIntersecting(entry.isIntersecting);
+    }, options);
+    if (targetRef.current) {
+      observer.observe(targetRef.current);
+    }
+    return function () {
+      if (targetRef.current) {
+        observer.unobserve(targetRef.current);
+      }
+    };
+  }, [targetRef, options]);
+  return isIntersecting;
+};
+
+var useMobileLandscape = function useMobileLandscape() {
+  var _useState = useState(false),
+    isLandscape = _useState[0],
+    setIsLandscape = _useState[1];
+  var _useState2 = useState(false),
+    isMobile = _useState2[0],
+    setIsMobile = _useState2[1];
+  var _useState3 = useState(false),
+    isMobileLandscape = _useState3[0],
+    setIsMobileLandscape = _useState3[1];
+  var handleResize = function handleResize() {
+    var landscape = window.innerWidth > window.innerHeight;
+    var mobile = window.innerWidth <= 996;
+    setIsLandscape(landscape);
+    setIsMobile(mobile);
+    setIsMobileLandscape(landscape && mobile);
+  };
+  useEffect(function () {
+    handleResize();
+    window.addEventListener('resize', handleResize);
+    return function () {
+      window.removeEventListener('resize', handleResize);
+    };
+  }, []);
+  return {
+    isMobileLandscape: isMobileLandscape,
+    isLandscape: isLandscape,
+    isMobile: isMobile
+  };
+};
+
+var useOnlineStatus = function useOnlineStatus() {
+  var _useState = useState(navigator.onLine),
+    isOnline = _useState[0],
+    setIsOnline = _useState[1];
+  useEffect(function () {
+    var handleOnline = function handleOnline() {
+      return setIsOnline(true);
+    };
+    var handleOffline = function handleOffline() {
+      return setIsOnline(false);
+    };
+    window.addEventListener('online', handleOnline);
+    window.addEventListener('offline', handleOffline);
+    return function () {
+      window.removeEventListener('online', handleOnline);
+      window.removeEventListener('offline', handleOffline);
+    };
+  }, []);
+  return isOnline;
+};
+
+var useScrollToElement = function useScrollToElement() {
+  var scrollToElement = useCallback(function (selectorOrRef, options) {
+    if (options === void 0) {
+      options = {};
+    }
+    var element;
+    if (typeof selectorOrRef === 'string') {
+      element = document.querySelector(selectorOrRef);
+    } else if (selectorOrRef.current) {
+      element = selectorOrRef.current;
+    }
+    if (element) {
+      element.scrollIntoView(_extends({
+        behavior: 'smooth'
+      }, options));
+    }
+  }, []);
+  return scrollToElement;
+};
+
+var useStateValidator = function useStateValidator(state, validator, initialState) {
+  if (initialState === void 0) {
+    initialState = [undefined];
+  }
+  var validatorInner = useRef(validator);
+  var stateInner = useRef(state);
+  validatorInner.current = validator;
+  stateInner.current = state;
+  var _useState = useState(initialState),
+    validity = _useState[0],
+    setValidity = _useState[1];
+  var validate = useCallback(function () {
+    if (validatorInner.current.length >= 2) {
+      validatorInner.current(stateInner.current, setValidity);
+    } else {
+      setValidity(validatorInner.current(stateInner.current));
+    }
+  }, [setValidity]);
+  useEffect(function () {
+    validate();
+  }, [state]);
+  return [validity, validate];
+};
+
+var useMultiStateValidator = function useMultiStateValidator(states, validator, initialValidity) {
+  if (initialValidity === void 0) {
+    initialValidity = [undefined];
+  }
+  if (typeof states !== 'object') {
+    throw new Error("state'in bir nesne ya da dizi olması beklenirken -> " + typeof states);
+  }
+  var validatorInner = useRef(validator);
+  var statesInner = useRef(states);
+  validatorInner.current = validator;
+  statesInner.current = states;
+  var _useState = useState(initialValidity),
+    validity = _useState[0],
+    setValidity = _useState[1];
+  var validate = useCallback(function () {
+    if (validatorInner.current.length >= 2) {
+      validatorInner.current(statesInner.current, setValidity);
+    } else {
+      setValidity(validatorInner.current(statesInner.current));
+    }
+  }, [setValidity]);
+  useEffect(function () {
+    validate();
+  }, Object.values(states));
+  return [validity, validate];
+};
+
+var useWindowScroll = function useWindowScroll() {
+  var _useState = useState(function () {
+      return {
+        x: isBrowser ? window.pageXOffset : 0,
+        y: isBrowser ? window.pageYOffset : 0
+      };
+    }),
+    state = _useState[0],
+    setState = _useState[1];
+  useEffect(function () {
+    var handler = function handler() {
+      setState(function (state) {
+        var _window = window,
+          pageXOffset = _window.pageXOffset,
+          pageYOffset = _window.pageYOffset;
+        return state.x !== pageXOffset || state.y !== pageYOffset ? {
+          x: pageXOffset,
+          y: pageYOffset
+        } : state;
+      });
+    };
+    handler();
+    on(window, 'scroll', handler, {
+      capture: false,
+      passive: true
+    });
+    return function () {
+      off(window, 'scroll', handler);
+    };
+  }, []);
+  return state;
+};
+
+export { useBatteryInfo, useBeforeUnload, useClickOutside, useColorScheme, useConnection, useCookie, useCopyToClipboard, useDebounce, _useEqualObject as useEqualObject, useForceUpdate, useFullScreen, useGeolocation, useHover, useIntersectionObserver, useInterval, useIsFirstRender, useLocalStorage, useMedia, useMobileLandscape, useMousePageLeave, useMultiStateValidator, useOnlineStatus, usePageLeave, usePageVisible, usePreferredLanguage, usePrevious, useScrollLock, useScrollToElement, useScrolling, useSessionStorage, useStateValidator, useThrottle, useWindowScroll, useWindowSize };
 //# sourceMappingURL=index.modern.js.map