react-native-nitro-geolocation 1.2.5 → 1.3.0

package/src/web/browser.ts

@@ -0,0 +1,171 @@
+import type {
+  LocationError,
+  LocationRequestOptions
+} from "../NitroGeolocation.nitro";
+import type { GeolocationResponse } from "../publicTypes";
+import { LocationErrorCode, createLocationError } from "../utils/errors";
+
+type BrowserPermissionState = "granted" | "denied" | "prompt";
+
+type BrowserPermissionStatus = {
+  state: BrowserPermissionState;
+};
+
+type BrowserPermissions = {
+  query(descriptor: { name: "geolocation" }): Promise<BrowserPermissionStatus>;
+};
+
+type BrowserCoordinates = {
+  latitude: number;
+  longitude: number;
+  altitude: number | null;
+  accuracy: number;
+  altitudeAccuracy: number | null;
+  heading: number | null;
+  speed: number | null;
+};
+
+export type BrowserPosition = {
+  coords: BrowserCoordinates;
+  timestamp: number;
+};
+
+export type BrowserPositionError = {
+  code: number;
+  message: string;
+};
+
+export type BrowserGeolocation = {
+  getCurrentPosition(
+    success: (position: BrowserPosition) => void,
+    error?: (error: BrowserPositionError) => void,
+    options?: BrowserPositionOptions
+  ): void;
+  watchPosition(
+    success: (position: BrowserPosition) => void,
+    error?: (error: BrowserPositionError) => void,
+    options?: BrowserPositionOptions
+  ): number;
+  clearWatch(watchId: number): void;
+};
+
+type BrowserPositionOptions = {
+  enableHighAccuracy?: boolean;
+  timeout?: number;
+  maximumAge?: number;
+};
+
+type BrowserNavigator = {
+  geolocation?: BrowserGeolocation;
+  permissions?: BrowserPermissions;
+};
+
+const defaultTimeoutMs = 600000;
+
+export function getNavigator(): BrowserNavigator | undefined {
+  const globalNavigator = (globalThis as { navigator?: BrowserNavigator })
+    .navigator;
+  return globalNavigator;
+}
+
+export function getGeolocation(): BrowserGeolocation | undefined {
+  return getNavigator()?.geolocation;
+}
+
+export function toPositionOptions(
+  options?: LocationRequestOptions
+): BrowserPositionOptions {
+  const androidAccuracy = options?.accuracy?.android;
+
+  return {
+    enableHighAccuracy:
+      androidAccuracy !== undefined
+        ? androidAccuracy === "high"
+        : options?.enableHighAccuracy,
+    timeout: options?.timeout ?? defaultTimeoutMs,
+    maximumAge: options?.maximumAge ?? 0
+  };
+}
+
+export function normalizePosition(
+  position: BrowserPosition
+): GeolocationResponse {
+  return {
+    coords: {
+      latitude: position.coords.latitude,
+      longitude: position.coords.longitude,
+      altitude: position.coords.altitude ?? null,
+      accuracy: position.coords.accuracy,
+      altitudeAccuracy: position.coords.altitudeAccuracy ?? null,
+      heading: position.coords.heading ?? null,
+      speed: position.coords.speed ?? null
+    },
+    timestamp: position.timestamp,
+    provider: "unknown"
+  };
+}
+
+export function mapPermissionState(
+  state: BrowserPermissionState
+): "granted" | "denied" | "undetermined" {
+  if (state === "granted") {
+    return "granted";
+  }
+  if (state === "denied") {
+    return "denied";
+  }
+  return "undetermined";
+}
+
+export function createUnsupportedError(): LocationError {
+  return createLocationError(
+    LocationErrorCode.POSITION_UNAVAILABLE,
+    "Browser geolocation is unavailable. Use a secure context and a browser that supports navigator.geolocation."
+  );
+}
+
+export function mapBrowserError(error: BrowserPositionError): LocationError {
+  switch (error.code) {
+    case 1:
+      return createLocationError(
+        LocationErrorCode.PERMISSION_DENIED,
+        error.message || "User denied geolocation permission."
+      );
+    case 3:
+      return createLocationError(
+        LocationErrorCode.TIMEOUT,
+        error.message || "Geolocation request timed out."
+      );
+    default:
+      return createLocationError(
+        LocationErrorCode.POSITION_UNAVAILABLE,
+        error.message || "Position is unavailable."
+      );
+  }
+}
+
+export function rejectUnsupported<T>(): Promise<T> {
+  return Promise.reject(createUnsupportedError());
+}
+
+export function distanceMeters(
+  first: GeolocationResponse,
+  second: GeolocationResponse
+): number {
+  const earthRadiusMeters = 6371000;
+  const lat1 = (first.coords.latitude * Math.PI) / 180;
+  const lat2 = (second.coords.latitude * Math.PI) / 180;
+  const deltaLat =
+    ((second.coords.latitude - first.coords.latitude) * Math.PI) / 180;
+  const deltaLon =
+    ((second.coords.longitude - first.coords.longitude) * Math.PI) / 180;
+
+  const a =
+    Math.sin(deltaLat / 2) * Math.sin(deltaLat / 2) +
+    Math.cos(lat1) *
+      Math.cos(lat2) *
+      Math.sin(deltaLon / 2) *
+      Math.sin(deltaLon / 2);
+
+  return earthRadiusMeters * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+}

