react-native-nitro-geolocation 0.1.2 → 0.2.0

package/nitrogen/generated/shared/c++/PermissionStatus.hpp

@@ -0,0 +1,84 @@
+///
+/// PermissionStatus.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::nitrogeolocation {
+
+  /**
+   * An enum which can be represented as a JavaScript union (PermissionStatus).
+   */
+  enum class PermissionStatus {
+    GRANTED      SWIFT_NAME(granted) = 0,
+    DENIED      SWIFT_NAME(denied) = 1,
+    RESTRICTED      SWIFT_NAME(restricted) = 2,
+    UNDETERMINED      SWIFT_NAME(undetermined) = 3,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::nitrogeolocation
+
+namespace margelo::nitro {
+
+  // C++ PermissionStatus <> JS PermissionStatus (union)
+  template <>
+  struct JSIConverter<margelo::nitro::nitrogeolocation::PermissionStatus> final {
+    static inline margelo::nitro::nitrogeolocation::PermissionStatus fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("granted"): return margelo::nitro::nitrogeolocation::PermissionStatus::GRANTED;
+        case hashString("denied"): return margelo::nitro::nitrogeolocation::PermissionStatus::DENIED;
+        case hashString("restricted"): return margelo::nitro::nitrogeolocation::PermissionStatus::RESTRICTED;
+        case hashString("undetermined"): return margelo::nitro::nitrogeolocation::PermissionStatus::UNDETERMINED;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum PermissionStatus - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::nitrogeolocation::PermissionStatus arg) {
+      switch (arg) {
+        case margelo::nitro::nitrogeolocation::PermissionStatus::GRANTED: return JSIConverter<std::string>::toJSI(runtime, "granted");
+        case margelo::nitro::nitrogeolocation::PermissionStatus::DENIED: return JSIConverter<std::string>::toJSI(runtime, "denied");
+        case margelo::nitro::nitrogeolocation::PermissionStatus::RESTRICTED: return JSIConverter<std::string>::toJSI(runtime, "restricted");
+        case margelo::nitro::nitrogeolocation::PermissionStatus::UNDETERMINED: return JSIConverter<std::string>::toJSI(runtime, "undetermined");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert PermissionStatus to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("granted"):
+        case hashString("denied"):
+        case hashString("restricted"):
+        case hashString("undetermined"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/RNConfigurationInternal.hpp

@@ -17,6 +17,16 @@
 #else
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
 
 // Forward declaration of `AuthorizationLevelInternal` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { enum class AuthorizationLevelInternal; }
@@ -32,7 +42,7 @@ namespace margelo::nitro::nitrogeolocation {
   /**
    * A struct which can be represented as a JavaScript object (RNConfigurationInternal).
    */
-  struct RNConfigurationInternal {
+  struct RNConfigurationInternal final {
   public:
     bool skipPermissionRequests     SWIFT_PRIVATE;
     std::optional<AuthorizationLevelInternal> authorizationLevel     SWIFT_PRIVATE;
@@ -42,6 +52,9 @@ namespace margelo::nitro::nitrogeolocation {
   public:
     RNConfigurationInternal() = default;
     explicit RNConfigurationInternal(bool skipPermissionRequests, std::optional<AuthorizationLevelInternal> authorizationLevel, std::optional<bool> enableBackgroundLocationUpdates, std::optional<LocationProviderInternal> locationProvider): skipPermissionRequests(skipPermissionRequests), authorizationLevel(authorizationLevel), enableBackgroundLocationUpdates(enableBackgroundLocationUpdates), locationProvider(locationProvider) {}
+
+  public:
+    friend bool operator==(const RNConfigurationInternal& lhs, const RNConfigurationInternal& rhs) = default;
   };
 
 } // namespace margelo::nitro::nitrogeolocation
@@ -54,18 +67,18 @@ namespace margelo::nitro {
     static inline margelo::nitro::nitrogeolocation::RNConfigurationInternal fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
       return margelo::nitro::nitrogeolocation::RNConfigurationInternal(
-        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "skipPermissionRequests")),
-        JSIConverter<std::optional<margelo::nitro::nitrogeolocation::AuthorizationLevelInternal>>::fromJSI(runtime, obj.getProperty(runtime, "authorizationLevel")),
-        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "enableBackgroundLocationUpdates")),
-        JSIConverter<std::optional<margelo::nitro::nitrogeolocation::LocationProviderInternal>>::fromJSI(runtime, obj.getProperty(runtime, "locationProvider"))
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "skipPermissionRequests"))),
+        JSIConverter<std::optional<margelo::nitro::nitrogeolocation::AuthorizationLevelInternal>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "authorizationLevel"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "enableBackgroundLocationUpdates"))),
+        JSIConverter<std::optional<margelo::nitro::nitrogeolocation::LocationProviderInternal>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "locationProvider")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitrogeolocation::RNConfigurationInternal& arg) {
       jsi::Object obj(runtime);
-      obj.setProperty(runtime, "skipPermissionRequests", JSIConverter<bool>::toJSI(runtime, arg.skipPermissionRequests));
-      obj.setProperty(runtime, "authorizationLevel", JSIConverter<std::optional<margelo::nitro::nitrogeolocation::AuthorizationLevelInternal>>::toJSI(runtime, arg.authorizationLevel));
-      obj.setProperty(runtime, "enableBackgroundLocationUpdates", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.enableBackgroundLocationUpdates));
-      obj.setProperty(runtime, "locationProvider", JSIConverter<std::optional<margelo::nitro::nitrogeolocation::LocationProviderInternal>>::toJSI(runtime, arg.locationProvider));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "skipPermissionRequests"), JSIConverter<bool>::toJSI(runtime, arg.skipPermissionRequests));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "authorizationLevel"), JSIConverter<std::optional<margelo::nitro::nitrogeolocation::AuthorizationLevelInternal>>::toJSI(runtime, arg.authorizationLevel));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "enableBackgroundLocationUpdates"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.enableBackgroundLocationUpdates));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "locationProvider"), JSIConverter<std::optional<margelo::nitro::nitrogeolocation::LocationProviderInternal>>::toJSI(runtime, arg.locationProvider));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -73,10 +86,13 @@ namespace margelo::nitro {
         return false;
       }
       jsi::Object obj = value.getObject(runtime);
