@musecat/functionkit 1.0.1 → 1.1.0

package/packages/hooks/useGeolocation.ts

@@ -3,14 +3,14 @@
 import { useCallback, useEffect, useRef, useState } from "react";
 
 type GeolocationData = {
-  latitude: number;
-  longitude: number;
-  accuracy: number;
-  altitude: number | null;
-  altitudeAccuracy: number | null;
-  heading: number | null;
-  speed: number | null;
-  timestamp: number;
+	latitude: number;
+	longitude: number;
+	accuracy: number;
+	altitude: number | null;
+	altitudeAccuracy: number | null;
+	heading: number | null;
+	speed: number | null;
+	timestamp: number;
 };
 
 const MOUNT_BEHAVIOR = { GET: "get", WATCH: "watch" } as const;
@@ -18,129 +18,125 @@ const MOUNT_BEHAVIOR = { GET: "get", WATCH: "watch" } as const;
 type MountBehavior = (typeof MOUNT_BEHAVIOR)[keyof typeof MOUNT_BEHAVIOR];
 
 type UseGeolocationOptions = {
-  mountBehavior?: MountBehavior;
-  enableHighAccuracy?: boolean;
-  timeout?: number;
-  maximumAge?: number;
+	mountBehavior?: MountBehavior;
+	enableHighAccuracy?: boolean;
+	timeout?: number;
+	maximumAge?: number;
 };
 
 export function useGeolocation(options?: UseGeolocationOptions) {
-  const [state, setState] = useState<{
-    loading: boolean;
-    error: string | null;
-    data: GeolocationData | null;
-  }>({
-    loading: !!options?.mountBehavior,
-    error: null,
-    data: null,
-  });
-  const [isTracking, setIsTracking] = useState(false);
-  const watchIdRef = useRef<number | null>(null);
-
-  const isSupported = useCallback(() => {
-    if (typeof window === "undefined" || !navigator.geolocation) {
-      setState((prev) => ({
-        ...prev,
-        loading: false,
-        error: "Geolocation is not supported by this environment.",
-      }));
-      return false;
-    }
-    return true;
-  }, []);
-
-  const handleSuccess = useCallback((position: GeolocationPosition) => {
-    const { coords } = position;
-    setState((prev) => ({
-      ...prev,
-      loading: false,
-      error: null,
-      data: {
-        latitude: coords.latitude,
-        longitude: coords.longitude,
-        accuracy: coords.accuracy,
-        altitude: coords.altitude,
-        altitudeAccuracy: coords.altitudeAccuracy,
-        heading: coords.heading,
-        speed: coords.speed,
-        timestamp: position.timestamp,
-      },
-    }));
-  }, []);
-
-  const handleError = useCallback((error: GeolocationPositionError) => {
-    setState((prev) => ({
-      ...prev,
-      loading: false,
-      error: error.message,
-    }));
-  }, []);
-
-  const geoOptions = useCallback(
-    () => ({
-      enableHighAccuracy: options?.enableHighAccuracy ?? false,
-      maximumAge: options?.maximumAge ?? 0,
-      timeout: options?.timeout ?? Infinity,
-    }),
-    [options?.enableHighAccuracy, options?.maximumAge, options?.timeout],
-  );
-
-  const getCurrentPosition = useCallback(() => {
-    if (!isSupported()) return;
-    setState((prev) => ({ ...prev, loading: true }));
-    navigator.geolocation.getCurrentPosition(
-      handleSuccess,
-      handleError,
-      geoOptions(),
-    );
-  }, [handleSuccess, handleError, geoOptions, isSupported]);
-
-  const startTracking = useCallback(() => {
-    if (!isSupported()) return;
-
-    if (watchIdRef.current !== null) {
-      navigator.geolocation.clearWatch(watchIdRef.current);
-    }
-
-    setState((prev) => ({ ...prev, loading: true }));
-
-    watchIdRef.current = navigator.geolocation.watchPosition(
-      (position) => {
-        setIsTracking(true);
-        handleSuccess(position);
-      },
-      handleError,
-      geoOptions(),
-    );
-  }, [handleSuccess, handleError, geoOptions, isSupported]);
-
-  const stopTracking = useCallback(() => {
-    if (watchIdRef.current === null) return;
-    navigator.geolocation.clearWatch(watchIdRef.current);
-    watchIdRef.current = null;
-    setIsTracking(false);
-  }, []);
-
-  useEffect(() => {
-    if (options?.mountBehavior === MOUNT_BEHAVIOR.WATCH) {
-      startTracking();
-    } else if (options?.mountBehavior === MOUNT_BEHAVIOR.GET) {
-      getCurrentPosition();
-    }
-
-    return () => {
-      if (watchIdRef.current !== null) {
-        navigator.geolocation.clearWatch(watchIdRef.current);
-        watchIdRef.current = null;
-      }
-    };
-  }, [options?.mountBehavior, getCurrentPosition, startTracking]);
-
-  return {
-    ...state,
-    getCurrentPosition,
-    startTracking,
-    stopTracking,
-    isTracking,
-  };
+	const [state, setState] = useState<{
+		loading: boolean;
+		error: string | null;
+		data: GeolocationData | null;
+	}>({
+		loading: !!options?.mountBehavior,
+		error: null,
+		data: null,
+	});
+	const [isTracking, setIsTracking] = useState(false);
+	const watchIdRef = useRef<number | null>(null);
+
+	const isSupported = useCallback(() => {
+		if (typeof window === "undefined" || !navigator.geolocation) {
+			setState((prev) => ({
+				...prev,
+				loading: false,
+				error: "Geolocation is not supported by this environment.",
+			}));
+			return false;
+		}
+		return true;
+	}, []);
+
+	const handleSuccess = useCallback((position: GeolocationPosition) => {
+		const { coords } = position;
+		setState((prev) => ({
+			...prev,
+			loading: false,
+			error: null,
+			data: {
+				latitude: coords.latitude,
+				longitude: coords.longitude,
+				accuracy: coords.accuracy,
+				altitude: coords.altitude,
+				altitudeAccuracy: coords.altitudeAccuracy,
+				heading: coords.heading,
+				speed: coords.speed,
+				timestamp: position.timestamp,
+			},
+		}));
+	}, []);
+
+	const handleError = useCallback((error: GeolocationPositionError) => {
+		setState((prev) => ({
+			...prev,
+			loading: false,
+			error: error.message,
+		}));
+	}, []);
+
+	const geoOptions = useCallback(
+		() => ({
+			enableHighAccuracy: options?.enableHighAccuracy ?? false,
+			maximumAge: options?.maximumAge ?? 0,
+			timeout: options?.timeout ?? Infinity,
+		}),
+		[options?.enableHighAccuracy, options?.maximumAge, options?.timeout],
+	);
+
+	const getCurrentPosition = useCallback(() => {
+		if (!isSupported()) return;
+		setState((prev) => ({ ...prev, loading: true }));
+		navigator.geolocation.getCurrentPosition(handleSuccess, handleError, geoOptions());
+	}, [handleSuccess, handleError, geoOptions, isSupported]);
+
+	const startTracking = useCallback(() => {
+		if (!isSupported()) return;
+
+		if (watchIdRef.current !== null) {
+			navigator.geolocation.clearWatch(watchIdRef.current);
+		}
+
+		setState((prev) => ({ ...prev, loading: true }));
+
+		watchIdRef.current = navigator.geolocation.watchPosition(
+			(position) => {
+				setIsTracking(true);
+				handleSuccess(position);
+			},
+			handleError,
+			geoOptions(),
+		);
+	}, [handleSuccess, handleError, geoOptions, isSupported]);
+
+	const stopTracking = useCallback(() => {
+		if (watchIdRef.current === null) return;
+		navigator.geolocation.clearWatch(watchIdRef.current);
+		watchIdRef.current = null;
+		setIsTracking(false);
+	}, []);
+
+	useEffect(() => {
+		if (options?.mountBehavior === MOUNT_BEHAVIOR.WATCH) {
+			startTracking();
+		} else if (options?.mountBehavior === MOUNT_BEHAVIOR.GET) {
+			getCurrentPosition();
+		}
+
+		return () => {
+			if (watchIdRef.current !== null) {
+				navigator.geolocation.clearWatch(watchIdRef.current);
+				watchIdRef.current = null;
+			}
+		};
+	}, [options?.mountBehavior, getCurrentPosition, startTracking]);
+
+	return {
+		...state,
+		getCurrentPosition,
+		startTracking,
+		stopTracking,
+		isTracking,
+	};
 }

