@umituz/react-native-location 1.0.6 → 1.0.8

package/package.json

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

package/src/domain/entities/Location.ts

@@ -1,23 +1 @@
-export interface Coordinates {
-    latitude: number;
-    longitude: number;
-}
-
-export interface LocationAddress {
-    city?: string | null;
-    region?: string | null;
-    country?: string | null;
-    street?: string | null;
-    formattedAddress?: string | null;
-}
-
-export interface LocationData {
-    coords: Coordinates;
-    timestamp: number;
-    address?: LocationAddress;
-}
-
-export interface LocationError {
-    code: string;
-    message: string;
-}
+export * from "../../types/location.types";

package/src/index.ts

@@ -1,3 +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

@@ -1,53 +1,140 @@
 import * as Location from "expo-location";
-import { LocationData, LocationError } from "../../domain/entities/Location";
+import { storageRepository, unwrap } from "@umituz/react-native-storage";
+import {
+    LocationData,
+    LocationConfig,
+    DEFAULT_LOCATION_CONFIG,
+    CachedLocationData,
+    LocationErrorImpl,
+    LocationErrorCode,
+} from "../../types/location.types";
+
+declare const __DEV__: boolean;
 
 export class LocationService {
-    /**
-     * Requests foreground location permissions.
-     * @returns boolean indicating if permission was granted.
-     */
+    private config: LocationConfig;
+    private storage = storageRepository;
+
+    constructor(config: LocationConfig = {}) {
+        this.config = { ...DEFAULT_LOCATION_CONFIG, ...config };
+    }
+
+    private log(message: string, ...args: unknown[]): void {
+        if (__DEV__) {
+            console.log(`[LocationService] ${message}`, ...args);
+        }
+    }
+
+    private logError(message: string, error: unknown): void {
+        if (__DEV__) {
+            console.error(`[LocationService] ${message}`, error);
+        }
+    }
+
+    private logWarn(message: string, ...args: unknown[]): void {
+        if (__DEV__) {
+            console.warn(`[LocationService] ${message}`, ...args);
+        }
+    }
+
     async requestPermissions(): Promise<boolean> {
         try {
-            console.log("[LocationService] Requesting permissions...");
+            this.log("Requesting permissions...");
             const { status } = await Location.requestForegroundPermissionsAsync();
-            console.log("[LocationService] Permission status:", status);
+            this.log("Permission status:", status);
             return status === "granted";
         } catch (error) {
-            console.error("[LocationService] Error requesting permissions:", error);
+            this.logError("Error requesting permissions:", error);
             return false;
         }
     }
 
-    /**
-     * Gets the current position of the device.
-     * @param withAddress If true, also performs reverse geocoding.
-     */
-    async getCurrentPosition(withAddress: boolean = false): Promise<LocationData> {
-        console.log("[LocationService] getCurrentPosition called");
+    private async getCachedLocation(): Promise<LocationData | null> {
+        if (!this.config.enableCache) {
+            return null;
+        }
+
+        try {
+            const cacheKey = `location_cache_${this.config.cacheKey}`;
+            const result = await this.storage.getItem<CachedLocationData | null>(cacheKey, null);
+            const cached = unwrap(result, null);
+
+            if (!cached) {
+                this.log("No cached location found");
+                return null;
+            }
+
+            const now = Date.now();
+            const cacheAge = now - cached.timestamp;
+            const cacheDuration = this.config.cacheDuration || 300000;
+
+            if (cacheAge > cacheDuration) {
+                this.log("Cache expired");
+                await this.storage.removeItem(cacheKey);
+                return null;
+            }
+
+            this.log("Using cached location");
+            return cached.location;
+        } catch (error) {
+            this.logError("Cache read error:", error);
+            return null;
+        }
+    }
+
+    private async cacheLocation(location: LocationData): Promise<void> {
+        if (!this.config.enableCache) {
+            return;
+        }
+
+        try {
+            const cacheKey = `location_cache_${this.config.cacheKey}`;
+            const cachedData: CachedLocationData = {
+                location,
+                timestamp: Date.now(),
+            };
+            await this.storage.setItem(cacheKey, cachedData);
+            this.log("Location cached successfully");
+        } catch (error) {
+            this.logError("Cache write error:", error);
+        }
+    }
+
+    async getCurrentPosition(): Promise<LocationData> {
+        const withAddress = this.config.withAddress ?? true;
+
+        this.log("getCurrentPosition called");
+
+        const cached = await this.getCachedLocation();
+        if (cached) {
+            this.log("Returning cached location");
+            return cached;
+        }
+
         const hasPermission = await this.requestPermissions();
         if (!hasPermission) {
-            console.warn("[LocationService] Permission denied");
-            throw { code: "PERMISSION_DENIED", message: "Location permission not granted" };
+            this.logWarn("Permission denied");
+            throw new LocationErrorImpl("PERMISSION_DENIED", "Location permission not granted");
         }
 
         try {
-            console.log("[LocationService] getting position async...");
+            this.log("Getting position...");
             const location = await Location.getCurrentPositionAsync({
-                accuracy: Location.Accuracy.Balanced,
+                accuracy: this.config.accuracy,
             });
-            console.log("[LocationService] position obtained", location);
+            this.log("Position obtained", location);
 
             let addressData;
             if (withAddress) {
-                console.log("[LocationService] reverse geocoding...");
+                this.log("Reverse geocoding...");
                 addressData = await this.reverseGeocode(
                     location.coords.latitude,
                     location.coords.longitude
                 );
-                console.log("[LocationService] address obtained", addressData);
+                this.log("Address obtained", addressData);
             }
 
-            return {
+            const locationData: LocationData = {
                 coords: {
                     latitude: location.coords.latitude,
                     longitude: location.coords.longitude,
@@ -55,17 +142,27 @@ export class LocationService {
                 timestamp: location.timestamp,
                 address: addressData,
             };
+
+            await this.cacheLocation(locationData);
+
+            return locationData;
         } catch (error) {
-            console.error("[LocationService] Error getting location:", error);
-            // Type guard for error object
-            const errorMessage = error instanceof Error ? error.message : "Unknown error getting location";
-            throw { code: "LOCATION_ERROR", message: errorMessage };
+            this.logError("Error getting location:", error);
+
+            let errorCode: LocationErrorCode = "UNKNOWN_ERROR";
+            let errorMessage = "Unknown error getting location";
+
+            if (error instanceof LocationErrorImpl) {
+                errorCode = error.code;
+                errorMessage = error.message;
+            } else if (error instanceof Error) {
+                errorMessage = error.message;
+            }
+
+            throw new LocationErrorImpl(errorCode, errorMessage);
         }
     }
 
-    /**
-     * Reverse geocodes coordinates to an address.
-     */
     async reverseGeocode(latitude: number, longitude: number) {
         try {
             const [address] = await Location.reverseGeocodeAsync({ latitude, longitude });
@@ -79,10 +176,61 @@ export class LocationService {
                 formattedAddress: [address.city, address.country].filter(Boolean).join(", "),
             };
         } catch (error) {
-            console.warn("[LocationService] Reverse geocode failed:", error);
+            this.logWarn("Reverse geocode failed:", error);
             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 const locationService = new LocationService();
+export function createLocationService(config?: LocationConfig): LocationService {
+    return new LocationService(config);
+}

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/useLocation.ts

@@ -1,6 +1,6 @@
-import { useState, useCallback } from "react";
-import { locationService } from "../../infrastructure/services/LocationService";
-import { LocationData, LocationError } from "../../domain/entities/Location";
+import { useState, useCallback, useRef } from "react";
+import { createLocationService } from "../../infrastructure/services/LocationService";
+import { LocationData, LocationError, LocationConfig } from "../../types/location.types";
 
 export interface UseLocationResult {
     location: LocationData | null;
@@ -9,7 +9,8 @@ export interface UseLocationResult {
     getCurrentLocation: () => Promise<LocationData | null>;
 }
 
-export function useLocation(): UseLocationResult {
+export function useLocation(config?: LocationConfig): UseLocationResult {
+    const serviceRef = useRef(createLocationService(config));
     const [location, setLocation] = useState<LocationData | null>(null);
     const [isLoading, setIsLoading] = useState(false);
     const [error, setError] = useState<LocationError | null>(null);
@@ -17,15 +18,24 @@ export function useLocation(): UseLocationResult {
     const getCurrentLocation = useCallback(async () => {
         setIsLoading(true);
         setError(null);
+
         try {
-            const data = await locationService.getCurrentPosition(true);
+            const data = await serviceRef.current.getCurrentPosition();
             setLocation(data);
             return data;
-        } catch (err: any) {
-            const errorObj = {
-                code: err.code || "UNKNOWN_ERROR",
-                message: err.message || "An unknown error occurred",
+        } 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);
             return null;
         } finally {

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

@@ -0,0 +1,78 @@
+import * as Location from "expo-location";
+
+export interface Coordinates {
+    latitude: number;
+    longitude: number;
+}
+
+export interface LocationAddress {
+    city?: string | null;
+    region?: string | null;
+    country?: string | null;
+    street?: string | null;
+    formattedAddress?: string | null;
+}
+
+export interface LocationData {
+    coords: Coordinates;
+    timestamp: number;
+    address?: LocationAddress;
+}
+
+export interface LocationError {
+    code: string;
+    message: string;
+}
+
+export interface CachedLocationData {
+    location: LocationData;
+    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;
+    enableCache?: boolean;
+    cacheKey?: string;
+    cacheDuration?: number;
+    withAddress?: boolean;
+    distanceFilter?: number;
+}
+
+export const DEFAULT_LOCATION_CONFIG: LocationConfig = {
+    accuracy: Location.Accuracy.Balanced,
+    timeout: 10000,
+    enableCache: true,
+    cacheKey: "default",
+    cacheDuration: 300000,
+    withAddress: true,
+    distanceFilter: 10,
+};
+
+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;
+
+    constructor(code: LocationErrorCode, message: string) {
+        super(message);
+        this.name = "LocationError";
+        this.code = code;
+    }
+}