-      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "skipPermissionRequests"))) return false;
-      if (!JSIConverter<std::optional<margelo::nitro::nitrogeolocation::AuthorizationLevelInternal>>::canConvert(runtime, obj.getProperty(runtime, "authorizationLevel"))) return false;
-      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "enableBackgroundLocationUpdates"))) return false;
-      if (!JSIConverter<std::optional<margelo::nitro::nitrogeolocation::LocationProviderInternal>>::canConvert(runtime, obj.getProperty(runtime, "locationProvider"))) return false;
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "skipPermissionRequests")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::nitrogeolocation::AuthorizationLevelInternal>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "authorizationLevel")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "enableBackgroundLocationUpdates")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::nitrogeolocation::LocationProviderInternal>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "locationProvider")))) return false;
       return true;
     }
   };

package/package.json

@@ -1,9 +1,19 @@
 {
   "name": "react-native-nitro-geolocation",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "⚡🚀Blazing-fast geolocation for React Native powered by Nitro Modules",
   "main": "src/index",
   "source": "src/index",
+  "exports": {
+    ".": {
+      "types": "./src/index.tsx",
+      "default": "./src/index.tsx"
+    },
+    "./compat": {
+      "types": "./src/compat/index.tsx",
+      "default": "./src/compat/index.tsx"
+    }
+  },
   "codegenConfig": {
     "name": "NitroGeolocationSpec",
     "type": "modules",
@@ -26,7 +36,7 @@
     "android/fix-prefab.gradle",
     "android/gradle.properties",
     "android/CMakeLists.txt",
-    "android/src",
+    "android/src/**/*",
     "ios/**/*.h",
     "ios/**/*.m",
     "ios/**/*.mm",
@@ -43,18 +53,17 @@
     "@types/react-test-renderer": "^18.0.0",
     "react": "19.1.0",
     "react-native": "0.81.1",
-    "react-native-nitro-modules": "^0.29.6",
+    "react-native-nitro-modules": "0.32.0",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "react-native-nitro-modules": "*"
+    "react": ">=18.0.0",
+    "react-native": ">=0.75.0",
+    "react-native-nitro-modules": ">=0.32.0"
   },
   "create-react-native-library": {
     "languages": "kotlin-swift",
     "type": "nitro-module",
     "version": "0.54.3"
-  },
-  "installConfig": {
-    "hoistingLimits": "workspaces"
   }
 }

