react-kanca 1.0.0

package/dist/index.modern.js

@@ -0,0 +1,574 @@
+import { useState, useEffect, useRef, cloneElement, useCallback, useLayoutEffect } from 'react';
+import Cookies from 'js-cookie';
+
+var usePageVisible = function usePageVisible() {
+  var _useState = useState(true),
+    isVisible = _useState[0],
+    setIsVisible = _useState[1];
+  var handleVisibilityChange = function handleVisibilityChange() {
+    setIsVisible(document.visibilityState === 'visible');
+  };
+  useEffect(function () {
+    document.addEventListener('visibilitychange', handleVisibilityChange);
+    return function () {
+      document.removeEventListener('visibilitychange', handleVisibilityChange);
+    };
+  }, []);
+  return isVisible;
+};
+
+var useWindowSize = function useWindowSize() {
+  var _useState = useState({
+      width: '',
+      height: ''
+    }),
+    size = _useState[0],
+    setSize = _useState[1];
+  useEffect(function () {
+    var handleResize = function handleResize() {
+      setSize({
+        width: window.innerWidth,
+        height: window.innerHeight
+      });
+    };
+    window.addEventListener('resize', handleResize);
+    handleResize();
+    return function () {
+      window.removeEventListener('resize', handleResize);
+    };
+  }, []);
+  return size;
+};
+
+var useDebounce = function useDebounce(value, delay) {
+  var _useState = useState(''),
+    debounce = _useState[0],
+    setDebounce = _useState[1];
+  useEffect(function () {
+    var handler = setTimeout(function () {
+      setDebounce(value);
+    }, delay);
+    return function () {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+  return debounce;
+};
+
+var usePrevious = function usePrevious(value) {
+  var ref = useRef();
+  useEffect(function () {
+    ref.current = value;
+  });
+  return ref.current;
+};
+
+var noop = function noop() {};
+function on(obj) {
+  if (obj && obj.addEventListener) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    obj.addEventListener.apply(obj, args);
+  }
+}
+function off(obj) {
+  if (obj && obj.removeEventListener) {
+    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      args[_key2 - 1] = arguments[_key2];
+    }
+    obj.removeEventListener.apply(obj, args);
+  }
+}
+var isBrowser = typeof window !== 'undefined';
+
+var useHover = function useHover(element) {
+  var _useState = useState(false),
+    state = _useState[0],
+    setState = _useState[1];
+  var onMouseEnter = function onMouseEnter(originalOnMouseEnter) {
+    return function (event) {
+      setState(true);
+    };
+  };
+  var onMouseLeave = function onMouseLeave(originalOnMouseLeave) {
+    return function (event) {
+      setState(false);
+    };
+  };
+  if (typeof element === 'function') {
+    element = element(state);
+  }
+  var el = cloneElement(element, {
+    onMouseEnter: onMouseEnter(),
+    onMouseLeave: onMouseLeave()
+  });
+  return [el, state];
+};
+
+var useScrolling = function useScrolling(ref) {
+  var _useState = useState(false),
+    scrolling = _useState[0],
+    setScrolling = _useState[1];
+  useEffect(function () {
+    if (ref.current) {
+      var scrollingTimeout;
+      var handleScrollEnd = function handleScrollEnd() {
+        setScrolling(false);
+      };
+      var handleScroll = function handleScroll() {
+        setScrolling(true);
+        clearTimeout(scrollingTimeout);
+        scrollingTimeout = setTimeout(function () {
+          return handleScrollEnd();
+        }, 150);
+      };
+      on(ref.current, 'scroll', handleScroll, false);
+      return function () {
+        if (ref.current) {
+          off(ref.current, 'scroll', handleScroll, false);
+        }
+      };
+    }
+    return function () {};
+  }, [ref]);
+  return scrolling;
+};
+
+var useBeforeUnload = function useBeforeUnload(enabled, message) {
+  if (enabled === void 0) {
+    enabled = true;
+  }
+  var handler = useCallback(function (event) {
+    var finalEnabled = typeof enabled === 'function' ? enabled() : true;
+    if (!finalEnabled) {
+      return;
+    }
+    event.preventDefault();
+    if (message) {
+      event.returnValue = message;
+    }
+    return message;
+  }, [enabled, message]);
+  useEffect(function () {
+    if (!enabled) {
+      return;
+    }
+    on(window, 'beforeunload', handler);
+    return function () {
+      return off(window, 'beforeunload', handler);
+    };
+  }, [enabled, handler]);
+};
+
+var useEffectOnce = function useEffectOnce(effect) {
+  useEffect(effect, []);
+};
+var useUnmount = function useUnmount(fn) {
+  var fnRef = useRef(fn);
+  fnRef.current = fn;
+  useEffectOnce(function () {
+    return function () {
+      return fnRef.current();
+    };
+  });
+};
+var useThrottle = function useThrottle(value, ms) {
+  if (ms === void 0) {
+    ms = 200;
+  }
+  var _useState = useState(value),
+    state = _useState[0],
+    setState = _useState[1];
+  var timeout = useRef();
+  var nextValue = useRef(null);
+  var hasNextValue = useRef(0);
+  useEffect(function () {
+    if (!timeout.current) {
+      setState(value);
+      var timeoutCallback = function timeoutCallback() {
+        if (hasNextValue.current) {
+          hasNextValue.current = false;
+          setState(nextValue.current);
+          timeout.current = setTimeout(timeoutCallback, ms);
+        } else {
+          timeout.current = undefined;
+        }
+      };
+      timeout.current = setTimeout(timeoutCallback, ms);
+    } else {
+      nextValue.current = value;
+      hasNextValue.current = true;
+    }
+  }, [value]);
+  useUnmount(function () {
+    timeout.current && clearTimeout(timeout.current);
+  });
+  return state;
+};
+
+var useLocalStorage = function useLocalStorage(key, initialValue, options) {
+  if (!isBrowser) {
+    return [initialValue, noop, noop];
+  }
+  if (!key) {
+    throw new Error('useLocalStorage key may not be falsy');
+  }
+  var deserializer = options ? options.raw ? function (value) {
+    return value;
+  } : options.deserializer : JSON.parse;
+  var initializer = useRef(function (key) {
+    try {
+      var serializer = options ? options.raw ? String : options.serializer : JSON.stringify;
+      var localStorageValue = localStorage.getItem(key);
+      if (localStorageValue !== null) {
+        return deserializer(localStorageValue);
+      } else {
+        initialValue && localStorage.setItem(key, serializer(initialValue));
+        return initialValue;
+      }
+    } catch (_unused) {
+      return initialValue;
+    }
+  });
+  var _useState = useState(function () {
+      return initializer.current(key);
+    }),
+    state = _useState[0],
+    setState = _useState[1];
+  useLayoutEffect(function () {
+    return setState(initializer.current(key));
+  }, [key]);
+  var set = useCallback(function (valOrFunc) {
+    try {
+      var newState = typeof valOrFunc === 'function' ? valOrFunc(state) : valOrFunc;
+      if (typeof newState === 'undefined') return;
+      var value;
+      if (options) {
+        if (options.raw) {
+          if (typeof newState === 'string') value = newState;else value = JSON.stringify(newState);
+        } else if (options.serializer) value = options.serializer(newState);else value = JSON.stringify(newState);
+      } else value = JSON.stringify(newState);
+      localStorage.setItem(key, value);
+      setState(deserializer(value));
+    } catch (_unused2) {}
+  }, [key, setState]);
+  var remove = useCallback(function () {
+    try {
+      localStorage.removeItem(key);
+      setState(undefined);
+    } catch (_unused3) {}
+  }, [key, setState]);
+  return [state, set, remove];
+};
+
+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);
+  var keys2 = Object.keys(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;
+  }
+  return true;
+};
+
+var useCookie = function useCookie(cookieName) {
+  var _useState = useState(function () {
+      return Cookies.get(cookieName) || null;
+    }),
+    value = _useState[0],
+    setValue = _useState[1];
+  var updateCookie = useCallback(function (newValue, options) {
+    Cookies.set(cookieName, newValue, options);
+    setValue(newValue);
+  }, [cookieName]);
+  var deleteCookie = useCallback(function () {
+    Cookies.remove(cookieName);
+    setValue(null);
+  }, [cookieName]);
+  return [value, updateCookie, deleteCookie];
+};
+
+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 target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+var useGeolocation = function useGeolocation(options) {
+  var _useState = useState({
+      loading: true,
+      accuracy: null,
+      altitude: null,
+      altitudeAccuracy: null,
+      heading: null,
+      latitude: null,
+      longitude: null,
+      speed: null,
+      timestamp: Date.now()
+    }),
+    state = _useState[0],
+    setState = _useState[1];
+  var mounted = true;
+  var watchId;
+  var onEvent = function onEvent(event) {
+    if (mounted) {
+      setState({
+        loading: false,
+        accuracy: event.coords.accuracy,
+        altitude: event.coords.altitude,
+        altitudeAccuracy: event.coords.altitudeAccuracy,
+        heading: event.coords.heading,
+        latitude: event.coords.latitude,
+        longitude: event.coords.longitude,
+        speed: event.coords.speed,
+        timestamp: event.timestamp
+      });
+    }
+  };
+  var onEventError = function onEventError(error) {
+    return mounted && setState(function (oldState) {
+      return _extends({}, oldState, {
+        loading: false,
+        error: error
+      });
+    });
+  };
+  useEffect(function () {
+    navigator.geolocation.getCurrentPosition(onEvent, onEventError, options);
+    watchId = navigator.geolocation.watchPosition(onEvent, onEventError, options);
+    return function () {
+      mounted = false;
+      navigator.geolocation.clearWatch(watchId);
+    };
+  }, []);
+  return state;
+};
+
+var useIsFirstRender = function useIsFirstRender() {
+  var isFirstRender = useRef(true);
+  useEffect(function () {
+    isFirstRender.current = false;
+  }, []);
+  return isFirstRender.current;
+};
+
+var useConnection = function useConnection() {
+  var _useState = useState(true),
+    status = _useState[0],
+    setStatus = _useState[1];
+  useEffect(function () {
+    var events = ['online', 'offline'];
+    var eventHandle = function eventHandle() {
+      return setStatus(navigator.online);
+    };
+    events.forEach(function (event) {
+      return window.addEventListener(event, eventHandle);
+    });
+    return function () {
+      events.forEach(function (event) {
+        return window.removeEventListener(event, eventHandle);
+      });
+    };
+  }, []);
+  return {
+    status: status
+  };
+};
+
+// A type of promise-like that resolves synchronously and supports only one observer
+
+const _iteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.iterator || (Symbol.iterator = Symbol("Symbol.iterator"))) : "@@iterator";
+
+const _asyncIteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.asyncIterator || (Symbol.asyncIterator = Symbol("Symbol.asyncIterator"))) : "@@asyncIterator";
+
+// Asynchronously call a function and send errors to recovery continuation
+function _catch(body, recover) {
+	try {
+		var result = body();
+	} catch(e) {
+		return recover(e);
+	}
+	if (result && result.then) {
+		return result.then(void 0, recover);
+	}
+	return result;
+}
+
+var useBatteryInfo = function useBatteryInfo() {
+  var _useState = useState(null),
+    batteryLevel = _useState[0],
+    setBatteryLevel = _useState[1];
+  var _useState2 = useState(null),
+    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];
+  useEffect(function () {
+    var getBatteryInfo = function getBatteryInfo() {
+      try {
+        return Promise.resolve(_catch(function () {
+          return Promise.resolve(navigator.getBattery()).then(function (battery) {
+            var updateBatteryInfo = function updateBatteryInfo() {
+              setBatteryLevel(Math.round(battery.level * 100));
+              setIsCharging(battery.charging);
+              setChargingTime(battery.chargingTime);
+              setDischargingTime(battery.dischargingTime);
+            };
+            updateBatteryInfo();
+            battery.addEventListener('chargingchange', updateBatteryInfo);
+            battery.addEventListener('levelchange', updateBatteryInfo);
+            battery.addEventListener('chargingtimechange', updateBatteryInfo);
+            battery.addEventListener('dischargingtimechange', updateBatteryInfo);
+            return function () {
+              battery.removeEventListener('chargingchange', updateBatteryInfo);
+              battery.removeEventListener('levelchange', updateBatteryInfo);
+              battery.removeEventListener('chargingtimechange', updateBatteryInfo);
+              battery.removeEventListener('dischargingtimechange', updateBatteryInfo);
+            };
+          });
+        }, function (error) {
+          console.error('Batarya bilgisi alınamadı: ' + error.message);
+        }));
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    getBatteryInfo();
+    return function () {};
+  }, []);
+  return {
+    batteryLevel: batteryLevel,
+    isCharging: isCharging,
+    chargingTime: chargingTime,
+    dischargingTime: dischargingTime
+  };
+};
+
+var useCopyToClipboard = function useCopyToClipboard() {
+  var _useState = useState(false),
+    copied = _useState[0],
+    setCopied = _useState[1];
+  var _useState2 = useState(false),
+    error = _useState2[0],
+    setError = _useState2[1];
+  var copyToClipboard = function copyToClipboard(text) {
+    navigator.clipboard.writeText(text).then(function () {
+      setCopied(true);
+    })["catch"](function (err) {
+      setError(err);
+    });
+  };
+  return {
+    copied: copied,
+    error: error,
+    copyToClipboard: copyToClipboard
+  };
+};
+
+var useMedia = function useMedia(width) {
+  if (width === void 0) {
+    width = 1024;
+  }
+  var _useState = useState(window.matchMedia("(max-width: " + width + "px)").matches),
+    screenStatus = _useState[0],
+    setScreenStatus = _useState[1];
+  useEffect(function () {
+    var matchMedia = window.matchMedia("(max-width: " + width + "px)");
+    var onChangeHandle = function onChangeHandle(e) {
+      console.log(e.matches);
+      setScreenStatus(e.matches);
+    };
+    matchMedia.addEventListener('change', onChangeHandle);
+  });
+  return screenStatus;
+};
+
+var useClickOutside = function useClickOutside(ref, callback) {
+  var handleClick = function handleClick(e) {
+    if (ref.current && !ref.current.contains(e.target)) {
+      callback();
+    }
+  };
+  useEffect(function () {
+    document.addEventListener('click', handleClick);
+    return function () {
+      document.removeEventListener('click', handleClick);
+    };
+  });
+};
+
+var useColorScheme = function useColorScheme() {
+  var _useState = useState(getInitialColorScheme()),
+    colorScheme = _useState[0],
+    setColorScheme = _useState[1];
+  useEffect(function () {
+    var mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
+    var listener = function listener(e) {
+      setColorScheme(e.matches ? 'dark' : 'light');
+    };
+    mediaQuery.addEventListener('change', listener);
+    return function () {
+      mediaQuery.removeEventListener('change', listener);
+    };
+  }, []);
+  function getInitialColorScheme() {
+    var isDarkMode = window.matchMedia('(prefers-color-scheme: dark)').matches;
+    return isDarkMode ? 'dark' : 'light';
+  }
+  return colorScheme;
+};
+
+var useFullScreen = function useFullScreen() {
+  var _useState = useState(false),
+    isFullScreen = _useState[0],
+    setIsFullScreen = _useState[1];
+  var enterFullScreen = function enterFullScreen() {
+    if (document.documentElement.requestFullscreen) {
+      document.documentElement.requestFullscreen();
+    } else if (document.documentElement.mozRequestFullScreen) {
+      document.documentElement.mozRequestFullScreen();
+    } else if (document.documentElement.webkitRequestFullscreen) {
+      document.documentElement.webkitRequestFullscreen();
+    } else if (document.documentElement.msRequestFullscreen) {
+      document.documentElement.msRequestFullscreen();
+    }
+    setIsFullScreen(true);
+  };
+  var exitFullScreen = function exitFullScreen() {
+    if (document.exitFullscreen) {
+      document.exitFullscreen();
+    } else if (document.mozCancelFullScreen) {
+      document.mozCancelFullScreen();
+    } else if (document.webkitExitFullscreen) {
+      document.webkitExitFullscreen();
+    } else if (document.msExitFullscreen) {
+      document.msExitFullscreen();
+    }
+    setIsFullScreen(false);
+  };
+  return {
+    isFullScreen: isFullScreen,
+    enterFullScreen: enterFullScreen,
+    exitFullScreen: exitFullScreen
+  };
+};
+
+export { useBatteryInfo, useBeforeUnload, useClickOutside, useColorScheme, useConnection, useCookie, useCopyToClipboard, useDebounce, useEqualObject, useFullScreen, useGeolocation, useHover, useIsFirstRender, useLocalStorage, useMedia, usePageVisible, usePrevious, useScrolling, useThrottle, useWindowSize };
+//# sourceMappingURL=index.modern.js.map