react-native-nitro-geolocation 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-geolocation",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "⚡🚀Blazing-fast geolocation for React Native powered by Nitro Modules",
   "main": "src/index",
   "source": "src/index",

package/src/hooks/useGetCurrentPosition.ts

@@ -1,44 +1,140 @@
-import type { LocationRequestOptions } from "../NitroGeolocation.nitro";
+import { useCallback, useEffect, useRef, useState } from "react";
+import type {
+  LocationError,
+  LocationRequestOptions
+} from "../NitroGeolocation.nitro";
 import { useGeolocationClient } from "../components/GeolocationProvider";
 import type { GeolocationResponse } from "../types";
 
 /**
- * Hook that returns a function to get current location (one-time request).
- * The returned function throws error if permission denied, timeout, or unavailable.
+ * Options for useGetCurrentPosition hook (Query style).
+ */
+export interface UseGetCurrentPositionOptions extends LocationRequestOptions {
+  /**
+   * Whether to automatically fetch the current position.
+   * When false, only manual refetch() will trigger the request.
+   * @default true
+   */
+  enabled?: boolean;
+}
+
+/**
+ * Hook for getting current location (one-time request) in Query style.
+ * Provides loading, error states, and data similar to TanStack Query.
  *
- * @returns Object containing getCurrentPosition function
- * @throws LocationError with code and message
+ * @param options - Location request options and enabled flag
+ * @returns Object containing position, loading/error states, and refetch function
  *
  * @example
  * ```tsx
+ * // Auto-fetch on mount
  * function MyComponent() {
- *   const { getCurrentPosition } = useGetCurrentPosition();
+ *   const {
+ *     position,
+ *     isLoading,
+ *     isError,
+ *     error,
+ *     refetch
+ *   } = useGetCurrentPosition({
+ *     enabled: true,
+ *     enableHighAccuracy: true,
+ *   });
  *
- *   const handleGetLocation = async () => {
- *     try {
- *       const position = await getCurrentPosition({
- *         enableHighAccuracy: true,
- *         timeout: 15000,
- *       });
- *       console.log('Lat:', position.coords.latitude);
- *       console.log('Lng:', position.coords.longitude);
- *     } catch (error) {
- *       console.error('Location error:', error.message);
- *     }
- *   };
+ *   if (isLoading) return <Text>Loading...</Text>;
+ *   if (isError) return <Text>Error: {error?.message}</Text>;
+ *   if (!position) return null;
  *
- *   return <Button onPress={handleGetLocation} />;
+ *   return (
+ *     <View>
+ *       <Text>Lat: {position.coords.latitude}</Text>
+ *       <Text>Lng: {position.coords.longitude}</Text>
+ *       <Button title="Refresh" onPress={() => refetch()} />
+ *     </View>
+ *   );
+ * }
+ *
+ * // Manual trigger only
+ * function ManualComponent() {
+ *   const { position, isLoading, refetch } = useGetCurrentPosition({
+ *     enabled: false
+ *   });
+ *
+ *   return (
+ *     <View>
+ *       <Button
+ *         title="Get Location"
+ *         onPress={() => refetch()}
+ *         disabled={isLoading}
+ *       />
+ *       {position && <Text>Lat: {position.coords.latitude}</Text>}
+ *     </View>
+ *   );
  * }
  * ```
  */
