react-native-nitro-geolocation 0.3.0 → 0.5.0

package/package.json

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

package/src/api/checkPermission.ts

@@ -0,0 +1,21 @@
+import type { PermissionStatus } from "../NitroGeolocation.nitro";
+import { NitroGeolocationHybridObject } from "../NitroGeolocationModule";
+
+/**
+ * Check current location permission status.
+ * Does NOT request permission, only checks current state.
+ *
+ * @returns Promise resolving to current permission status
+ * @example
+ * ```tsx
+ * import { checkPermission } from 'react-native-nitro-geolocation';
+ *
+ * const status = await checkPermission();
+ * if (status === 'granted') {
+ *   // Get location
+ * }
+ * ```
+ */
+export function checkPermission(): Promise<PermissionStatus> {
+  return NitroGeolocationHybridObject.checkPermission();
+}

package/src/api/getCurrentPosition.ts

@@ -0,0 +1,43 @@
+import type { LocationRequestOptions } from "../NitroGeolocation.nitro";
+import { NitroGeolocationHybridObject } from "../NitroGeolocationModule";
+import { isDevtoolsEnabled } from "../devtools";
+import { getDevtoolsCurrentPosition } from "../devtools/getCurrentPosition";
+import type { GeolocationResponse } from "../types";
+
+/**
+ * Get current location (one-time request).
+ *
+ * Strategy:
+ * 1. Check cached location (if maximumAge allows)
+ * 2. Request fresh location from GPS/Network
+ * 3. Timeout after specified duration
+ *
+ * @param options - Location request options
+ * @returns Promise resolving to current position
+ * @throws LocationError if permission denied, timeout, or unavailable
+ * @example
+ * ```tsx
+ * import { getCurrentPosition } from 'react-native-nitro-geolocation';
+ *
+ * try {
+ *   const position = await getCurrentPosition({
+ *     enableHighAccuracy: true,
+ *     timeout: 15000
+ *   });
+ *   console.log(position.coords.latitude, position.coords.longitude);
+ * } catch (error) {
+ *   console.error(error.message);
+ * }
+ * ```
+ */
+export function getCurrentPosition(
+  options?: LocationRequestOptions
+): Promise<GeolocationResponse> {
+  if (isDevtoolsEnabled()) {
+    const devtoolsResult = getDevtoolsCurrentPosition();
+    if (devtoolsResult) {
+      return devtoolsResult;
+    }
+  }
+  return NitroGeolocationHybridObject.getCurrentPosition(options);
+}

package/src/api/index.ts

@@ -0,0 +1,7 @@
+export { setConfiguration } from "./setConfiguration";
+export { checkPermission } from "./checkPermission";
+export { requestPermission } from "./requestPermission";
+export { getCurrentPosition } from "./getCurrentPosition";
+export { watchPosition } from "./watchPosition";
+export { unwatch } from "./unwatch";
+export { stopObserving } from "./stopObserving";

package/src/api/requestPermission.ts

@@ -0,0 +1,21 @@
+import type { PermissionStatus } from "../NitroGeolocation.nitro";
+import { NitroGeolocationHybridObject } from "../NitroGeolocationModule";
+
+/**
+ * Request location permission from the user.
+ * Shows system permission dialog if not yet determined.
+ *
+ * @returns Promise resolving to new permission status
+ * @example
+ * ```tsx
+ * import { requestPermission } from 'react-native-nitro-geolocation';
+ *
+ * const status = await requestPermission();
+ * if (status === 'granted') {
+ *   // Get location
+ * }
+ * ```
+ */
+export function requestPermission(): Promise<PermissionStatus> {
+  return NitroGeolocationHybridObject.requestPermission();
+}

package/src/api/setConfiguration.ts

@@ -0,0 +1,31 @@
+import type { ModernGeolocationConfiguration as NitroModernGeolocationConfiguration } from "../NitroGeolocation.nitro";
+import { NitroGeolocationHybridObject } from "../NitroGeolocationModule";
+import type { ModernGeolocationConfiguration } from "../types";
+
+/**
+ * Set global geolocation configuration.
+ * Should be called once at app startup.
+ *
+ * @param config - Platform-specific configuration
+ * @example
+ * ```tsx
+ * import { setConfiguration } from 'react-native-nitro-geolocation';
+ *
+ * setConfiguration({
+ *   authorizationLevel: 'whenInUse',
+ *   enableBackgroundLocationUpdates: false,
+ *   locationProvider: 'auto'
+ * });
+ * ```
+ */
+export function setConfiguration(config: ModernGeolocationConfiguration): void {
+  const nativeConfig: NitroModernGeolocationConfiguration = {
+    ...config,
+    locationProvider:
+      config.locationProvider === "android"
+        ? "android_platform"
+        : config.locationProvider
+  };
+
+  NitroGeolocationHybridObject.setConfiguration(nativeConfig);
+}