package/src/web/index.ts

@@ -0,0 +1,167 @@
+import type {
+  LocationError,
+  LocationRequestOptions,
+  LocationSettingsOptions,
+  PermissionStatus
+} from "../NitroGeolocation.nitro";
+import type {
+  AccuracyAuthorization,
+  GeocodedLocation,
+  GeocodingCoordinates,
+  GeolocationConfiguration,
+  GeolocationResponse,
+  Heading,
+  LocationAvailability,
+  LocationProviderStatus,
+  ReverseGeocodedAddress
+} from "../publicTypes";
+import { LocationErrorCode, createLocationError } from "../utils/errors";
+import {
+  createUnsupportedError,
+  getGeolocation,
+  getNavigator,
+  mapBrowserError,
+  mapPermissionState,
+  normalizePosition,
+  rejectUnsupported,
+  toPositionOptions
+} from "./browser";
+export { stopObserving, unwatch, watchHeading, watchPosition } from "./watch";
+export {
+  useWatchPosition,
+  type UseWatchPositionOptions
+} from "./useWatchPosition";
+
+export function setConfiguration(_config: GeolocationConfiguration): void {
+  // Browser geolocation has no global configuration API.
+}
+
+export async function checkPermission(): Promise<PermissionStatus> {
+  const browserNavigator = getNavigator();
+  if (!browserNavigator?.geolocation) {
+    return "denied";
+  }
+
+  try {
+    const status = await browserNavigator.permissions?.query({
+      name: "geolocation"
+    });
+    return status ? mapPermissionState(status.state) : "undetermined";
+  } catch {
+    return "undetermined";
+  }
+}
+
+export async function requestPermission(): Promise<PermissionStatus> {
+  const currentStatus = await checkPermission();
+  if (currentStatus === "granted" || currentStatus === "denied") {
+    return currentStatus;
+  }
+
+  try {
+    await getCurrentPosition({ maximumAge: 0, timeout: 10000 });
+    return "granted";
+  } catch (error) {
+    if ((error as LocationError).code === LocationErrorCode.PERMISSION_DENIED) {
+      return "denied";
+    }
+    return checkPermission();
+  }
+}
+
+export function hasServicesEnabled(): Promise<boolean> {
+  return Promise.resolve(Boolean(getGeolocation()));
+}
+
+export function getProviderStatus(): Promise<LocationProviderStatus> {
+  const enabled = Boolean(getGeolocation());
+  return Promise.resolve({
+    locationServicesEnabled: enabled,
+    backgroundModeEnabled: false
+  });
+}
+
+export async function getLocationAvailability(): Promise<LocationAvailability> {
+  if (!getGeolocation()) {
+    return {
+      available: false,
+      reason: createUnsupportedError().message
+    };
+  }
+
+  const permission = await checkPermission();
+  if (permission === "denied" || permission === "restricted") {
+    return {
+      available: false,
+      reason: "Browser geolocation permission is denied."
+    };
+  }
+
+  return { available: true };
+}
+
+export function requestLocationSettings(
+  _options?: LocationSettingsOptions
+): Promise<LocationProviderStatus> {
+  return getProviderStatus();
+}
+
+export function getAccuracyAuthorization(): Promise<AccuracyAuthorization> {
+  return checkPermission().then((status) =>
+    status === "granted" ? "full" : "unknown"
+  );
+}
+
+export function requestTemporaryFullAccuracy(
+  _purposeKey: string
+): Promise<AccuracyAuthorization> {
+  return getAccuracyAuthorization();
+}
+
+export function getCurrentPosition(
+  options?: LocationRequestOptions
+): Promise<GeolocationResponse> {
+  const geolocation = getGeolocation();
+  if (!geolocation) {
+    return rejectUnsupported();
+  }
+
+  return new Promise((resolve, reject) => {
+    geolocation.getCurrentPosition(
+      (position) => resolve(normalizePosition(position)),
+      (error) => reject(mapBrowserError(error)),
+      toPositionOptions(options)
+    );
+  });
+}
+
+export function getLastKnownPosition(
+  options?: LocationRequestOptions
+): Promise<GeolocationResponse> {
+  const maximumAge = options?.maximumAge ?? Number.POSITIVE_INFINITY;
+  return getCurrentPosition({ ...options, maximumAge, timeout: 0 }).catch(
+    (error) => {
+      if ((error as LocationError).code === LocationErrorCode.TIMEOUT) {
+        throw createLocationError(
+          LocationErrorCode.POSITION_UNAVAILABLE,
+          "No cached browser location is available."
+        );
+      }
+      throw error;
+    }
+  );
+}
+
+export function geocode(_address: string): Promise<GeocodedLocation[]> {
+  return rejectUnsupported();
+}
+
+export function reverseGeocode(
+  _coords: GeocodingCoordinates
+): Promise<ReverseGeocodedAddress[]> {
+  return rejectUnsupported();
+}
+
+export function getHeading(): Promise<Heading> {
+  return rejectUnsupported();
+}