-export function useGetCurrentPosition() {
+export function useGetCurrentPosition(options?: UseGetCurrentPositionOptions) {
   const client = useGeolocationClient();
 
-  return {
-    getCurrentPosition: (
-      options?: LocationRequestOptions
-    ): Promise<GeolocationResponse> => {
-      return client.getCurrentPosition(options);
+  const [position, setPosition] = useState<GeolocationResponse | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isError, setIsError] = useState(false);
+  const [error, setError] = useState<LocationError | null>(null);
+
+  const isMountedRef = useRef(true);
+  const optionsRef = useRef(options);
+
+  // Update options ref when they change
+  useEffect(() => {
+    optionsRef.current = options;
+  }, [options]);
+
+  const fetchPosition = useCallback(async () => {
+    if (!isMountedRef.current) return;
+
+    setIsLoading(true);
+    setIsError(false);
+    setError(null);
+
+    try {
+      const result = await client.getCurrentPosition(optionsRef.current);
+      if (!isMountedRef.current) return;
+
+      setPosition(result);
+      setIsLoading(false);
+    } catch (err) {
+      if (!isMountedRef.current) return;
+
+      setIsError(true);
+      setError(err as LocationError);
+      setIsLoading(false);
+    }
+  }, [client]);
+
+  // Extract enabled flag for reactive dependency
+  const enabled = options?.enabled ?? true;
+
+  // Auto-fetch on mount if enabled
+  useEffect(() => {
+    if (enabled) {
+      fetchPosition();
     }
+    // Only run when enabled changes, not when fetchPosition changes
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [enabled]);
+
+  // Track mount status
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+
+  return {
+    position,
+    isLoading,
+    isError,
+    error,
+    refetch: fetchPosition
   };
 }

package/src/hooks/useRequestPermission.ts

@@ -1,38 +1,98 @@
-import type { PermissionStatus } from "../NitroGeolocation.nitro";
+import { useCallback, useEffect, useRef, useState } from "react";
+import type {
+  LocationError,
+  PermissionStatus
+} from "../NitroGeolocation.nitro";
 import { useGeolocationClient } from "../components/GeolocationProvider";
 
 /**
- * Hook that returns a function to request location permission from the user.
- * Shows system permission dialog if not yet determined.
+ * Hook for requesting location permission in Mutation style.
+ * Provides pending, error states, and status similar to TanStack Query mutations.
  *
- * @returns Object containing requestPermission function
+ * @returns Object containing requestPermission function, status, and state flags
  *
  * @example
  * ```tsx
  * function MyComponent() {
- *   const { requestPermission } = useRequestPermission();
+ *   const {
+ *     requestPermission,
+ *     status,
+ *     isPending,
+ *     isError,
+ *     error
+ *   } = useRequestPermission();
  *
  *   const handleRequest = async () => {
- *     try {
- *       const status = await requestPermission();
- *       if (status === 'granted') {
- *         console.log('Permission granted!');
- *       }
- *     } catch (error) {
- *       console.error('Permission error:', error);
+ *     const result = await requestPermission();
+ *     if (result === 'granted') {
+ *       console.log('Permission granted!');
  *     }
  *   };
  *
- *   return <Button onPress={handleRequest} />;
+ *   return (
+ *     <View>
+ *       <Button
+ *         onPress={handleRequest}
+ *         disabled={isPending}
+ *       >
+ *         {isPending ? 'Requesting...' : 'Request Permission'}
+ *       </Button>
+ *       {isError && <Text>Error: {error?.message}</Text>}
+ *       {status && <Text>Status: {status}</Text>}
+ *     </View>
+ *   );
  * }
  * ```
  */
 export function useRequestPermission() {
   const client = useGeolocationClient();
 
-  return {
-    requestPermission: (): Promise<PermissionStatus> => {
-      return client.requestPermission();
+  const [status, setStatus] = useState<PermissionStatus | null>(null);
+  const [isPending, setIsPending] = useState(false);
+  const [isError, setIsError] = useState(false);
+  const [error, setError] = useState<LocationError | null>(null);
+
+  const isMountedRef = useRef(true);
+
+  const requestPermission = useCallback(async (): Promise<PermissionStatus> => {
+    if (!isMountedRef.current) {
+      throw new Error("Component unmounted");
     }
+
+    setIsPending(true);
+    setIsError(false);
+    setError(null);
+
+    try {
+      const result = await client.requestPermission();
+      if (!isMountedRef.current) return result;
+
+      setStatus(result);
+      setIsPending(false);
+      return result;
+    } catch (err) {
+      if (!isMountedRef.current) throw err;
+
+      setIsError(true);
+      setError(err as LocationError);
+      setIsPending(false);
+      throw err;
+    }
+  }, [client]);
+
+  // Track mount status
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+
+  return {
+    requestPermission,
+    status,
+    isPending,
+    isError,
+    error
   };
 }

package/src/hooks/useWatchPosition.ts

@@ -26,12 +26,12 @@ export interface UseWatchPositionOptions extends LocationRequestOptions {
  * Cleanup is automatic via useEffect.
  *
  * @param options - Location request options
- * @returns Object containing current position data, error, and watching status
+ * @returns Object containing current position, error, and watching status
  *
  * @example
  * ```tsx
  * function LiveTracking() {
- *   const { data, error, isWatching } = useWatchPosition({
+ *   const { position, error, isWatching } = useWatchPosition({
  *     enabled: true,
  *     enableHighAccuracy: true,
  *     distanceFilter: 10  // Update every 10 meters
@@ -39,12 +39,12 @@ export interface UseWatchPositionOptions extends LocationRequestOptions {
  *
  *   if (!isWatching) return <Text>Not watching</Text>;
  *   if (error) return <Text>Error: {error.message}</Text>;
- *   if (!data) return <Text>Waiting for location...</Text>;
+ *   if (!position) return <Text>Waiting for location...</Text>;
  *
  *   return (
  *     <Text>
- *       Current: {data.coords.latitude}, {data.coords.longitude}
- *       Accuracy: {data.coords.accuracy}m
+ *       Current: {position.coords.latitude}, {position.coords.longitude}
+ *       Accuracy: {position.coords.accuracy}m
  *     </Text>
  *   );
  * }
@@ -53,8 +53,9 @@ export interface UseWatchPositionOptions extends LocationRequestOptions {
 export function useWatchPosition(options?: UseWatchPositionOptions) {
   const client = useGeolocationClient();
 
-  const [data, setData] = useState<GeolocationResponse | null>(null);
+  const [position, setPosition] = useState<GeolocationResponse | null>(null);
   const [isWatching, setIsWatching] = useState(false);
+  const [error, setError] = useState<LocationError | null>(null);
 
   // Store subscription token (hidden from user!)
   const tokenRef = useRef<string | null>(null);
@@ -62,9 +63,18 @@ export function useWatchPosition(options?: UseWatchPositionOptions) {
   // Track if component is mounted to prevent state updates after unmount
   const isMountedRef = useRef(true);
 
+  // Store latest options in ref to avoid unnecessary re-subscriptions
+  const optionsRef = useRef(options);
+
+  // Update options ref whenever options change
   useEffect(() => {
-    const enabled = options?.enabled ?? false;
+    optionsRef.current = options;
+  }, [options]);
+
+  // Extract enabled flag for reactive dependency
+  const enabled = options?.enabled ?? false;
 
+  useEffect(() => {
     if (!enabled) {
       // Not enabled, ensure cleanup
       if (tokenRef.current) {
@@ -75,21 +85,23 @@ export function useWatchPosition(options?: UseWatchPositionOptions) {
       return;
     }
 
-    // Start watching
+    // Start watching with latest options
     setIsWatching(true);
+    setError(null);
 
     const token = client.watchPosition(
-      (position: GeolocationResponse) => {
+      (result: GeolocationResponse) => {
         // Success callback
         if (!isMountedRef.current) return;
-        setData(position);
+        setPosition(result);
+        setError(null);
       },
       (err: LocationError) => {
-        // Error callback - throw to be caught by Error Boundary
+        // Error callback
         if (!isMountedRef.current) return;
-        throw new Error(err.message);
+        setError(err);
       },
-      options
+      optionsRef.current
     );
 
     tokenRef.current = token;
@@ -100,17 +112,7 @@ export function useWatchPosition(options?: UseWatchPositionOptions) {
         client.unwatch(token);
       }
     };
-  }, [
-    client,
-    options?.enabled,
-    options?.enableHighAccuracy,
-    options?.distanceFilter,
-    options?.interval,
-    options?.fastestInterval,
-    options?.timeout,
-    options?.maximumAge,
-    options?.useSignificantChanges
-  ]);
+  }, [enabled, client]); // Only re-subscribe when enabled/client changes
 
   // Track mount status
   useEffect(() => {
@@ -121,7 +123,8 @@ export function useWatchPosition(options?: UseWatchPositionOptions) {
   }, []);
 
   return {
-    data,
+    position,
+    error,
     isWatching
   };
 }