package/src/GeolocationClient.ts

@@ -0,0 +1,116 @@
+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/NitroGeolocation.nitro.ts

@@ -1,41 +1,188 @@
 import type { HybridObject } from "react-native-nitro-modules";
-import type {
-  GeolocationError,
-  GeolocationOptions,
-  GeolocationResponse
-} from "./types";
-
-// Configuration - Internal (for C++ codegen, avoiding ANDROID macro conflict)
-export type AuthorizationLevelInternal = "always" | "whenInUse" | "auto";
-export type LocationProviderInternal =
-  | "playServices"
-  | "android_platform"
-  | "auto";
-
-export interface RNConfigurationInternal {
-  skipPermissionRequests: boolean;
-  authorizationLevel?: AuthorizationLevelInternal;
+import type { GeolocationResponse } from "./types";
+
+/**
+ * Permission status for location services.
+ * Matches native permission states across iOS and Android.
+ */
+export type PermissionStatus =
+  | "granted" // User has granted location permission
+  | "denied" // User has denied permission
+  | "restricted" // Permission is restricted (iOS parental controls)
+  | "undetermined"; // Permission not yet requested
+
+/**
+ * iOS authorization level.
+ */
+export type AuthorizationLevel = "always" | "whenInUse" | "auto";
+
+/**
+ * Android location provider (internal).
+ * Note: Use "android_platform" instead of "android" to avoid C++ macro conflicts.
+ */
+export type LocationProvider = "playServices" | "android_platform" | "auto";
+
+/**
+ * Global configuration for geolocation services.
+ * Set once via GeolocationProvider.
+ */
+export interface ModernGeolocationConfiguration {
+  /**
+   * Automatically request location permission when GeolocationProvider mounts.
+   * When true, permission is requested immediately on app start.
+   * When false, you must manually call useRequestPermission().
+   * @default false
+   */
+  autoRequestPermission?: boolean;
+
+  /**
+   * iOS: Authorization level
+   * - 'always': Request "Always" permission (background + foreground)
+   * - 'whenInUse': Request "When In Use" permission (foreground only)
+   * - 'auto': Auto-detect from Info.plist keys
+   */
+  authorizationLevel?: AuthorizationLevel;
+
+  /**
+   * iOS: Enable background location updates.
+   * Requires "UIBackgroundModes" with "location" in Info.plist.
+   */
   enableBackgroundLocationUpdates?: boolean;
-  locationProvider?: LocationProviderInternal;
+
+  /**
+   * Android: Location provider
+   * - 'playServices': Use Google Play Services (fused location)
+   * - 'android_platform': Use Android platform LocationManager
+   * - 'auto': Auto-select (prefer Play Services if available)
+   */
+  locationProvider?: LocationProvider;
+}
+
+/**
+ * Options for location requests.
+ */
+export interface LocationRequestOptions {
+  /** Timeout in milliseconds (default: 600000 / 10 minutes) */
+  timeout?: number;
+
+  /** Maximum age of cached location in milliseconds (default: 0) */
+  maximumAge?: number;
+
+  /** Enable high accuracy mode (GPS) */
+  enableHighAccuracy?: boolean;
+
+  /** Minimum time interval between updates in milliseconds (watch only) */
+  interval?: number;
+
+  /** Fastest interval for updates in milliseconds (Android watch only) */
+  fastestInterval?: number;
+
+  /** Minimum distance change in meters for updates (watch only) */
+  distanceFilter?: number;
+
+  /** Use significant location changes mode (iOS watch only) */
+  useSignificantChanges?: boolean;
 }
 
+/**
+ * Location error structure.
+ */
+export interface LocationError {
+  code: number; // 1: PERMISSION_DENIED, 2: POSITION_UNAVAILABLE, 3: TIMEOUT
+  message: string;
+}
+
+/**
+ * Modern Geolocation Nitro Module.
+ *
+ * Key Features:
+ * - Promise-based for async operations
+ * - First-class function callbacks for continuous updates
+ * - Token-based subscriptions (internal use only)
+ * - Type-safe across JS ↔ Native boundary
+ */
 export interface NitroGeolocation
   extends HybridObject<{ ios: "swift"; android: "kotlin" }> {
-  setRNConfiguration(config: RNConfigurationInternal): void;
-  requestAuthorization(
-    success?: () => void,
-    error?: (error: GeolocationError) => void
-  ): void;
+  /**
+   * Set global geolocation configuration.
+   * Should be called once at app startup via GeolocationProvider.
+   *
+   * @param config - Platform-specific configuration
+   */
+  setConfiguration(config: ModernGeolocationConfiguration): void;
+
+  /**
+   * Check current location permission status.
+   * Does NOT request permission, only checks current state.
+   *
+   * @returns Promise resolving to current permission status
+   */
+  checkPermission(): Promise<PermissionStatus>;
+
+  /**
+   * Request location permission from the user.
+   * Shows system permission dialog if not yet determined.
+   *
+   * @returns Promise resolving to new permission status
+   */
+  requestPermission(): Promise<PermissionStatus>;
+
+  /**
+   * 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
+   */
   getCurrentPosition(
-    success: (position: GeolocationResponse) => void,
-    error?: (error: GeolocationError) => void,
-    options?: GeolocationOptions
-  ): void;
+    options?: LocationRequestOptions
+  ): Promise<GeolocationResponse>;
+
+  /**
+   * Start watching for continuous location updates.
+   *
+   * IMPORTANT: This is a LOW-LEVEL API.
+   * Users should use useWatchPosition() hook instead.
+   *
+   * Nitro Advantage: Functions are first-class citizens!
+   * We can store callbacks and call them multiple times,
+   * unlike Turbo Modules which require Events.
+   *
+   * @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: GeolocationError) => void,
-    options?: GeolocationOptions
-  ): number;
-  clearWatch(watchId: number): void;
+    error?: (error: LocationError) => void,
+    options?: LocationRequestOptions
+  ): string;
+
+  /**
+   * Stop a specific watch subscription.
+   *
+   * IMPORTANT: This is a LOW-LEVEL API.
+   * Cleanup is handled automatically by useWatchPosition() hook.
+   *
+   * @param token - Subscription token from watchPosition()
+   */
+  unwatch(token: string): void;
+
+  /**
+   * Stop ALL watch subscriptions immediately.
+   *
+   * Use cases:
+   * - Emergency cleanup
+   * - App termination
+   * - User logout
+   *
+   * Note: Individual subscriptions should use unwatch() instead.
+   */
   stopObserving(): void;
 }

