@umituz/react-native-location 1.0.5 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-location",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Device location services for React Native with GPS, permissions, caching, and reverse geocoding",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -33,10 +33,11 @@
     "react-native": ">=0.74.0"
   },
   "devDependencies": {
+    "@types/react": "~19.1.10",
     "@umituz/react-native-design-system": "latest",
     "@umituz/react-native-storage": "latest",
     "expo-location": "~18.0.0",
-    "@types/react": "~19.1.10",
+    "firebase": "^12.7.0",
     "react": "19.1.0",
     "react-native": "0.81.5",
     "typescript": "~5.9.2"
@@ -49,4 +50,4 @@
     "README.md",
     "LICENSE"
   ]
-}
+}

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,4 @@
 export * from "./domain/entities/Location";
+export * from "./types/location.types";
 export * from "./infrastructure/services/LocationService";
 export * from "./presentation/hooks/useLocation";

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,12 @@ 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;
         }
     }
 }
 
-export const locationService = new LocationService();
+export function createLocationService(config?: LocationConfig): LocationService {
+    return new LocationService(config);
+}

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/types/location.types.ts

@@ -0,0 +1,65 @@
+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 interface LocationConfig {
+    accuracy?: Location.Accuracy;
+    timeout?: number;
+    enableCache?: boolean;
+    cacheKey?: string;
+    cacheDuration?: number;
+    withAddress?: boolean;
+}
+
+export const DEFAULT_LOCATION_CONFIG: LocationConfig = {
+    accuracy: Location.Accuracy.Balanced,
+    timeout: 10000,
+    enableCache: true,
+    cacheKey: "default",
+    cacheDuration: 300000,
+    withAddress: true,
+};
+
+export type LocationErrorCode =
+    | "PERMISSION_DENIED"
+    | "LOCATION_UNAVAILABLE"
+    | "TIMEOUT"
+    | "CACHE_ERROR"
+    | "UNKNOWN_ERROR";
+
+export class LocationErrorImpl extends Error implements LocationError {
+    code: LocationErrorCode;
+
+    constructor(code: LocationErrorCode, message: string) {
+        super(message);
+        this.name = "LocationError";
+        this.code = code;
+    }
+}