@umituz/react-native-location 1.0.7 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-location",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Device location services for React Native with GPS, permissions, caching, and reverse geocoding",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/index.ts

@@ -1,4 +1,7 @@
 export * from "./domain/entities/Location";
 export * from "./types/location.types";
 export * from "./infrastructure/services/LocationService";
+export * from "./infrastructure/services/LocationWatcher";
+export * from "./infrastructure/utils/LocationUtils";
 export * from "./presentation/hooks/useLocation";
+export * from "./presentation/hooks/useLocationWatch";

package/src/infrastructure/services/LocationService.ts

@@ -180,6 +180,55 @@ export class LocationService {
             return undefined;
         }
     }
+
+    async isLocationEnabled(): Promise<boolean> {
+        try {
+            this.log("Checking if location is enabled...");
+            const enabled = await Location.hasServicesEnabledAsync();
+            this.log("Location enabled:", enabled);
+            return enabled;
+        } catch (error) {
+            this.logError("Error checking location enabled:", error);
+            return false;
+        }
+    }
+
+    async getPermissionStatus(): Promise<Location.PermissionStatus> {
+        try {
+            this.log("Getting permission status...");
+            const status = await Location.getForegroundPermissionsAsync();
+            this.log("Permission status:", status.status);
+            return status.status;
+        } catch (error) {
+            this.logError("Error getting permission status:", error);
+            return "undetermined";
+        }
+    }
+
+    async getLastKnownPosition(): Promise<LocationData | null> {
+        try {
+            this.log("Getting last known position...");
+            const location = await Location.getLastKnownPositionAsync();
+
+            if (!location) {
+                this.log("No last known position available");
+                return null;
+            }
+
+            this.log("Last known position obtained", location);
+
+            return {
+                coords: {
+                    latitude: location.coords.latitude,
+                    longitude: location.coords.longitude,
+                },
+                timestamp: location.timestamp,
+            };
+        } catch (error) {
+            this.logError("Error getting last known position:", error);
+            return null;
+        }
+    }
 }
 
 export function createLocationService(config?: LocationConfig): LocationService {

package/src/infrastructure/services/LocationWatcher.ts

@@ -0,0 +1,116 @@
+import * as Location from "expo-location";
+import {
+    LocationData,
+    LocationError,
+    LocationCallback,
+    LocationErrorCallback,
+    LocationWatcherOptions,
+    LocationErrorImpl,
+    LocationErrorCode,
+} from "../../types/location.types";
+
+declare const __DEV__: boolean;
+
+export class LocationWatcher {
+    private subscription: Location.LocationSubscription | null = null;
+    private options: LocationWatcherOptions;
+
+    constructor(options: LocationWatcherOptions = {}) {
+        this.options = options;
+    }
+
+    private log(message: string, ...args: unknown[]): void {
+        if (__DEV__) {
+            console.log(`[LocationWatcher] ${message}`, ...args);
+        }
+    }
+
+    private logError(message: string, error: unknown): void {
+        if (__DEV__) {
+            console.error(`[LocationWatcher] ${message}`, error);
+        }
+    }
+
+    async watchPosition(
+        onSuccess: LocationCallback,
+        onError?: LocationErrorCallback
+    ): Promise<string> {
+        try {
+            this.log("Requesting permissions...");
+            const { status } = await Location.requestForegroundPermissionsAsync();
+
+            if (status !== "granted") {
+                const error: LocationError = {
+                    code: "PERMISSION_DENIED",
+                    message: "Location permission not granted",
+                };
+                if (onError) {
+                    onError(error);
+                }
+                throw new LocationErrorImpl("PERMISSION_DENIED", "Location permission not granted");
+            }
+
+            this.log("Starting location watch...");
+
+            this.subscription = await Location.watchPositionAsync(
+                {
+                    accuracy: this.options.accuracy || Location.Accuracy.Balanced,
+                },
+                (location) => {
+                    this.log("Location update received", location);
+
+                    const locationData: LocationData = {
+                        coords: {
+                            latitude: location.coords.latitude,
+                            longitude: location.coords.longitude,
+                        },
+                        timestamp: location.timestamp,
+                    };
+
+                    onSuccess(locationData);
+                }
+            );
+
+            return "watching";
+        } catch (error) {
+            this.logError("Error watching position:", error);
+
+            let errorCode: LocationErrorCode = "UNKNOWN_ERROR";
+            let errorMessage = "Unknown error watching location";
+
+            if (error instanceof LocationErrorImpl) {
+                errorCode = error.code;
+                errorMessage = error.message;
+            } else if (error instanceof Error) {
+                errorMessage = error.message;
+            }
+
+            const locationError: LocationError = {
+                code: errorCode,
+                message: errorMessage,
+            };
+
+            if (onError) {
+                onError(locationError);
+            }
+
+            throw new LocationErrorImpl(errorCode, errorMessage);
+        }
+    }
+
+    clearWatch(): void {
+        if (this.subscription) {
+            this.log("Clearing location watch");
+            this.subscription.remove();
+            this.subscription = null;
+        }
+    }
+
+    isWatching(): boolean {
+        return this.subscription !== null;
+    }
+}
+
+export function createLocationWatcher(options?: LocationWatcherOptions): LocationWatcher {
+    return new LocationWatcher(options);
+}

package/src/infrastructure/utils/LocationUtils.ts

@@ -0,0 +1,83 @@
+import { Coordinates, DistanceUnit } from "../../types/location.types";
+
+export class LocationUtils {
+    private static readonly EARTH_RADIUS_KM = 6371;
+    private static readonly EARTH_RADIUS_MILES = 3959;
+    private static readonly EARTH_RADIUS_METERS = 6371000;
+
+    static calculateDistance(
+        from: Coordinates,
+        to: Coordinates,
+        unit: DistanceUnit = "km"
+    ): number {
+        const lat1Rad = (from.latitude * Math.PI) / 180;
+        const lat2Rad = (to.latitude * Math.PI) / 180;
+        const deltaLatRad = ((to.latitude - from.latitude) * Math.PI) / 180;
+        const deltaLonRad = ((to.longitude - from.longitude) * Math.PI) / 180;
+
+        const a =
+            Math.sin(deltaLatRad / 2) * Math.sin(deltaLatRad / 2) +
+            Math.cos(lat1Rad) *
+                Math.cos(lat2Rad) *
+                Math.sin(deltaLonRad / 2) *
+                Math.sin(deltaLonRad / 2);
+
+        const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+        switch (unit) {
+            case "miles":
+                return this.EARTH_RADIUS_MILES * c;
+            case "meters":
+                return this.EARTH_RADIUS_METERS * c;
+            case "km":
+            default:
+                return this.EARTH_RADIUS_KM * c;
+        }
+    }
+
+    static isValidCoordinate(latitude: number, longitude: number): boolean {
+        return (
+            latitude >= -90 &&
+            latitude <= 90 &&
+            longitude >= -180 &&
+            longitude <= 180
+        );
+    }
+
+    static isValidAccuracy(accuracy: number | null | undefined, maxAccuracy = 100): boolean {
+        if (accuracy === null || accuracy === undefined) {
+            return false;
+        }
+        return accuracy > 0 && accuracy <= maxAccuracy;
+    }
+
+    static formatAccuracy(accuracy: number | null | undefined): string {
+        if (accuracy === null || accuracy === undefined) {
+            return "Unknown";
+        }
+
+        if (accuracy < 10) {
+            return "Excellent (±" + Math.round(accuracy) + "m)";
+        }
+        if (accuracy < 50) {
+            return "Good (±" + Math.round(accuracy) + "m)";
+        }
+        if (accuracy < 100) {
+            return "Fair (±" + Math.round(accuracy) + "m)";
+        }
+        return "Poor (±" + Math.round(accuracy) + "m)";
+    }
+
+    static coordinatesAreEqual(
+        coord1: Coordinates,
+        coord2: Coordinates,
+        precision = 6
+    ): boolean {
+        const lat1 = coord1.latitude.toFixed(precision);
+        const lat2 = coord2.latitude.toFixed(precision);
+        const lon1 = coord1.longitude.toFixed(precision);
+        const lon2 = coord2.longitude.toFixed(precision);
+
+        return lat1 === lat2 && lon1 === lon2;
+    }
+}

package/src/presentation/hooks/useLocationWatch.ts

@@ -0,0 +1,75 @@
+import { useEffect, useRef, useState, useCallback } from "react";
+import { createLocationWatcher } from "../../infrastructure/services/LocationWatcher";
+import { LocationData, LocationError, LocationWatcherOptions } from "../../types/location.types";
+
+export interface UseLocationWatchResult {
+    location: LocationData | null;
+    error: LocationError | null;
+    isWatching: boolean;
+    startWatching: () => Promise<void>;
+    stopWatching: () => void;
+}
+
+export function useLocationWatch(options?: LocationWatcherOptions): UseLocationWatchResult {
+    const watcherRef = useRef<ReturnType<typeof createLocationWatcher> | null>(null);
+    const [location, setLocation] = useState<LocationData | null>(null);
+    const [error, setError] = useState<LocationError | null>(null);
+    const [isWatching, setIsWatching] = useState(false);
+
+    const stopWatching = useCallback(() => {
+        if (watcherRef.current) {
+            watcherRef.current.clearWatch();
+            watcherRef.current = null;
+            setIsWatching(false);
+        }
+    }, []);
+
+    const startWatching = useCallback(async () => {
+        stopWatching();
+
+        const watcher = createLocationWatcher(options);
+        watcherRef.current = watcher;
+
+        try {
+            await watcher.watchPosition(
+                (data) => {
+                    setLocation(data);
+                    setError(null);
+                },
+                (err) => {
+                    setError(err);
+                }
+            );
+            setIsWatching(true);
+        } catch (err) {
+            let errorObj: LocationError = {
+                code: "UNKNOWN_ERROR",
+                message: "An unknown error occurred",
+            };
+
+            if (err && typeof err === "object" && "code" in err && "message" in err) {
+                errorObj = {
+                    code: typeof err.code === "string" ? err.code : "UNKNOWN_ERROR",
+                    message: typeof err.message === "string" ? err.message : "An unknown error occurred",
+                };
+            }
+
+            setError(errorObj);
+            setIsWatching(false);
+        }
+    }, [options, stopWatching]);
+
+    useEffect(() => {
+        return () => {
+            stopWatching();
+        };
+    }, [stopWatching]);
+
+    return {
+        location,
+        error,
+        isWatching,
+        startWatching,
+        stopWatching,
+    };
+}

package/src/types/location.types.ts

@@ -29,6 +29,15 @@ export interface CachedLocationData {
     timestamp: number;
 }
 
+export type DistanceUnit = "km" | "miles" | "meters";
+
+export type LocationErrorCode =
+    | "PERMISSION_DENIED"
+    | "LOCATION_UNAVAILABLE"
+    | "TIMEOUT"
+    | "CACHE_ERROR"
+    | "UNKNOWN_ERROR";
+
 export interface LocationConfig {
     accuracy?: Location.Accuracy;
     timeout?: number;
@@ -36,6 +45,7 @@ export interface LocationConfig {
     cacheKey?: string;
     cacheDuration?: number;
     withAddress?: boolean;
+    distanceFilter?: number;
 }
 
 export const DEFAULT_LOCATION_CONFIG: LocationConfig = {
@@ -45,14 +55,17 @@ export const DEFAULT_LOCATION_CONFIG: LocationConfig = {
     cacheKey: "default",
     cacheDuration: 300000,
     withAddress: true,
+    distanceFilter: 10,
 };
 
-export type LocationErrorCode =
-    | "PERMISSION_DENIED"
-    | "LOCATION_UNAVAILABLE"
-    | "TIMEOUT"
-    | "CACHE_ERROR"
-    | "UNKNOWN_ERROR";
+export type LocationCallback = (location: LocationData) => void;
+export type LocationErrorCallback = (error: LocationError) => void;
+
+export interface LocationWatcherOptions {
+    accuracy?: Location.Accuracy;
+    distanceFilter?: number;
+    timeout?: number;
+}
 
 export class LocationErrorImpl extends Error implements LocationError {
     code: LocationErrorCode;