package/src/api/stopObserving.ts

@@ -0,0 +1,22 @@
+import { NitroGeolocationHybridObject } from "../NitroGeolocationModule";
+
+/**
+ * Stop ALL watch subscriptions immediately.
+ *
+ * Use cases:
+ * - Emergency cleanup
+ * - App termination
+ * - User logout
+ *
+ * Note: Individual subscriptions should use unwatch() instead.
+ * @example
+ * ```tsx
+ * import { stopObserving } from 'react-native-nitro-geolocation';
+ *
+ * // Stop all location tracking
+ * stopObserving();
+ * ```
+ */
+export function stopObserving(): void {
+  NitroGeolocationHybridObject.stopObserving();
+}

package/src/api/unwatch.ts

@@ -0,0 +1,22 @@
+import { NitroGeolocationHybridObject } from "../NitroGeolocationModule";
+import { devtoolsUnwatch } from "../devtools/watchPosition";
+
+/**
+ * Stop a specific watch subscription.
+ *
+ * @param token - Subscription token from watchPosition()
+ * @example
+ * ```tsx
+ * import { watchPosition, unwatch } from 'react-native-nitro-geolocation';
+ *
+ * const token = watchPosition((position) => console.log(position));
+ * // Later...
+ * unwatch(token);
+ * ```
+ */
+export function unwatch(token: string): void {
+  if (devtoolsUnwatch(token)) {
+    return;
+  }
+  NitroGeolocationHybridObject.unwatch(token);
+}

package/src/api/watchPosition.ts

@@ -0,0 +1,43 @@
+import type {
+  LocationError,
+  LocationRequestOptions
+} from "../NitroGeolocation.nitro";
+import { NitroGeolocationHybridObject } from "../NitroGeolocationModule";
+import { isDevtoolsEnabled } from "../devtools";
+import { devtoolsWatchPosition } from "../devtools/watchPosition";
+import type { GeolocationResponse } from "../types";
+
+/**
+ * Start watching for continuous location updates.
+ *
+ * IMPORTANT: This is a LOW-LEVEL API.
+ * For React components, use useWatchPosition() hook instead.
+ *
+ * @param success - Called on each successful location update
+ * @param error - Called when an error occurs
+ * @param options - Location request options
+ * @returns Subscription token (UUID string) for cleanup
+ * @example
+ * ```tsx
+ * import { watchPosition, unwatch } from 'react-native-nitro-geolocation';
+ *
+ * const token = watchPosition(
+ *   (position) => console.log(position.coords),
+ *   (error) => console.error(error.message),
+ *   { enableHighAccuracy: true, distanceFilter: 10 }
+ * );
+ *
+ * // Later: cleanup
+ * unwatch(token);
+ * ```
+ */
+export function watchPosition(
+  success: (position: GeolocationResponse) => void,
+  error?: (error: LocationError) => void,
+  options?: LocationRequestOptions
+): string {
+  if (isDevtoolsEnabled()) {
+    return devtoolsWatchPosition(success, error);
+  }
+  return NitroGeolocationHybridObject.watchPosition(success, error, options);
+}

package/src/devtools/getCurrentPosition.ts

@@ -0,0 +1,15 @@
+import type { GeolocationResponse } from "../types";
+import { getDevtoolsState } from "./index";
+
+export function getDevtoolsCurrentPosition(): Promise<GeolocationResponse> | null {
+  const devtools = getDevtoolsState();
+  if (devtools.position) {
+    return Promise.resolve(devtools.position);
+  }
+  // Devtools not connected - throw error
+  return Promise.reject(
+    new Error(
+      "Geolocation devtools not connected. Press 'j' in Metro to open devtools and enable the geolocation plugin."
+    )
+  );
+}

package/src/devtools/index.ts

