react-native-nitro-geolocation 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-geolocation",
-  "version": "0.4.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/getCurrentPosition.ts

@@ -1,5 +1,7 @@
 import type { LocationRequestOptions } from "../NitroGeolocation.nitro";
 import { NitroGeolocationHybridObject } from "../NitroGeolocationModule";
+import { isDevtoolsEnabled } from "../devtools";
+import { getDevtoolsCurrentPosition } from "../devtools/getCurrentPosition";
 import type { GeolocationResponse } from "../types";
 
 /**
@@ -31,5 +33,11 @@ import type { GeolocationResponse } from "../types";
 export function getCurrentPosition(
   options?: LocationRequestOptions
 ): Promise<GeolocationResponse> {
+  if (isDevtoolsEnabled()) {
+    const devtoolsResult = getDevtoolsCurrentPosition();
+    if (devtoolsResult) {
+      return devtoolsResult;
+    }
+  }
   return NitroGeolocationHybridObject.getCurrentPosition(options);
 }

package/src/api/unwatch.ts

@@ -1,4 +1,5 @@
 import { NitroGeolocationHybridObject } from "../NitroGeolocationModule";
+import { devtoolsUnwatch } from "../devtools/watchPosition";
 
 /**
  * Stop a specific watch subscription.
@@ -14,5 +15,8 @@ import { NitroGeolocationHybridObject } from "../NitroGeolocationModule";
  * ```
  */
 export function unwatch(token: string): void {
+  if (devtoolsUnwatch(token)) {
+    return;
+  }
   NitroGeolocationHybridObject.unwatch(token);
 }

package/src/api/watchPosition.ts

@@ -3,6 +3,8 @@ import type {
   LocationRequestOptions
 } from "../NitroGeolocation.nitro";
 import { NitroGeolocationHybridObject } from "../NitroGeolocationModule";
+import { isDevtoolsEnabled } from "../devtools";
+import { devtoolsWatchPosition } from "../devtools/watchPosition";
 import type { GeolocationResponse } from "../types";
 
 /**
@@ -34,5 +36,8 @@ export function watchPosition(
   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/useWatchPosition.ts

@@ -3,7 +3,7 @@ import type {
   LocationError,
   LocationRequestOptions
 } from "../NitroGeolocation.nitro";
-import { NitroGeolocationHybridObject } from "../NitroGeolocationModule";
+import { unwatch, watchPosition } from "../api";
 import type { GeolocationResponse } from "../types";
 
 /**
@@ -76,7 +76,7 @@ export function useWatchPosition(options?: UseWatchPositionOptions) {
     if (!enabled) {
       // Not enabled, ensure cleanup
       if (tokenRef.current) {
-        NitroGeolocationHybridObject.unwatch(tokenRef.current);
+        unwatch(tokenRef.current);
         tokenRef.current = null;
       }
       setIsWatching(false);
@@ -87,7 +87,7 @@ export function useWatchPosition(options?: UseWatchPositionOptions) {
     setIsWatching(true);
     setError(null);
 
-    const token = NitroGeolocationHybridObject.watchPosition(
+    const token = watchPosition(
       (result: GeolocationResponse) => {
         // Success callback
         if (!isMountedRef.current) return;
@@ -107,7 +107,7 @@ export function useWatchPosition(options?: UseWatchPositionOptions) {
     // Cleanup function
     return () => {
       if (token) {
-        NitroGeolocationHybridObject.unwatch(token);
+        unwatch(token);
       }
     };
   }, [enabled]); // Only re-subscribe when enabled changes