package/src/web/useWatchPosition.ts

@@ -0,0 +1,76 @@
+import { useEffect, useRef, useState } from "react";
+import type {
+  LocationError,
+  LocationRequestOptions
+} from "../NitroGeolocation.nitro";
+import type { GeolocationResponse } from "../publicTypes";
+import { unwatch, watchPosition } from "./watch";
+
+export interface UseWatchPositionOptions extends LocationRequestOptions {
+  enabled?: boolean;
+}
+
+export function useWatchPosition(options?: UseWatchPositionOptions) {
+  const [position, setPosition] = useState<GeolocationResponse | null>(null);
+  const [isWatching, setIsWatching] = useState(false);
+  const [error, setError] = useState<LocationError | null>(null);
+  const tokenRef = useRef<string | null>(null);
+  const isMountedRef = useRef(true);
+  const optionsRef = useRef(options);
+  const enabled = options?.enabled ?? false;
+
+  useEffect(() => {
+    optionsRef.current = options;
+  }, [options]);
+
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+
+  useEffect(() => {
+    if (!enabled) {
+      if (tokenRef.current) {
+        unwatch(tokenRef.current);
+        tokenRef.current = null;
+      }
+      setIsWatching(false);
+      return;
+    }
+
+    setIsWatching(true);
+    setError(null);
+    const token = watchPosition(
+      (nextPosition) => {
+        if (!isMountedRef.current) {
+          return;
+        }
+        setPosition(nextPosition);
+        setError(null);
+      },
+      (nextError) => {
+        if (!isMountedRef.current) {
+          return;
+        }
+        setError(nextError);
+      },
+      optionsRef.current
+    );
+    tokenRef.current = token;
+
+    return () => {
+      unwatch(token);
+      if (tokenRef.current === token) {
+        tokenRef.current = null;
+      }
+    };
+  }, [enabled]);
+
+  return {
+    position,
+    error,
+    isWatching
+  };
+}