@@ -0,0 +1,23 @@
+import type { GeolocationResponse } from "../types";
+
+declare global {
+  var __geolocationDevToolsEnabled: boolean | undefined;
+  var __geolocationDevtools: DevtoolsState | undefined;
+}
+
+interface DevtoolsState {
+  position: GeolocationResponse | null;
+}
+
+export function getDevtoolsState(): DevtoolsState {
+  if (!globalThis.__geolocationDevtools) {
+    globalThis.__geolocationDevtools = {
+      position: null
+    };
+  }
+  return globalThis.__geolocationDevtools;
+}
+
+export function isDevtoolsEnabled(): boolean {
+  return globalThis.__geolocationDevToolsEnabled === true;
+}

package/src/devtools/watchPosition.ts

@@ -0,0 +1,66 @@
+import type { GeolocationError, GeolocationResponse } from "../types";
+import { getDevtoolsState } from "./index";
+
+export function devtoolsWatchPosition(
+  success: (position: GeolocationResponse) => void,
+  error?: (error: GeolocationError) => void
+): string {
+  const devtools = getDevtoolsState();
+
+  // Check if devtools has position at all
+  if (!devtools.position) {
+    // Call error callback immediately if provided
+    if (error) {
+      error({
+        code: 2, // POSITION_UNAVAILABLE
+        message:
+          "Geolocation devtools not connected. Press 'j' in Metro to open devtools and enable the geolocation plugin.",
+        PERMISSION_DENIED: 1,
+        POSITION_UNAVAILABLE: 2,
+        TIMEOUT: 3
+      });
+    }
+    // Return a dummy token that does nothing
+    return `devtools-error-${Date.now()}`;
+  }
+
+  let previousPosition = devtools.position;
+
+  // Send initial position immediately if available
+  success(devtools.position);
+
+  const interval = setInterval(() => {
+    if (devtools.position && devtools.position !== previousPosition) {
+      previousPosition = devtools.position;
+      success(devtools.position);
+    }
+  }, 100);
+
+  // Return a cleanup token
+  const token = `devtools-${Date.now()}`;
+  (globalThis as any).__devtoolsWatchers =
+    (globalThis as any).__devtoolsWatchers || {};
+  (globalThis as any).__devtoolsWatchers[token] = interval;
+
+  return token;
+}
+
+export function devtoolsUnwatch(token: string): boolean {
+  if (!token.startsWith("devtools-")) {
+    return false;
+  }
+
+  // Handle error tokens (no cleanup needed)
+  if (token.startsWith("devtools-error-")) {
+    return true;
+  }
+
+  const watchers = (globalThis as any).__devtoolsWatchers;
+  if (watchers?.[token]) {
+    clearInterval(watchers[token]);
+    delete watchers[token];
+    return true;
+  }
+
+  return false;
+}

package/src/hooks/index.ts

@@ -1,9 +1,7 @@
 /**
- * Modern React hooks for geolocation.
- * These hooks provide a declarative, React-friendly API for location services.
+ * React hook for geolocation.
+ * Provides a declarative API for continuous location tracking.
  */
 
-export * from "./useCheckPermission";
-export * from "./useRequestPermission";
-export * from "./useGetCurrentPosition";
-export * from "./useWatchPosition";
+export { useWatchPosition } from "./useWatchPosition";
+export type { UseWatchPositionOptions } from "./useWatchPosition";

package/src/hooks/useWatchPosition.ts

@@ -3,7 +3,7 @@ import type {
   LocationError,
   LocationRequestOptions
 } from "../NitroGeolocation.nitro";
