@umituz/react-native-location 1.0.15 → 1.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-location",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "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,3 @@
-export * from "./domain/entities/Location";
 export * from "./types/location.types";
 export * from "./infrastructure/services/LocationService";
 export * from "./infrastructure/services/LocationWatcher";

package/src/infrastructure/services/LocationService.ts

@@ -2,21 +2,33 @@ import * as Location from "expo-location";
 import { storageRepository, unwrap } from "@umituz/react-native-design-system/storage";
 import {
     LocationData,
+    LocationAddress,
     LocationConfig,
-    DEFAULT_LOCATION_CONFIG,
-    CachedLocationData,
-    LocationErrorImpl,
+    LocationError,
     LocationErrorCode,
 } from "../../types/location.types";
 
-declare const __DEV__: boolean;
+interface CachedLocationData {
+    location: LocationData;
+    timestamp: number;
+}
+
+const DEFAULT_CONFIG: Required<LocationConfig> = {
+    accuracy: Location.Accuracy.Balanced,
+    timeout: 10000,
+    enableCache: true,
+    cacheKey: "default",
+    cacheDuration: 300000,
+    withAddress: true,
+};
 
 export class LocationService {
-    private config: LocationConfig;
+    private config: Required<LocationConfig>;
     private storage = storageRepository;
+    private inFlightRequest: Promise<LocationData> | null = null;
 
     constructor(config: LocationConfig = {}) {
-        this.config = { ...DEFAULT_LOCATION_CONFIG, ...config };
+        this.config = { ...DEFAULT_CONFIG, ...config };
     }
 
     private log(message: string, ...args: unknown[]): void {
@@ -31,17 +43,13 @@ export class LocationService {
         }
     }
 
-    private logWarn(message: string, ...args: unknown[]): void {
-        if (__DEV__) {
-            console.warn(`[LocationService] ${message}`, ...args);
-        }
-    }
-
     async requestPermissions(): Promise<boolean> {
         try {
+            const { status: current } = await Location.getForegroundPermissionsAsync();
+            if (current === "granted") return true;
+
             this.log("Requesting permissions...");
             const { status } = await Location.requestForegroundPermissionsAsync();
-            this.log("Permission status:", status);
             return status === "granted";
         } catch (error) {
             this.logError("Error requesting permissions:", error);
@@ -49,27 +57,23 @@ export class LocationService {
         }
     }
 
+    private getCacheKey(): string {
+        const suffix = this.config.withAddress ? "_addr" : "";
+        return `location_cache_${this.config.cacheKey}${suffix}`;
+    }
+
     private async getCachedLocation(): Promise<LocationData | null> {
-        if (!this.config.enableCache) {
-            return null;
-        }
+        if (!this.config.enableCache) return null;
 
         try {
-            const cacheKey = `location_cache_${this.config.cacheKey}`;
+            const cacheKey = this.getCacheKey();
             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 (!cached) return null;
 
-            if (cacheAge > cacheDuration) {
-                this.log("Cache expired");
+            const cacheAge = Date.now() - cached.timestamp;
+            if (cacheAge > this.config.cacheDuration) {
                 await this.storage.removeItem(cacheKey);
                 return null;
             }
@@ -83,55 +87,47 @@ export class LocationService {
     }
 
     private async cacheLocation(location: LocationData): Promise<void> {
-        if (!this.config.enableCache) {
-            return;
-        }
+        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");
+            const data: CachedLocationData = { location, timestamp: Date.now() };
+            await this.storage.setItem(this.getCacheKey(), data);
         } catch (error) {
             this.logError("Cache write error:", error);
         }
     }
 
     async getCurrentPosition(): Promise<LocationData> {
-        const withAddress = this.config.withAddress ?? true;
+        if (this.inFlightRequest) {
+            return this.inFlightRequest;
+        }
 
-        this.log("getCurrentPosition called");
+        this.inFlightRequest = this.fetchPosition();
+        try {
+            return await this.inFlightRequest;
+        } finally {
+            this.inFlightRequest = null;
+        }
+    }
 
+    private async fetchPosition(): Promise<LocationData> {
         const cached = await this.getCachedLocation();
-        if (cached) {
-            this.log("Returning cached location");
-            return cached;
-        }
+        if (cached) return cached;
 
         const hasPermission = await this.requestPermissions();
         if (!hasPermission) {
-            this.logWarn("Permission denied");
-            throw new LocationErrorImpl("PERMISSION_DENIED", "Location permission not granted");
+            throw this.createError("PERMISSION_DENIED", "Location permission not granted");
         }
 
         try {
-            this.log("Getting position...");
-            const location = await Location.getCurrentPositionAsync({
-                accuracy: this.config.accuracy,
-            });
-            this.log("Position obtained", location);
-
-            let addressData;
-            if (withAddress) {
-                this.log("Reverse geocoding...");
-                addressData = await this.reverseGeocode(
+            const location = await this.getPositionWithTimeout();
+
+            let address: LocationAddress | undefined;
+            if (this.config.withAddress) {
+                address = await this.reverseGeocode(
                     location.coords.latitude,
-                    location.coords.longitude
+                    location.coords.longitude,
                 );
-                this.log("Address obtained", addressData);
             }
 
             const locationData: LocationData = {
@@ -140,53 +136,64 @@ export class LocationService {
                     longitude: location.coords.longitude,
                 },
                 timestamp: location.timestamp,
-                address: addressData,
+                address,
             };
 
             await this.cacheLocation(locationData);
-
             return locationData;
         } catch (error) {
             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;
+            if (error instanceof Error && "code" in error) {
+                throw error;
             }
 
-            throw new LocationErrorImpl(errorCode, errorMessage);
+            const message = error instanceof Error ? error.message : "Unknown error getting location";
+            throw this.createError("UNKNOWN_ERROR", message);
         }
     }
 
-    async reverseGeocode(latitude: number, longitude: number) {
+    private async getPositionWithTimeout(): Promise<Location.LocationObject> {
+        let timeoutId: ReturnType<typeof setTimeout>;
+
+        const locationPromise = Location.getCurrentPositionAsync({
+            accuracy: this.config.accuracy,
+        });
+
+        const timeoutPromise = new Promise<never>((_, reject) => {
+            timeoutId = setTimeout(() => {
+                reject(this.createError("TIMEOUT", `Location request timed out after ${this.config.timeout}ms`));
+            }, this.config.timeout);
+        });
+
+        const result = await Promise.race([locationPromise, timeoutPromise]);
+        clearTimeout(timeoutId!);
+        return result;
+    }
+
+    async reverseGeocode(latitude: number, longitude: number): Promise<LocationAddress | undefined> {
         try {
             const [address] = await Location.reverseGeocodeAsync({ latitude, longitude });
             if (!address) return undefined;
 
             return {
-                city: address.city,
-                region: address.region,
-                country: address.country,
-                street: address.street,
-                formattedAddress: [address.city, address.country].filter(Boolean).join(", "),
+                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,
             };
         } catch (error) {
-            this.logWarn("Reverse geocode failed:", error);
+            this.logError("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;
+            return await Location.hasServicesEnabledAsync();
         } catch (error) {
             this.logError("Error checking location enabled:", error);
             return false;
@@ -195,10 +202,8 @@ export class LocationService {
 
     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;
+            const { status } = await Location.getForegroundPermissionsAsync();
+            return status;
         } catch (error) {
             this.logError("Error getting permission status:", error);
             return Location.PermissionStatus.UNDETERMINED;
@@ -207,15 +212,8 @@ export class LocationService {
 
     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);
+            if (!location) return null;
 
             return {
                 coords: {
@@ -229,8 +227,11 @@ export class LocationService {
             return null;
         }
     }
-}
 
-export function createLocationService(config?: LocationConfig): LocationService {
-    return new LocationService(config);
+    private createError(code: LocationErrorCode, message: string): LocationError & Error {
+        const error = new Error(message) as Error & LocationError;
+        error.name = "LocationError";
+        error.code = code;
+        return error;
+    }
 }

package/src/infrastructure/services/LocationWatcher.ts

@@ -2,14 +2,12 @@ import * as Location from "expo-location";
 import {
     LocationData,
     LocationError,
-    LocationCallback,
-    LocationErrorCallback,
-    LocationWatcherOptions,
-    LocationErrorImpl,
     LocationErrorCode,
+    LocationWatcherOptions,
 } from "../../types/location.types";
 
-declare const __DEV__: boolean;
+type LocationCallback = (location: LocationData) => void;
+type ErrorCallback = (error: LocationError) => void;
 
 export class LocationWatcher {
     private subscription: Location.LocationSubscription | null = null;
@@ -31,70 +29,46 @@ export class LocationWatcher {
         }
     }
 
-    async watchPosition(
-        onSuccess: LocationCallback,
-        onError?: LocationErrorCallback
-    ): Promise<string> {
-        try {
-            this.log("Requesting permissions...");
-            const { status } = await Location.requestForegroundPermissionsAsync();
+    async watchPosition(onSuccess: LocationCallback, onError?: ErrorCallback): Promise<void> {
+        this.clearWatch();
 
-            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");
+        try {
+            const granted = await this.ensurePermission();
+            if (!granted) {
+                onError?.({ code: "PERMISSION_DENIED", message: "Location permission not granted" });
+                return;
             }
 
-            this.log("Starting location watch...");
-
             this.subscription = await Location.watchPositionAsync(
                 {
-                    accuracy: this.options.accuracy || Location.Accuracy.Balanced,
+                    accuracy: this.options.accuracy ?? Location.Accuracy.Balanced,
+                    distanceInterval: this.options.distanceInterval,
+                    timeInterval: this.options.timeInterval,
                 },
                 (location) => {
-                    this.log("Location update received", location);
-
-                    const locationData: LocationData = {
+                    onSuccess({
                         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";
+            let code: LocationErrorCode = "UNKNOWN_ERROR";
+            let message = "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);
+            if (error instanceof Error) {
+                message = error.message;
+                if ("code" in error) {
+                    code = (error as { code: string }).code as LocationErrorCode;
+                }
             }
 
-            throw new LocationErrorImpl(errorCode, errorMessage);
+            onError?.({ code, message });
         }
     }
 
@@ -109,8 +83,18 @@ export class LocationWatcher {
     isWatching(): boolean {
         return this.subscription !== null;
     }
-}
 
-export function createLocationWatcher(options?: LocationWatcherOptions): LocationWatcher {
-    return new LocationWatcher(options);
+    private async ensurePermission(): Promise<boolean> {
+        try {
+            const { status: current } = await Location.getForegroundPermissionsAsync();
+            if (current === "granted") return true;
+
+            this.log("Requesting permissions...");
+            const { status } = await Location.requestForegroundPermissionsAsync();
+            return status === "granted";
+        } catch (error) {
+            this.logError("Error requesting permissions:", error);
+            return false;
+        }
+    }
 }

package/src/infrastructure/utils/LocationUtils.ts

@@ -73,11 +73,10 @@ export class LocationUtils {
         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;
+        const epsilon = Math.pow(10, -precision);
+        return (
+            Math.abs(coord1.latitude - coord2.latitude) < epsilon &&
+            Math.abs(coord1.longitude - coord2.longitude) < epsilon
+        );
     }
 }

package/src/presentation/hooks/useLocation.ts

@@ -1,6 +1,6 @@
-import { useState, useCallback, useRef } from "react";
-import { createLocationService } from "../../infrastructure/services/LocationService";
-import { LocationData, LocationError, LocationConfig } from "../../types/location.types";
+import { useState, useCallback, useRef, useEffect } from "react";
+import { LocationService } from "../../infrastructure/services/LocationService";
+import { LocationData, LocationError, LocationConfig, LocationErrorCode } from "../../types/location.types";
 
 export interface UseLocationResult {
     location: LocationData | null;
@@ -10,10 +10,25 @@ export interface UseLocationResult {
 }
 
 export function useLocation(config?: LocationConfig): UseLocationResult {
-    const serviceRef = useRef(createLocationService(config));
+    const configRef = useRef(config);
+    const serviceRef = useRef(new LocationService(config));
+
+    if (configRef.current !== config) {
+        configRef.current = config;
+        serviceRef.current = new LocationService(config);
+    }
+
     const [location, setLocation] = useState<LocationData | null>(null);
     const [isLoading, setIsLoading] = useState(false);
     const [error, setError] = useState<LocationError | null>(null);
+    const mountedRef = useRef(true);
+
+    useEffect(() => {
+        mountedRef.current = true;
+        return () => {
+            mountedRef.current = false;
+        };
+    }, []);
 
     const getCurrentLocation = useCallback(async () => {
         setIsLoading(true);
@@ -21,32 +36,33 @@ export function useLocation(config?: LocationConfig): UseLocationResult {
 
         try {
             const data = await serviceRef.current.getCurrentPosition();
-            setLocation(data);
+            if (mountedRef.current) {
+                setLocation(data);
+            }
             return data;
         } catch (err) {
-            let errorObj: LocationError = {
-                code: "UNKNOWN_ERROR",
-                message: "An unknown error occurred",
+            const errorObj: LocationError = {
+                code: extractErrorCode(err),
+                message: err instanceof Error ? err.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",
-                };
+            if (mountedRef.current) {
+                setError(errorObj);
             }
-
-            setError(errorObj);
             return null;
         } finally {
-            setIsLoading(false);
+            if (mountedRef.current) {
+                setIsLoading(false);
+            }
         }
     }, []);
 
-    return {
-        location,
-        isLoading,
-        error,
-        getCurrentLocation,
-    };
+    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,5 +1,5 @@
 import { useEffect, useRef, useState, useCallback } from "react";
-import { createLocationWatcher } from "../../infrastructure/services/LocationWatcher";
+import { LocationWatcher } from "../../infrastructure/services/LocationWatcher";
 import { LocationData, LocationError, LocationWatcherOptions } from "../../types/location.types";
 
 export interface UseLocationWatchResult {
@@ -11,7 +11,7 @@ export interface UseLocationWatchResult {
 }
 
 export function useLocationWatch(options?: LocationWatcherOptions): UseLocationWatchResult {
-    const watcherRef = useRef<ReturnType<typeof createLocationWatcher> | null>(null);
+    const watcherRef = useRef<LocationWatcher | null>(null);
     const [location, setLocation] = useState<LocationData | null>(null);
     const [error, setError] = useState<LocationError | null>(null);
     const [isWatching, setIsWatching] = useState(false);
@@ -26,36 +26,24 @@ export function useLocationWatch(options?: LocationWatcherOptions): UseLocationW
 
     const startWatching = useCallback(async () => {
         stopWatching();
+        setError(null);
 
-        const watcher = createLocationWatcher(options);
+        const watcher = new LocationWatcher(options);
         watcherRef.current = watcher;
 
-        try {
-            await watcher.watchPosition(
-                (data) => {
-                    setLocation(data);
-                    setError(null);
-                },
-                (err) => {
-                    setError(err);
-                }
-            );
+        await watcher.watchPosition(
+            (data) => {
+                setLocation(data);
+                setError(null);
+            },
+            (err) => {
+                setError(err);
+                setIsWatching(false);
+            },
+        );
+
+        if (watcher.isWatching()) {
             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]);
 
@@ -65,11 +53,5 @@ export function useLocationWatch(options?: LocationWatcherOptions): UseLocationW
         };
     }, [stopWatching]);
 
-    return {
-        location,
-        error,
-        isWatching,
-        startWatching,
-        stopWatching,
-    };
+    return { location, error, isWatching, startWatching, stopWatching };
 }

package/src/types/env.d.ts

@@ -0,0 +1 @@
+declare const __DEV__: boolean;

package/src/types/location.types.ts

@@ -6,11 +6,11 @@ export interface Coordinates {
 }
 
 export interface LocationAddress {
-    city?: string | null;
-    region?: string | null;
-    country?: string | null;
-    street?: string | null;
-    formattedAddress?: string | null;
+    city: string | null;
+    region: string | null;
+    country: string | null;
+    street: string | null;
+    formattedAddress: string | null;
 }
 
 export interface LocationData {
@@ -19,25 +19,18 @@ export interface LocationData {
     address?: LocationAddress;
 }
 
+export type LocationErrorCode =
+    | "PERMISSION_DENIED"
+    | "TIMEOUT"
+    | "UNKNOWN_ERROR";
+
 export interface LocationError {
-    code: string;
+    code: LocationErrorCode;
     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;
@@ -45,34 +38,10 @@ export interface LocationConfig {
     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;
-    }
+    distanceInterval?: number;
+    timeInterval?: number;
 }

package/src/domain/entities/Location.ts

@@ -1 +0,0 @@
-export * from "../../types/location.types";