package/packages/hooks/useHasMounted.ts

@@ -3,11 +3,11 @@
 import { useEffect, useState } from "react";
 
 export function useHasMounted() {
-  const [hasMounted, setHasMounted] = useState(false);
+	const [hasMounted, setHasMounted] = useState(false);
 
-  useEffect(() => {
-    setHasMounted(true);
-  }, []);
+	useEffect(() => {
+		setHasMounted(true);
+	}, []);
 
-  return hasMounted;
+	return hasMounted;
 }

package/packages/hooks/useIntersectionObserver.ts

@@ -6,29 +6,29 @@ import { usePreservedCallback } from "./usePreservedCallback";
 import { useRefEffect } from "./useRefEffect";
 
 export function useIntersectionObserver<Element extends HTMLElement>(
-  callback: (entry: IntersectionObserverEntry) => void,
-  options: IntersectionObserverInit,
+	callback: (entry: IntersectionObserverEntry) => void,
+	options: IntersectionObserverInit,
 ): (element: Element | null) => void {
-  const preservedCallback = usePreservedCallback(callback);
+	const preservedCallback = usePreservedCallback(callback);
 
-  const observer = useMemo(() => {
-    if (typeof IntersectionObserver === "undefined") {
-      return;
-    }
+	const observer = useMemo(() => {
+		if (typeof IntersectionObserver === "undefined") {
+			return;
+		}
 
-    return new IntersectionObserver(([entry]) => {
-      preservedCallback(entry);
-    }, options);
-  }, [preservedCallback, options]);
+		return new IntersectionObserver(([entry]) => {
+			preservedCallback(entry);
+		}, options);
+	}, [preservedCallback, options]);
 
-  return useRefEffect<Element>(
-    (element) => {
-      observer?.observe(element);
+	return useRefEffect<Element>(
+		(element) => {
+			observer?.observe(element);
 
-      return () => {
-        observer?.unobserve(element);
-      };
-    },
-    [preservedCallback, options],
-  );
+			return () => {
+				observer?.unobserve(element);
+			};
+		},
+		[preservedCallback, options],
+	);
 }

