react-kanca 1.1.0 → 1.3.0

package/README.md

@@ -20,26 +20,40 @@ npm install --save react-kanca
 
 ```jsx
 import {
-  useWindowSize,
-  usePageVisible,
-  useDebounce,
-  usePrevious,
-  useHover,
-  useScrolling,
+  useBatteryInfo,
   useBeforeUnload,
-  useThrottle,
-  useLocalStorage,
-  useEqualObject,
+  useClickOutside,
+  useColorScheme,
+  useConnection,
   useCookie,
+  useCopyToClipboard,
+  useDebounce,
+  useEqualObject,
+  useForceUpdate,
+  useFullScreen,
   useGeolocation,
+  useHover,
+  useIntersectionObserver,
+  useInterval,
   useIsFirstRender,
-  useConnection,
-  useBatteryInfo,
-  useCopyToClipboard,
+  useLocalStorage,
   useMedia,
-  useClickOutside,
-  useColorScheme,
-  useFullScreen
+  useMobileLandscape,
+  useMousePageLeave,
+  useMultiStateValidator,
+  useOnlineStatus,
+  usePageLeave,
+  usePageVisible,
+  usePreferredLanguage,
+  usePrevious,
+  useScrolling,
+  useScrollLock,
+  useScrollToElement,
+  useSessionStorage,
+  useStateValidator,
+  useThrottle,
+  useWindowScroll
+  useWindowSize,
 } from 'react-kanca'
 
 // import 'react-kanca/dist/index.css'

package/dist/index.js

@@ -42,19 +42,23 @@ var useWindowSize = function useWindowSize() {
   return size;
 };
 
-var useDebounce = function useDebounce(value, delay) {
-  var _useState = react.useState(''),
-    debounce = _useState[0],
-    setDebounce = _useState[1];
-  react.useEffect(function () {
+var useDebounce = function useDebounce() {
+  var _useState = react.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) {
@@ -188,16 +192,16 @@ var useThrottle = function useThrottle(value, ms) {
   react.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;
@@ -264,7 +268,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);
@@ -272,7 +276,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;
 };
@@ -295,18 +299,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) {
@@ -595,6 +594,262 @@ var useSessionStorage = function useSessionStorage(key, initialValue) {
   return [storedValue, setValue];
 };
 
+var useScrollLock = function useScrollLock(lock) {
+  react.useEffect(function () {
+    if (lock) {
+      document.body.style.overflow = 'hidden';
+    } else {
+      document.body.style.overflow = 'unset';
+    }
+    return function () {
+      document.body.style.overflow = 'unset';
+    };
+  }, [lock]);
+};
+
+var usePreferredLanguage = function usePreferredLanguage() {
+  var _useState = react.useState(''),
+    preferredLanguage = _useState[0],
+    setPreferredLanguage = _useState[1];
+  react.useEffect(function () {
+    var language = navigator.language || navigator.userLanguage;
+    setPreferredLanguage(language);
+  }, []);
+  return preferredLanguage;
+};
+
+function useMousePageLeave(onPageLeave) {
+  react.useEffect(function () {
+    document.documentElement.addEventListener('mouseleave', onPageLeave);
+    return function () {
+      return document.documentElement.removeEventListener('mouseleave', onPageLeave);
+    };
+  }, []);
+}
+
+var usePageLeave = function usePageLeave(onLeave) {
+  react.useEffect(function () {
+    var handleBeforeUnload = function handleBeforeUnload(event) {
+      var returnValue = onLeave();
+      if (returnValue) {
+        event.preventDefault();
+        event.returnValue = returnValue;
+        return returnValue;
+      }
+    };
+    window.addEventListener('beforeunload', handleBeforeUnload);
+    return function () {
+      window.removeEventListener('beforeunload', handleBeforeUnload);
+    };
+  }, [onLeave]);
+};
+
+var useForceUpdate = function useForceUpdate() {
+  var _useState = react.useState(0),
+    setTick = _useState[1];
+  var update = react.useCallback(function () {
+    setTick(function (tick) {
+      return tick + 1;
+    });
+  }, []);
+  return update;
+};
+
+var useInterval = function useInterval(callback, delay) {
+  var savedCallback = react.useRef(function () {});
+  react.useEffect(function () {
+    savedCallback.current = callback;
+  });
+  react.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 = react.useState(false),
+    isIntersecting = _useState[0],
+    setIsIntersecting = _useState[1];
+  react.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 = react.useState(false),
+    isLandscape = _useState[0],
+    setIsLandscape = _useState[1];
+  var _useState2 = react.useState(false),
+    isMobile = _useState2[0],
+    setIsMobile = _useState2[1];
+  var _useState3 = react.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);
+  };
+  react.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 = react.useState(navigator.onLine),
+    isOnline = _useState[0],
+    setIsOnline = _useState[1];
+  react.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 = react.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 = react.useRef(validator);
+  var stateInner = react.useRef(state);
+  validatorInner.current = validator;
+  stateInner.current = state;
+  var _useState = react.useState(initialState),
+    validity = _useState[0],
+    setValidity = _useState[1];
+  var validate = react.useCallback(function () {
+    if (validatorInner.current.length >= 2) {
+      validatorInner.current(stateInner.current, setValidity);
+    } else {
+      setValidity(validatorInner.current(stateInner.current));
+    }
+  }, [setValidity]);
+  react.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 = react.useRef(validator);
+  var statesInner = react.useRef(states);
+  validatorInner.current = validator;
+  statesInner.current = states;
+  var _useState = react.useState(initialValidity),
+    validity = _useState[0],
+    setValidity = _useState[1];
+  var validate = react.useCallback(function () {
+    if (validatorInner.current.length >= 2) {
+      validatorInner.current(statesInner.current, setValidity);
+    } else {
+      setValidity(validatorInner.current(statesInner.current));
+    }
+  }, [setValidity]);
+  react.useEffect(function () {
+    validate();
+  }, Object.values(states));
+  return [validity, validate];
+};
+
+var useWindowScroll = function useWindowScroll() {
+  var _useState = react.useState(function () {
+      return {
+        x: isBrowser ? window.pageXOffset : 0,
+        y: isBrowser ? window.pageYOffset : 0
+      };
+    }),
+    state = _useState[0],
+    setState = _useState[1];
+  react.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;
+};
+
 exports.useBatteryInfo = useBatteryInfo;
 exports.useBeforeUnload = useBeforeUnload;
 exports.useClickOutside = useClickOutside;
@@ -603,17 +858,30 @@ exports.useConnection = useConnection;
 exports.useCookie = useCookie;
 exports.useCopyToClipboard = useCopyToClipboard;
 exports.useDebounce = useDebounce;
-exports.useEqualObject = useEqualObject;
+exports.useEqualObject = _useEqualObject;
+exports.useForceUpdate = useForceUpdate;
 exports.useFullScreen = useFullScreen;
 exports.useGeolocation = useGeolocation;
 exports.useHover = useHover;
+exports.useIntersectionObserver = useIntersectionObserver;
+exports.useInterval = useInterval;
 exports.useIsFirstRender = useIsFirstRender;
 exports.useLocalStorage = useLocalStorage;
 exports.useMedia = useMedia;
+exports.useMobileLandscape = useMobileLandscape;
+exports.useMousePageLeave = useMousePageLeave;
+exports.useMultiStateValidator = useMultiStateValidator;
+exports.useOnlineStatus = useOnlineStatus;
+exports.usePageLeave = usePageLeave;
 exports.usePageVisible = usePageVisible;
+exports.usePreferredLanguage = usePreferredLanguage;
 exports.usePrevious = usePrevious;
+exports.useScrollLock = useScrollLock;
+exports.useScrollToElement = useScrollToElement;
 exports.useScrolling = useScrolling;
 exports.useSessionStorage = useSessionStorage;
+exports.useStateValidator = useStateValidator;
 exports.useThrottle = useThrottle;
+exports.useWindowScroll = useWindowScroll;
 exports.useWindowSize = useWindowSize;
 //# sourceMappingURL=index.js.map