react-native-nitro-geolocation 0.2.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-geolocation",
-  "version": "0.2.0",
+  "version": "0.4.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,35 @@
+import type { LocationRequestOptions } from "../NitroGeolocation.nitro";
+import { NitroGeolocationHybridObject } from "../NitroGeolocationModule";
+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> {
+  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,18 @@
+import { NitroGeolocationHybridObject } from "../NitroGeolocationModule";
+
+/**
+ * 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 {
+  NitroGeolocationHybridObject.unwatch(token);
+}

package/src/api/watchPosition.ts

@@ -0,0 +1,38 @@
+import type {
+  LocationError,
+  LocationRequestOptions
+} from "../NitroGeolocation.nitro";
+import { NitroGeolocationHybridObject } from "../NitroGeolocationModule";
+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 {
+  return NitroGeolocationHybridObject.watchPosition(success, error, options);
+}

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 { NitroGeolocationHybridObject } from "../NitroGeolocationModule";
 import type { GeolocationResponse } from "../types";
 
 /**
@@ -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,22 +39,21 @@ 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>
  *   );
  * }
  * ```
  */
 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,34 +61,45 @@ 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) {
-        client.unwatch(tokenRef.current);
+        NitroGeolocationHybridObject.unwatch(tokenRef.current);
         tokenRef.current = null;
       }
       setIsWatching(false);
       return;
     }
 
-    // Start watching
+    // Start watching with latest options
     setIsWatching(true);
+    setError(null);
 
-    const token = client.watchPosition(
-      (position: GeolocationResponse) => {
+    const token = NitroGeolocationHybridObject.watchPosition(
+      (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;
@@ -97,20 +107,10 @@ export function useWatchPosition(options?: UseWatchPositionOptions) {
     // Cleanup function
     return () => {
       if (token) {
-        client.unwatch(token);
+        NitroGeolocationHybridObject.unwatch(token);
       }
     };
-  }, [
-    client,
-    options?.enabled,
-    options?.enableHighAccuracy,
-    options?.distanceFilter,
-    options?.interval,
-    options?.fastestInterval,
-    options?.timeout,
-    options?.maximumAge,
-    options?.useSignificantChanges
-  ]);
+  }, [enabled]); // Only re-subscribe when enabled changes
 
   // Track mount status
   useEffect(() => {
@@ -121,7 +121,8 @@ export function useWatchPosition(options?: UseWatchPositionOptions) {
   }, []);
 
   return {
-    data,
+    position,
+    error,
     isWatching
   };
 }

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,44 +0,0 @@
-import type { 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.
- *
- * @returns Object containing getCurrentPosition function
- * @throws LocationError with code and message
- *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const { getCurrentPosition } = useGetCurrentPosition();
- *
- *   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);
- *     }
- *   };
- *
- *   return <Button onPress={handleGetLocation} />;
- * }
- * ```
- */
-export function useGetCurrentPosition() {
-  const client = useGeolocationClient();
-
-  return {
-    getCurrentPosition: (
-      options?: LocationRequestOptions
-    ): Promise<GeolocationResponse> => {
-      return client.getCurrentPosition(options);
-    }
-  };
-}

package/src/hooks/useRequestPermission.ts

@@ -1,38 +0,0 @@
-import type { 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.
- *
- * @returns Object containing requestPermission function
- *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const { requestPermission } = useRequestPermission();
- *
- *   const handleRequest = async () => {
- *     try {
- *       const status = await requestPermission();
- *       if (status === 'granted') {
- *         console.log('Permission granted!');
- *       }
- *     } catch (error) {
- *       console.error('Permission error:', error);
- *     }
- *   };
- *
- *   return <Button onPress={handleRequest} />;
- * }
- * ```
- */
-export function useRequestPermission() {
-  const client = useGeolocationClient();
-
-  return {
-    requestPermission: (): Promise<PermissionStatus> => {
-      return client.requestPermission();
-    }
-  };
-}