package/src/NitroGeolocationCompat.nitro.ts

@@ -0,0 +1,41 @@
+import type { HybridObject } from "react-native-nitro-modules";
+import type {
+  GeolocationError,
+  GeolocationOptions,
+  GeolocationResponse
+} from "./types";
+
+// Configuration - Internal (for C++ codegen, avoiding ANDROID macro conflict)
+export type AuthorizationLevelInternal = "always" | "whenInUse" | "auto";
+export type LocationProviderInternal =
+  | "playServices"
+  | "android_platform"
+  | "auto";
+
+export interface RNConfigurationInternal {
+  skipPermissionRequests: boolean;
+  authorizationLevel?: AuthorizationLevelInternal;
+  enableBackgroundLocationUpdates?: boolean;
+  locationProvider?: LocationProviderInternal;
+}
+
+export interface NitroGeolocationCompat
+  extends HybridObject<{ ios: "swift"; android: "kotlin" }> {
+  setRNConfiguration(config: RNConfigurationInternal): void;
+  requestAuthorization(
+    success?: () => void,
+    error?: (error: GeolocationError) => void
+  ): void;
+  getCurrentPosition(
+    success: (position: GeolocationResponse) => void,
+    error?: (error: GeolocationError) => void,
+    options?: GeolocationOptions
+  ): void;
+  watchPosition(
+    success: (position: GeolocationResponse) => void,
+    error?: (error: GeolocationError) => void,
+    options?: GeolocationOptions
+  ): number;
+  clearWatch(watchId: number): void;
+  stopObserving(): void;
+}