package/src/web/watch.ts

@@ -0,0 +1,81 @@
+import type {
+  LocationError,
+  LocationRequestOptions
+} from "../NitroGeolocation.nitro";
+import type {
+  GeolocationResponse,
+  Heading,
+  HeadingOptions
+} from "../publicTypes";
+import {
+  createUnsupportedError,
+  distanceMeters,
+  getGeolocation,
+  mapBrowserError,
+  normalizePosition,
+  toPositionOptions
+} from "./browser";
+
+const activeWatches = new Map<string, number>();
+let nextWatchId = 1;
+
+export function watchHeading(
+  _success: (heading: Heading) => void,
+  error?: (error: LocationError) => void,
+  _options?: HeadingOptions
+): string {
+  const token = `web-heading-${nextWatchId++}`;
+  error?.(createUnsupportedError());
+  return token;
+}
+
+export function watchPosition(
+  success: (position: GeolocationResponse) => void,
+  error?: (error: LocationError) => void,
+  options?: LocationRequestOptions
+): string {
+  const geolocation = getGeolocation();
+  const token = `web-${nextWatchId++}`;
+
+  if (!geolocation) {
+    error?.(createUnsupportedError());
+    return token;
+  }
+
+  let lastEmitted: GeolocationResponse | null = null;
+  const watchId = geolocation.watchPosition(
+    (position) => {
+      const normalizedPosition = normalizePosition(position);
+      const filter = options?.distanceFilter ?? 0;
+      if (
+        filter <= 0 ||
+        !lastEmitted ||
+        distanceMeters(lastEmitted, normalizedPosition) >= filter
+      ) {
+        lastEmitted = normalizedPosition;
+        success(normalizedPosition);
+      }
+    },
+    (browserError) => error?.(mapBrowserError(browserError)),
+    toPositionOptions(options)
+  );
+
+  activeWatches.set(token, watchId);
+  return token;
+}
+
+export function unwatch(token: string): void {
+  const watchId = activeWatches.get(token);
+  if (watchId === undefined) {
+    return;
+  }
+
+  getGeolocation()?.clearWatch(watchId);
+  activeWatches.delete(token);
+}
+
+export function stopObserving(): void {
+  for (const token of activeWatches.keys()) {
+    unwatch(token);
+  }
+}

package/src/devtools/index.test.ts

@@ -1,54 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { isDevtoolsEnabled } from "./index";
-
-const globalState = globalThis as typeof globalThis & {
-  __DEV__?: boolean;
-  __geolocationDevToolsEnabled?: boolean;
-};
-
-const originalState = {
-  hasDev: Object.prototype.hasOwnProperty.call(globalState, "__DEV__"),
-  dev: globalState.__DEV__,
-  hasDevtoolsEnabled: Object.prototype.hasOwnProperty.call(
-    globalState,
-    "__geolocationDevToolsEnabled"
-  ),
-  devtoolsEnabled: globalState.__geolocationDevToolsEnabled
-};
-
-describe("isDevtoolsEnabled", () => {
-  afterEach(() => {
-    if (originalState.hasDev) {
-      globalState.__DEV__ = originalState.dev;
-    } else {
-      globalState.__DEV__ = undefined;
-    }
-
-    if (originalState.hasDevtoolsEnabled) {
-      globalState.__geolocationDevToolsEnabled = originalState.devtoolsEnabled;
-    } else {
-      globalState.__geolocationDevToolsEnabled = undefined;
-    }
-  });
-
-  it("enables devtools only when React Native __DEV__ and the devtools flag are true", () => {
-    globalState.__DEV__ = true;
-    globalState.__geolocationDevToolsEnabled = true;
-
-    expect(isDevtoolsEnabled()).toBe(true);
-  });
-
-  it("ignores the devtools flag outside React Native __DEV__", () => {
-    globalState.__DEV__ = false;
-    globalState.__geolocationDevToolsEnabled = true;
-
-    expect(isDevtoolsEnabled()).toBe(false);
-  });
-
-  it("stays disabled when __DEV__ is unavailable", () => {
-    globalState.__DEV__ = undefined;
-    globalState.__geolocationDevToolsEnabled = true;
-
-    expect(isDevtoolsEnabled()).toBe(false);
-  });
-});