package/packages/hooks/useInterval.ts

@@ -5,51 +5,51 @@ import { useEffect, useRef } from "react";
 import { usePreservedCallback } from "./usePreservedCallback";
 
 type IntervalOptions =
-  | number
-  | {
-      delay: number;
-      immediate?: boolean;
-      enabled?: boolean;
-    };
+	| number
+	| {
+			delay: number;
+			immediate?: boolean;
+			enabled?: boolean;
+	  };
 
 export function useInterval(callback: () => void, options: IntervalOptions) {
-  const delay = typeof options === "number" ? options : options.delay;
-  const immediate = typeof options === "number" ? false : options.immediate;
-  const enabled = typeof options === "number" ? true : (options.enabled ?? true);
-
-  const preservedCallback = usePreservedCallback(callback);
-  const immediateCalledRef = useRef(false);
-
-  useEffect(
-    function runImmediateCallback() {
-      if (immediate !== true) {
-        immediateCalledRef.current = false;
-        return;
-      }
-
-      if (!enabled) {
-        return;
-      }
-
-      if (immediateCalledRef.current) {
-        return;
-      }
-
-      immediateCalledRef.current = true;
-      preservedCallback();
-    },
-    [immediate, preservedCallback, enabled],
-  );
-
-  useEffect(
-    function startInterval() {
-      if (!enabled) {
-        return;
-      }
-
-      const id = setInterval(preservedCallback, delay);
-      return () => clearInterval(id);
-    },
-    [delay, preservedCallback, enabled],
-  );
+	const delay = typeof options === "number" ? options : options.delay;
+	const immediate = typeof options === "number" ? false : options.immediate;
+	const enabled = typeof options === "number" ? true : (options.enabled ?? true);
+
+	const preservedCallback = usePreservedCallback(callback);
+	const immediateCalledRef = useRef(false);
+
+	useEffect(
+		function runImmediateCallback() {
+			if (immediate !== true) {
+				immediateCalledRef.current = false;
+				return;
+			}
+
+			if (!enabled) {
+				return;
+			}
+
+			if (immediateCalledRef.current) {
+				return;
+			}
+
+			immediateCalledRef.current = true;
+			preservedCallback();
+		},
+		[immediate, preservedCallback, enabled],
+	);
+
+	useEffect(
+		function startInterval() {
+			if (!enabled) {
+				return;
+			}
+
+			const id = setInterval(preservedCallback, delay);
+			return () => clearInterval(id);
+		},
+		[delay, preservedCallback, enabled],
+	);
 }

package/packages/hooks/useKeyboardHeight.ts

@@ -4,15 +4,15 @@ import { useEffect, useState } from "react";
 import { subscribeKeyboardHeight } from "../utils/subscribeKeyboardHeight";
 
 export function useKeyboardHeight() {
-  const [keyboardHeight, setKeyboardHeight] = useState(0);
+	const [keyboardHeight, setKeyboardHeight] = useState(0);
 
-  useEffect(() => {
-    const { unsubscribe } = subscribeKeyboardHeight({
-      callback: setKeyboardHeight,
-      immediate: true,
-    });
-    return unsubscribe;
-  }, []);
+	useEffect(() => {
+		const { unsubscribe } = subscribeKeyboardHeight({
+			callback: setKeyboardHeight,
+			immediate: true,
+		});
+		return unsubscribe;
+	}, []);
 
-  return { keyboardHeight };
+	return { keyboardHeight };
 }