package/src/NitroGeolocationModule.ts

@@ -1,5 +1,11 @@
 import { NitroModules } from "react-native-nitro-modules";
 import type { NitroGeolocation } from "./NitroGeolocation.nitro";
+import type { NitroGeolocationCompat } from "./NitroGeolocationCompat.nitro";
 
 export const NitroGeolocationHybridObject =
   NitroModules.createHybridObject<NitroGeolocation>("NitroGeolocation");
+
+export const NitroGeolocationHybridCompatObject =
+  NitroModules.createHybridObject<NitroGeolocationCompat>(
+    "NitroGeolocationCompat"
+  );

package/src/compat/clearWatch.ts

@@ -0,0 +1,9 @@
+import { NitroGeolocationHybridCompatObject } from "../NitroGeolocationModule";
+/**
+ * Clears a specific watch session identified by watchId.
+ *
+ * @param watchId - The ID returned by watchPosition()
+ */
+export function clearWatch(watchId: number): void {
+  NitroGeolocationHybridCompatObject.clearWatch(watchId);
+}

package/src/{getCurrentPosition.ts → compat/getCurrentPosition.ts}

@@ -1,14 +1,18 @@
-import { NitroGeolocationHybridObject } from "./NitroGeolocationModule";
+import { NitroGeolocationHybridCompatObject } from "../NitroGeolocationModule";
 import type {
   GeolocationError,
   GeolocationOptions,
   GeolocationResponse
-} from "./types";
+} from "../types";
 
 export function getCurrentPosition(
   success: (position: GeolocationResponse) => void,
   error?: (error: GeolocationError) => void,
   options?: GeolocationOptions
 ): void {
-  NitroGeolocationHybridObject.getCurrentPosition(success, error, options);
+  NitroGeolocationHybridCompatObject.getCurrentPosition(
+    success,
+    error,
+    options
+  );
 }

package/src/compat/index.tsx

@@ -0,0 +1,34 @@
+// Export methods
+export { clearWatch } from "./clearWatch";
+export { getCurrentPosition } from "./getCurrentPosition";
+export { requestAuthorization } from "./requestAuthorization";
+export { setRNConfiguration } from "./setRNConfiguration";
+export { stopObserving } from "./stopObserving";
+export { watchPosition } from "./watchPosition";
+
+// Default export for compatibility
+import { clearWatch } from "./clearWatch";
+import { getCurrentPosition } from "./getCurrentPosition";
+import { requestAuthorization } from "./requestAuthorization";
+import { setRNConfiguration } from "./setRNConfiguration";
+import { stopObserving } from "./stopObserving";
+import { watchPosition } from "./watchPosition";
+
+const Geolocation = {
+  setRNConfiguration,
+  requestAuthorization,
+  getCurrentPosition,
+  watchPosition,
+  clearWatch,
+  stopObserving
+};
+
+// Export types
+export type {
+  GeolocationConfiguration,
+  GeolocationResponse,
+  GeolocationError,
+  GeolocationOptions
+} from "../types";
+
+export default Geolocation;