package/src/utils/errors.test.ts

@@ -1,65 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  LocationErrorCode,
-  createLocationError,
-  getLocationErrorCodeName,
-  mapAndroidException,
-  mapCLErrorCode
-} from "./errors";
-
-describe("LocationErrorCode", () => {
-  it("keeps legacy-compatible codes and adds modern-only error codes", () => {
-    expect(LocationErrorCode.INTERNAL_ERROR).toBe(-1);
-    expect(LocationErrorCode.PERMISSION_DENIED).toBe(1);
-    expect(LocationErrorCode.POSITION_UNAVAILABLE).toBe(2);
-    expect(LocationErrorCode.TIMEOUT).toBe(3);
-    expect(LocationErrorCode.PLAY_SERVICE_NOT_AVAILABLE).toBe(4);
-    expect(LocationErrorCode.SETTINGS_NOT_SATISFIED).toBe(5);
-  });
-
-  it("creates the same plain LocationError shape native sends to JS", () => {
-    const error = createLocationError(
-      LocationErrorCode.SETTINGS_NOT_SATISFIED,
-      "Location settings are disabled"
-    );
-
-    expect(error).toEqual({
-      code: LocationErrorCode.SETTINGS_NOT_SATISFIED,
-      message: "Location settings are disabled"
-    });
-  });
-
-  it("maps platform-specific error sources", () => {
-    expect(mapCLErrorCode(0)).toBe(LocationErrorCode.POSITION_UNAVAILABLE);
-    expect(mapCLErrorCode(1)).toBe(LocationErrorCode.PERMISSION_DENIED);
-    expect(mapAndroidException("SecurityException")).toBe(
-      LocationErrorCode.PERMISSION_DENIED
-    );
-    expect(mapAndroidException("ResolvableApiException")).toBe(
-      LocationErrorCode.SETTINGS_NOT_SATISFIED
-    );
-    expect(mapAndroidException("GooglePlayServicesNotAvailableException")).toBe(
-      LocationErrorCode.PLAY_SERVICE_NOT_AVAILABLE
-    );
-  });
-
-  it("returns stable names for code display", () => {
-    expect(getLocationErrorCodeName(LocationErrorCode.INTERNAL_ERROR)).toBe(
-      "INTERNAL_ERROR"
-    );
-    expect(getLocationErrorCodeName(LocationErrorCode.PERMISSION_DENIED)).toBe(
-      "PERMISSION_DENIED"
-    );
-    expect(
-      getLocationErrorCodeName(LocationErrorCode.POSITION_UNAVAILABLE)
-    ).toBe("POSITION_UNAVAILABLE");
-    expect(getLocationErrorCodeName(LocationErrorCode.TIMEOUT)).toBe("TIMEOUT");
-    expect(
-      getLocationErrorCodeName(LocationErrorCode.PLAY_SERVICE_NOT_AVAILABLE)
-    ).toBe("PLAY_SERVICE_NOT_AVAILABLE");
-    expect(
-      getLocationErrorCodeName(LocationErrorCode.SETTINGS_NOT_SATISFIED)
-    ).toBe("SETTINGS_NOT_SATISFIED");
-    expect(getLocationErrorCodeName(999)).toBe("UNKNOWN_LOCATION_ERROR");
-  });
-});