-import { useGeolocationClient } from "../components/GeolocationProvider";
+import { unwatch, watchPosition } from "../api";
 import type { GeolocationResponse } from "../types";
 
 /**
@@ -51,8 +51,6 @@ export interface UseWatchPositionOptions extends LocationRequestOptions {
  * ```
  */
 export function useWatchPosition(options?: UseWatchPositionOptions) {
-  const client = useGeolocationClient();
-
   const [position, setPosition] = useState<GeolocationResponse | null>(null);
   const [isWatching, setIsWatching] = useState(false);
   const [error, setError] = useState<LocationError | null>(null);
@@ -78,7 +76,7 @@ export function useWatchPosition(options?: UseWatchPositionOptions) {
     if (!enabled) {
       // Not enabled, ensure cleanup
       if (tokenRef.current) {
-        client.unwatch(tokenRef.current);
+        unwatch(tokenRef.current);
         tokenRef.current = null;
       }
       setIsWatching(false);
@@ -89,7 +87,7 @@ export function useWatchPosition(options?: UseWatchPositionOptions) {
     setIsWatching(true);
     setError(null);
 
-    const token = client.watchPosition(
+    const token = watchPosition(
       (result: GeolocationResponse) => {
         // Success callback
         if (!isMountedRef.current) return;
@@ -109,10 +107,10 @@ export function useWatchPosition(options?: UseWatchPositionOptions) {
     // Cleanup function
     return () => {
       if (token) {
-        client.unwatch(token);
+        unwatch(token);
       }
     };
-  }, [enabled, client]); // Only re-subscribe when enabled/client changes
+  }, [enabled]); // Only re-subscribe when enabled changes
 
   // Track mount status
   useEffect(() => {

package/src/index.tsx

@@ -1,61 +1,61 @@
 /**
  * Modern Geolocation API for React Native.
  *
- * This is the main entry point for the modern, React-friendly API.
+ * This is the main entry point for the modern, functional API.
  * For legacy compatibility, use: import Geolocation from 'react-native-nitro-geolocation/compat'
  *
  * @example
  * ```tsx
  * import {
- *   GeolocationClient,
- *   GeolocationClientProvider,
- *   useRequestPermission,
- *   useGetCurrentPosition,
+ *   setConfiguration,
+ *   getCurrentPosition,
+ *   requestPermission,
  *   useWatchPosition
  * } from 'react-native-nitro-geolocation';
  *
- * // Create GeolocationClient instance
- * const geolocationClient = new GeolocationClient({
+ * // Set configuration at app startup
+ * setConfiguration({
  *   authorizationLevel: 'whenInUse',
  *   enableBackgroundLocationUpdates: false,
  *   locationProvider: 'auto'
  * });
  *
- * function App() {
- *   return (
- *     <GeolocationClientProvider client={geolocationClient}>
- *       <YourApp />
- *     </GeolocationClientProvider>
- *   );
+ * // Request permission
+ * async function setup() {
+ *   const status = await requestPermission();
+ *   if (status === 'granted') {
+ *     const position = await getCurrentPosition({ enableHighAccuracy: true });
+ *     console.log('Position:', position);
+ *   }
  * }
  *
- * function LocationButton() {
- *   const { getCurrentPosition } = useGetCurrentPosition();
- *   const [loading, setLoading] = useState(false);
+ * // Continuous tracking in React component
+ * function LiveTracking() {
+ *   const { position, error, isWatching } = useWatchPosition({
+ *     enabled: true,
+ *     enableHighAccuracy: true,
+ *     distanceFilter: 10
+ *   });
  *
- *   const handlePress = async () => {
- *     setLoading(true);
- *     try {
- *       const pos = await getCurrentPosition({ enableHighAccuracy: true });
- *       console.log('Position:', pos);
- *     } catch (error) {
- *       console.error('Error:', error);
- *     } finally {
- *       setLoading(false);
- *     }
- *   };
+ *   if (!isWatching) return <Text>Not watching</Text>;
+ *   if (error) return <Text>Error: {error.message}</Text>;
+ *   if (!position) return <Text>Waiting...</Text>;
  *
- *   return <Button onPress={handlePress} disabled={loading} />;
+ *   return <Text>Lat: {position.coords.latitude}</Text>;
  * }
  * ```
  */
 
-// Core
-export { GeolocationClient } from "./GeolocationClient";
-export type { GeolocationClientConfig } from "./GeolocationClient";
-
-// Components
-export * from "./components";
+// Core API functions
+export {
+  setConfiguration,
+  checkPermission,
+  requestPermission,
+  getCurrentPosition,
+  watchPosition,
+  unwatch,
+  stopObserving
+} from "./api";
 
 // Hooks
 export * from "./hooks";

package/src/GeolocationClient.ts

@@ -1,116 +0,0 @@
-import type {
-  LocationError,
-  LocationRequestOptions,
-  ModernGeolocationConfiguration as NitroModernGeolocationConfiguration,
-  PermissionStatus
-} from "./NitroGeolocation.nitro";
-import { NitroGeolocationHybridObject } from "./NitroGeolocationModule";
-import type { ModernGeolocationConfiguration } from "./types";
-import type { GeolocationResponse } from "./types";
-
-export interface GeolocationClientConfig
-  extends ModernGeolocationConfiguration {}
-
-/**
- * GeolocationClient provides direct access to geolocation methods.
- *
- * Usage:
- * ```tsx
- * // With provider
- * const client = new GeolocationClient({ locationProvider: 'auto' });
- * <GeolocationClientProvider client={client}>
- *   <App />
- * </GeolocationClientProvider>
- *
- * // Without provider
- * const standaloneClient = new GeolocationClient();
- * await standaloneClient.getCurrentPosition();
- * ```
- */
-export class GeolocationClient {
-  private config: GeolocationClientConfig;
-
-  constructor(config: GeolocationClientConfig = {}) {
-    this.config = config;
-
-    // Set configuration on Nitro module
-    if (Object.keys(config).length > 0) {
-      const nativeConfig: NitroModernGeolocationConfiguration = {
-        ...config,
-        locationProvider:
-          config.locationProvider === "android"
-            ? "android_platform"
-            : config.locationProvider
-      };
-
-      NitroGeolocationHybridObject.setConfiguration(nativeConfig);
-    }
-  }
-
-  /**
-   * Check current location permission status.
-   * Does NOT request permission, only checks current state.
-   */
-  checkPermission = (): Promise<PermissionStatus> => {
-    return NitroGeolocationHybridObject.checkPermission();
-  };
-
-  /**
-   * Request location permission from the user.
-   * Shows system permission dialog if not yet determined.
-   */
-  requestPermission = (): Promise<PermissionStatus> => {
-    return NitroGeolocationHybridObject.requestPermission();
-  };
-
-  /**
-   * Get current location (one-time request).
-   *
-   * @param options - Location request options
-   * @returns Promise resolving to current position
-   */
-  getCurrentPosition = (
-    options?: LocationRequestOptions
-  ): Promise<GeolocationResponse> => {
-    return NitroGeolocationHybridObject.getCurrentPosition(options);
-  };
-
-  /**
-   * Start watching for continuous location updates.
-   *
-   * @param success - Called on each successful location update
-   * @param error - Called when an error occurs
-   * @param options - Location request options
-   * @returns Subscription token (UUID string) for cleanup
-   */
-  watchPosition = (
-    success: (position: GeolocationResponse) => void,
-    error?: (error: LocationError) => void,
-    options?: LocationRequestOptions
-  ): string => {
-    return NitroGeolocationHybridObject.watchPosition(success, error, options);
-  };
-
-  /**
-   * Stop a specific watch subscription.
-   *
-   * @param token - Subscription token from watchPosition()
-   */
-  unwatch = (token: string): void => {
-    NitroGeolocationHybridObject.unwatch(token);
-  };
-
-  /**
-   * Stop ALL watch subscriptions immediately.
-   */
-  stopObserving = (): void => {
-    NitroGeolocationHybridObject.stopObserving();
-  };
-
-  /**
-   * Get the current client configuration.
-   */
-  getConfig = (): Readonly<GeolocationClientConfig> => {
-    return { ...this.config };
-  };
-}

package/src/components/GeolocationProvider.tsx

@@ -1,91 +0,0 @@
-import React, { createContext, useContext } from "react";
-import type { GeolocationClient } from "../GeolocationClient";
-
-/**
- * Geolocation context value.
- */
-export interface GeolocationContextValue {
-  client: GeolocationClient;
-}
-
-/**
- * Geolocation context.
- */
-const GeolocationContext = createContext<GeolocationContextValue | null>(null);
-
-/**
- * Hook to access GeolocationClient from context.
- * Throws error if used outside GeolocationClientProvider.
- */
-export function useGeolocationClient(): GeolocationClient {
-  const context = useContext(GeolocationContext);
-
-  if (!context) {
-    throw new Error(
-      "useGeolocationClient must be used within GeolocationClientProvider. " +
-        "Wrap your component with <GeolocationClientProvider client={...}> at the root level."
-    );
-  }
-
-  return context.client;
-}
-
-/**
- * Props for GeolocationProvider component.
- */
-export interface GeolocationProviderProps {
-  /**
-   * GeolocationClient instance (required).
-   * Create with: new GeolocationClient({...config})
-   */
-  client: GeolocationClient;
-
-  /**
-   * Child components that can use geolocation hooks.
-   */
-  children: React.ReactNode;
-}
-
-/**
- * Provider component for GeolocationClient.
- *
- * This component should wrap your app at the root level.
- * It provides a GeolocationClient instance to all child components via context.
- *
- * @example
- * ```tsx
- * // Create client instance
- * const geolocationClient = new GeolocationClient({
- *   authorizationLevel: 'whenInUse',
- *   enableBackgroundLocationUpdates: false,
- *   locationProvider: 'auto'
- * });
- *
- * function App() {
- *   return (
- *     <GeolocationClientProvider client={geolocationClient}>
- *       <NavigationContainer>
- *         <YourApp />
- *       </NavigationContainer>
- *     </GeolocationClientProvider>
- *   );
- * }
- * ```
- */
-export function GeolocationProvider({
-  client,
-  children
-}: GeolocationProviderProps) {
-  const value: GeolocationContextValue = {
-    client
-  };
-
-  return (
-    <GeolocationContext.Provider value={value}>
-      {children}
-    </GeolocationContext.Provider>
-  );
-}
-
-// Modern alias (preferred)
-export const GeolocationClientProvider = GeolocationProvider;

package/src/components/index.ts

@@ -1,13 +0,0 @@
-/**
- * React components for geolocation.
- */
-
-export {
-  GeolocationProvider,
-  GeolocationClientProvider,
-  useGeolocationClient
-} from "./GeolocationProvider";
-export type {
-  GeolocationProviderProps,
-  GeolocationContextValue
-} from "./GeolocationProvider";

package/src/hooks/useCheckPermission.ts

@@ -1,46 +0,0 @@
-import type { PermissionStatus } from "../NitroGeolocation.nitro";
-import { useGeolocationClient } from "../components/GeolocationProvider";
-
-/**
- * Hook that returns a function to check current location permission status.
- * Does NOT request permission, only checks current state.
- *
- * Must be used within GeolocationClientProvider.
- *
- * @returns Object containing checkPermission function
- *
- * @example
- * ```tsx
- * const geolocationClient = new GeolocationClient({...config});
- *
- * function App() {
- *   return (
- *     <GeolocationClientProvider client={geolocationClient}>
- *       <MyComponent />
- *     </GeolocationClientProvider>
- *   );
- * }
- *
- * function MyComponent() {
- *   const { checkPermission } = useCheckPermission();
- *
- *   const handleCheck = async () => {
- *     const status = await checkPermission();
- *     if (status === 'granted') {
- *       // Can use location
- *     }
- *   };
- *
- *   return <Button onPress={handleCheck} />;
- * }
- * ```
- */
-export function useCheckPermission() {
-  const client = useGeolocationClient();
-
-  return {
-    checkPermission: (): Promise<PermissionStatus> => {
-      return client.checkPermission();
-    }
-  };
-}

package/src/hooks/useGetCurrentPosition.ts

@@ -1,140 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from "react";
-import type {
-  LocationError,
-  LocationRequestOptions
-} from "../NitroGeolocation.nitro";
-import { useGeolocationClient } from "../components/GeolocationProvider";
-import type { GeolocationResponse } from "../types";
-
-/**
- * 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.
- *
- * @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 {
- *     position,
- *     isLoading,
- *     isError,
- *     error,
- *     refetch
- *   } = useGetCurrentPosition({
- *     enabled: true,
- *     enableHighAccuracy: true,
- *   });
- *
- *   if (isLoading) return <Text>Loading...</Text>;
- *   if (isError) return <Text>Error: {error?.message}</Text>;
- *   if (!position) return null;
- *
- *   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(options?: UseGetCurrentPositionOptions) {
-  const client = useGeolocationClient();
-
-  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,98 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from "react";
-import type {
-  LocationError,
-  PermissionStatus
-} from "../NitroGeolocation.nitro";
-import { useGeolocationClient } from "../components/GeolocationProvider";
-
-/**
- * Hook for requesting location permission in Mutation style.
- * Provides pending, error states, and status similar to TanStack Query mutations.
- *
- * @returns Object containing requestPermission function, status, and state flags
- *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const {
- *     requestPermission,
- *     status,
- *     isPending,
- *     isError,
- *     error
- *   } = useRequestPermission();
- *
- *   const handleRequest = async () => {
- *     const result = await requestPermission();
- *     if (result === 'granted') {
- *       console.log('Permission granted!');
- *     }
- *   };
- *
- *   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();
-
-  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
-  };
-}