@umituz/react-native-location 1.0.17 → 1.0.18

package/package.json

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

package/src/infrastructure/services/LocationService.ts

@@ -7,6 +7,7 @@ import {
     LocationError,
     LocationErrorCode,
 } from "../../types/location.types";
+import { LocationUtils } from "../utils/LocationUtils";
 
 interface CachedLocationData {
     location: LocationData;
@@ -24,42 +25,28 @@ const DEFAULT_CONFIG: Required<LocationConfig> = {
 
 export class LocationService {
     private config: Required<LocationConfig>;
-    private storage = storageRepository;
     private inFlightRequest: Promise<LocationData> | null = null;
 
     constructor(config: LocationConfig = {}) {
         this.config = { ...DEFAULT_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);
-        }
-    }
-
     async requestPermissions(): Promise<boolean> {
         try {
             const { status: current } = await Location.getForegroundPermissionsAsync();
             if (current === "granted") return true;
 
-            this.log("Requesting permissions...");
+            if (__DEV__) console.log("[LocationService] Requesting permissions...");
             const { status } = await Location.requestForegroundPermissionsAsync();
             return status === "granted";
         } catch (error) {
-            this.logError("Error requesting permissions:", error);
+            if (__DEV__) console.error("[LocationService] Error requesting permissions:", error);
             return false;
         }
     }
 
     private getCacheKey(): string {
-        const suffix = this.config.withAddress ? "_addr" : "";
-        return `location_cache_${this.config.cacheKey}${suffix}`;
+        return LocationUtils.generateCacheKey(this.config.cacheKey, this.config.withAddress);
     }
 
     private async getCachedLocation(): Promise<LocationData | null> {
@@ -67,21 +54,20 @@ export class LocationService {
 
         try {
             const cacheKey = this.getCacheKey();
-            const result = await this.storage.getItem<CachedLocationData | null>(cacheKey, null);
+            const result = await storageRepository.getItem<CachedLocationData | null>(cacheKey, null);
             const cached = unwrap(result, null);
 
             if (!cached) return null;
 
-            const cacheAge = Date.now() - cached.timestamp;
-            if (cacheAge > this.config.cacheDuration) {
-                await this.storage.removeItem(cacheKey);
+            if (LocationUtils.isCacheExpired(cached.timestamp, this.config.cacheDuration)) {
+                await storageRepository.removeItem(cacheKey);
                 return null;
             }
 
-            this.log("Using cached location");
+            if (__DEV__) console.log("[LocationService] Using cached location");
             return cached.location;
         } catch (error) {
-            this.logError("Cache read error:", error);
+            if (__DEV__) console.error("[LocationService] Cache read error:", error);
             return null;
         }
     }
@@ -91,9 +77,9 @@ export class LocationService {
 
         try {
             const data: CachedLocationData = { location, timestamp: Date.now() };
-            await this.storage.setItem(this.getCacheKey(), data);
+            await storageRepository.setItem(this.getCacheKey(), data);
         } catch (error) {
-            this.logError("Cache write error:", error);
+            if (__DEV__) console.error("[LocationService] Cache write error:", error);
         }
     }
 
@@ -142,11 +128,7 @@ export class LocationService {
             await this.cacheLocation(locationData);
             return locationData;
         } catch (error) {
-            this.logError("Error getting location:", error);
-
-            if (error instanceof Error && "code" in error) {
-                throw error;
-            }
+            if (__DEV__) console.error("[LocationService] Error getting location:", error);
 
             const message = error instanceof Error ? error.message : "Unknown error getting location";
             throw this.createError("UNKNOWN_ERROR", message);
@@ -154,7 +136,7 @@ export class LocationService {
     }
 
     private async getPositionWithTimeout(): Promise<Location.LocationObject> {
-        let timeoutId: ReturnType<typeof setTimeout>;
+        let timeoutId: ReturnType<typeof setTimeout> | null = null;
 
         const locationPromise = Location.getCurrentPositionAsync({
             accuracy: this.config.accuracy,
@@ -166,9 +148,14 @@ export class LocationService {
             }, this.config.timeout);
         });
 
-        const result = await Promise.race([locationPromise, timeoutPromise]);
-        clearTimeout(timeoutId!);
-        return result;
+        try {
+            const result = await Promise.race([locationPromise, timeoutPromise]);
+            return result;
+        } finally {
+            if (timeoutId !== null) {
+                clearTimeout(timeoutId);
+            }
+        }
     }
 
     async reverseGeocode(latitude: number, longitude: number): Promise<LocationAddress | undefined> {
@@ -176,17 +163,9 @@ export class LocationService {
             const [address] = await Location.reverseGeocodeAsync({ latitude, longitude });
             if (!address) return undefined;
 
-            return {
-                city: address.city ?? null,
-                region: address.region ?? null,
-                country: address.country ?? null,
-                street: address.street ?? null,
-                formattedAddress: [address.street, address.city, address.region, address.country]
-                    .filter(Boolean)
-                    .join(", ") || null,
-            };
+            return LocationUtils.buildFormattedAddress(address);
         } catch (error) {
-            this.logError("Reverse geocode failed:", error);
+            if (__DEV__) console.error("[LocationService] Reverse geocode failed:", error);
             return undefined;
         }
     }
@@ -195,7 +174,7 @@ export class LocationService {
         try {
             return await Location.hasServicesEnabledAsync();
         } catch (error) {
-            this.logError("Error checking location enabled:", error);
+            if (__DEV__) console.error("[LocationService] Error checking location enabled:", error);
             return false;
         }
     }
@@ -205,7 +184,7 @@ export class LocationService {
             const { status } = await Location.getForegroundPermissionsAsync();
             return status;
         } catch (error) {
-            this.logError("Error getting permission status:", error);
+            if (__DEV__) console.error("[LocationService] Error getting permission status:", error);
             return Location.PermissionStatus.UNDETERMINED;
         }
     }
@@ -223,7 +202,7 @@ export class LocationService {
                 timestamp: location.timestamp,
             };
         } catch (error) {
-            this.logError("Error getting last known position:", error);
+            if (__DEV__) console.error("[LocationService] Error getting last known position:", error);
             return null;
         }
     }

package/src/infrastructure/services/LocationWatcher.ts

@@ -6,10 +6,13 @@ import {
     LocationWatcherOptions,
 } from "../../types/location.types";
 
-type LocationCallback = (location: LocationData) => void;
-type ErrorCallback = (error: LocationError) => void;
-
 export class LocationWatcher {
+    private static readonly VALID_ERROR_CODES: readonly LocationErrorCode[] = [
+        "PERMISSION_DENIED",
+        "TIMEOUT",
+        "UNKNOWN_ERROR",
+    ] as const;
+
     private subscription: Location.LocationSubscription | null = null;
     private options: LocationWatcherOptions;
 
@@ -17,19 +20,10 @@ export class LocationWatcher {
         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?: ErrorCallback): Promise<void> {
+    async watchPosition(
+        onSuccess: (location: LocationData) => void,
+        onError?: (error: LocationError) => void,
+    ): Promise<void> {
         this.clearWatch();
 
         try {
@@ -56,15 +50,17 @@ export class LocationWatcher {
                 },
             );
         } catch (error) {
-            this.logError("Error watching position:", error);
+            if (__DEV__) console.error("[LocationWatcher] Error watching position:", error);
 
             let code: LocationErrorCode = "UNKNOWN_ERROR";
             let message = "Unknown error watching location";
 
             if (error instanceof Error) {
                 message = error.message;
-                if ("code" in error) {
-                    code = (error as { code: string }).code as LocationErrorCode;
+                if ("code" in error && typeof error.code === "string") {
+                    if (LocationWatcher.VALID_ERROR_CODES.includes(error.code as LocationErrorCode)) {
+                        code = error.code as LocationErrorCode;
+                    }
                 }
             }
 
@@ -74,7 +70,7 @@ export class LocationWatcher {
 
     clearWatch(): void {
         if (this.subscription) {
-            this.log("Clearing location watch");
+            if (__DEV__) console.log("[LocationWatcher] Clearing location watch");
             this.subscription.remove();
             this.subscription = null;
         }
@@ -89,11 +85,11 @@ export class LocationWatcher {
             const { status: current } = await Location.getForegroundPermissionsAsync();
             if (current === "granted") return true;
 
-            this.log("Requesting permissions...");
+            if (__DEV__) console.log("[LocationWatcher] Requesting permissions...");
             const { status } = await Location.requestForegroundPermissionsAsync();
             return status === "granted";
         } catch (error) {
-            this.logError("Error requesting permissions:", error);
+            if (__DEV__) console.error("[LocationWatcher] Error requesting permissions:", error);
             return false;
         }
     }

package/src/infrastructure/utils/LocationUtils.ts

@@ -1,10 +1,90 @@
-import { Coordinates, DistanceUnit } from "../../types/location.types";
+import { Coordinates, DistanceUnit, LocationAddress } from "../../types/location.types";
+import * as Location from "expo-location";
 
 export class LocationUtils {
     private static readonly EARTH_RADIUS_KM = 6371;
     private static readonly EARTH_RADIUS_MILES = 3959;
     private static readonly EARTH_RADIUS_METERS = 6371000;
 
+    // Accuracy thresholds in meters for classification
+    private static readonly ACCURACY_EXCELLENT_THRESHOLD = 10;
+    private static readonly ACCURACY_GOOD_THRESHOLD = 50;
+    private static readonly ACCURACY_FAIR_THRESHOLD = 100;
+    private static readonly DEFAULT_MAX_ACCURACY = 100;
+
+    /**
+     * Generates a cache key for location data
+     * @param cacheKey Base cache key
+     * @param withAddress Whether address is included
+     * @returns Formatted cache key
+     */
+    static generateCacheKey(cacheKey: string, withAddress: boolean): string {
+        const suffix = withAddress ? "_addr" : "";
+        return `location_cache_${cacheKey}${suffix}`;
+    }
+
+    /**
+     * Calculates the age of a cached location
+     * @param cachedTimestamp Timestamp when location was cached
+     * @returns Age in milliseconds
+     */
+    static getCacheAge(cachedTimestamp: number): number {
+        return Date.now() - cachedTimestamp;
+    }
+
+    /**
+     * Checks if cached location is expired
+     * @param cachedTimestamp Timestamp when location was cached
+     * @param cacheDuration Maximum cache duration in milliseconds
+     * @returns True if cache is expired
+     */
+    static isCacheExpired(cachedTimestamp: number, cacheDuration: number): boolean {
+        return LocationUtils.getCacheAge(cachedTimestamp) > cacheDuration;
+    }
+
+    /**
+     * Builds a formatted address from Expo Location address object
+     * @param address Expo Location address object (from reverseGeocodeAsync)
+     * @returns Formatted LocationAddress
+     */
+    static buildFormattedAddress(
+        address: Pick<Location.LocationGeocodedAddress, "street" | "city" | "region" | "country">
+    ): LocationAddress {
+        const addressParts = [
+            address.street,
+            address.city,
+            address.region,
+            address.country,
+        ].filter((part): part is string => Boolean(part));
+
+        return {
+            city: address.city ?? null,
+            region: address.region ?? null,
+            country: address.country ?? null,
+            street: address.street ?? null,
+            formattedAddress: addressParts.length > 0 ? addressParts.join(", ") : null,
+        };
+    }
+
+    /**
+     * Deep compares two objects by JSON stringification
+     * @param obj1 First object
+     * @param obj2 Second object
+     * @returns True if objects are deeply equal
+     */
+    static deepEqual(obj1: unknown, obj2: unknown): boolean {
+        return JSON.stringify(obj1) === JSON.stringify(obj2);
+    }
+
+    /**
+     * Generates a stable string reference for deep comparison
+     * @param obj Object to stringify
+     * @returns JSON string representation
+     */
+    static getStableReference(obj: unknown): string {
+        return JSON.stringify(obj ?? {});
+    }
+
     static calculateDistance(
         from: Coordinates,
         to: Coordinates,
@@ -36,6 +116,11 @@ export class LocationUtils {
     }
 
     static isValidCoordinate(latitude: number, longitude: number): boolean {
+        // Check for NaN and Infinity first
+        if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
+            return false;
+        }
+
         return (
             latitude >= -90 &&
             latitude <= 90 &&
@@ -44,10 +129,14 @@ export class LocationUtils {
         );
     }
 
-    static isValidAccuracy(accuracy: number | null | undefined, maxAccuracy = 100): boolean {
+    static isValidAccuracy(accuracy: number | null | undefined, maxAccuracy = LocationUtils.DEFAULT_MAX_ACCURACY): boolean {
         if (accuracy === null || accuracy === undefined) {
             return false;
         }
+        // Check for NaN and Infinity
+        if (!Number.isFinite(accuracy)) {
+            return false;
+        }
         return accuracy > 0 && accuracy <= maxAccuracy;
     }
 
@@ -56,13 +145,13 @@ export class LocationUtils {
             return "Unknown";
         }
 
-        if (accuracy < 10) {
+        if (accuracy < LocationUtils.ACCURACY_EXCELLENT_THRESHOLD) {
             return "Excellent (±" + Math.round(accuracy) + "m)";
         }
-        if (accuracy < 50) {
+        if (accuracy < LocationUtils.ACCURACY_GOOD_THRESHOLD) {
             return "Good (±" + Math.round(accuracy) + "m)";
         }
-        if (accuracy < 100) {
+        if (accuracy < LocationUtils.ACCURACY_FAIR_THRESHOLD) {
             return "Fair (±" + Math.round(accuracy) + "m)";
         }
         return "Poor (±" + Math.round(accuracy) + "m)";
@@ -73,6 +162,16 @@ export class LocationUtils {
         coord2: Coordinates,
         precision = 6
     ): boolean {
+        // Check for NaN and Infinity first
+        if (
+            !Number.isFinite(coord1.latitude) ||
+            !Number.isFinite(coord1.longitude) ||
+            !Number.isFinite(coord2.latitude) ||
+            !Number.isFinite(coord2.longitude)
+        ) {
+            return false;
+        }
+
         const epsilon = Math.pow(10, -precision);
         return (
             Math.abs(coord1.latitude - coord2.latitude) < epsilon &&

package/src/presentation/hooks/useLocation.ts

@@ -1,6 +1,9 @@
 import { useState, useCallback, useRef, useEffect } from "react";
 import { LocationService } from "../../infrastructure/services/LocationService";
 import { LocationData, LocationError, LocationConfig, LocationErrorCode } from "../../types/location.types";
+import { LocationUtils } from "../../infrastructure/utils/LocationUtils";
+
+const VALID_ERROR_CODES: readonly LocationErrorCode[] = ["PERMISSION_DENIED", "TIMEOUT", "UNKNOWN_ERROR"] as const;
 
 export interface UseLocationResult {
     location: LocationData | null;
@@ -10,11 +13,13 @@ export interface UseLocationResult {
 }
 
 export function useLocation(config?: LocationConfig): UseLocationResult {
-    const configRef = useRef(config);
+    // Use stable reference for deep comparison of config object
+    const configStringRef = useRef<string>(LocationUtils.getStableReference(config));
     const serviceRef = useRef(new LocationService(config));
 
-    if (configRef.current !== config) {
-        configRef.current = config;
+    const currentConfigString = LocationUtils.getStableReference(config);
+    if (configStringRef.current !== currentConfigString) {
+        configStringRef.current = currentConfigString;
         serviceRef.current = new LocationService(config);
     }
 
@@ -41,8 +46,16 @@ export function useLocation(config?: LocationConfig): UseLocationResult {
             }
             return data;
         } catch (err) {
+            // Extract and validate error code inline
+            let code: LocationErrorCode = "UNKNOWN_ERROR";
+            if (err instanceof Error && "code" in err && typeof err.code === "string") {
+                if (VALID_ERROR_CODES.includes(err.code as LocationErrorCode)) {
+                    code = err.code as LocationErrorCode;
+                }
+            }
+
             const errorObj: LocationError = {
-                code: extractErrorCode(err),
+                code,
                 message: err instanceof Error ? err.message : "An unknown error occurred",
             };
 
@@ -55,14 +68,7 @@ export function useLocation(config?: LocationConfig): UseLocationResult {
                 setIsLoading(false);
             }
         }
-    }, []);
+    }, [configStringRef]);
 
     return { location, isLoading, error, getCurrentLocation };
 }
-
-function extractErrorCode(err: unknown): LocationErrorCode {
-    if (err instanceof Error && "code" in err && typeof (err as { code: unknown }).code === "string") {
-        return (err as { code: string }).code as LocationErrorCode;
-    }
-    return "UNKNOWN_ERROR";
-}

package/src/presentation/hooks/useLocationWatch.ts

@@ -1,6 +1,7 @@
 import { useEffect, useRef, useState, useCallback } from "react";
 import { LocationWatcher } from "../../infrastructure/services/LocationWatcher";
 import { LocationData, LocationError, LocationWatcherOptions } from "../../types/location.types";
+import { LocationUtils } from "../../infrastructure/utils/LocationUtils";
 
 export interface UseLocationWatchResult {
     location: LocationData | null;
@@ -11,6 +12,8 @@ export interface UseLocationWatchResult {
 }
 
 export function useLocationWatch(options?: LocationWatcherOptions): UseLocationWatchResult {
+    // Use stable reference for deep comparison of options object
+    const optionsStringRef = useRef<string>(LocationUtils.getStableReference(options));
     const watcherRef = useRef<LocationWatcher | null>(null);
     const [location, setLocation] = useState<LocationData | null>(null);
     const [error, setError] = useState<LocationError | null>(null);
@@ -37,6 +40,8 @@ export function useLocationWatch(options?: LocationWatcherOptions): UseLocationW
                 setError(null);
             },
             (err) => {
+                // Clear watcher reference on error to maintain consistent state
+                watcherRef.current = null;
                 setError(err);
                 setIsWatching(false);
             },
@@ -45,7 +50,7 @@ export function useLocationWatch(options?: LocationWatcherOptions): UseLocationW
         if (watcher.isWatching()) {
             setIsWatching(true);
         }
-    }, [options, stopWatching]);
+    }, [optionsStringRef, stopWatching]); // Use string ref for stable dependency
 
     useEffect(() => {
         return () => {