@umituz/react-native-location 1.0.26 → 1.0.28

package/src/infrastructure/services/LocationWatcher.ts

@@ -1,96 +0,0 @@
-import * as Location from "expo-location";
-import {
-    LocationData,
-    LocationError,
-    LocationErrorCode,
-    LocationWatcherOptions,
-} from "../../types/location.types";
-
-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;
-
-    constructor(options: LocationWatcherOptions = {}) {
-        this.options = options;
-    }
-
-    async watchPosition(
-        onSuccess: (location: LocationData) => void,
-        onError?: (error: LocationError) => void,
-    ): Promise<void> {
-        this.clearWatch();
-
-        try {
-            const granted = await this.ensurePermission();
-            if (!granted) {
-                onError?.({ code: "PERMISSION_DENIED", message: "Location permission not granted" });
-                return;
-            }
-
-            this.subscription = await Location.watchPositionAsync(
-                {
-                    accuracy: this.options.accuracy ?? Location.Accuracy.Balanced,
-                    distanceInterval: this.options.distanceInterval,
-                    timeInterval: this.options.timeInterval,
-                },
-                (location) => {
-                    onSuccess({
-                        coords: {
-                            latitude: location.coords.latitude,
-                            longitude: location.coords.longitude,
-                        },
-                        timestamp: location.timestamp,
-                    });
-                },
-            );
-        } catch (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 && typeof error.code === "string") {
-                    if (LocationWatcher.VALID_ERROR_CODES.includes(error.code as LocationErrorCode)) {
-                        code = error.code as LocationErrorCode;
-                    }
-                }
-            }
-
-            onError?.({ code, message });
-        }
-    }
-
-    clearWatch(): void {
-        if (this.subscription) {
-            if (__DEV__) console.log("[LocationWatcher] Clearing location watch");
-            this.subscription.remove();
-            this.subscription = null;
-        }
-    }
-
-    isWatching(): boolean {
-        return this.subscription !== null;
-    }
-
-    private async ensurePermission(): Promise<boolean> {
-        try {
-            const { status: current } = await Location.getForegroundPermissionsAsync();
-            if (current === "granted") return true;
-
-            if (__DEV__) console.log("[LocationWatcher] Requesting permissions...");
-            const { status } = await Location.requestForegroundPermissionsAsync();
-            return status === "granted";
-        } catch (error) {
-            if (__DEV__) console.error("[LocationWatcher] Error requesting permissions:", error);
-            return false;
-        }
-    }
-}

package/src/infrastructure/utils/LocationUtils.ts

@@ -1,181 +0,0 @@
-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,
-        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 {
-        // Check for NaN and Infinity first
-        if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
-            return false;
-        }
-
-        return (
-            latitude >= -90 &&
-            latitude <= 90 &&
-            longitude >= -180 &&
-            longitude <= 180
-        );
-    }
-
-    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;
-    }
-
-    static formatAccuracy(accuracy: number | null | undefined): string {
-        if (accuracy === null || accuracy === undefined) {
-            return "Unknown";
-        }
-
-        if (accuracy < LocationUtils.ACCURACY_EXCELLENT_THRESHOLD) {
-            return "Excellent (±" + Math.round(accuracy) + "m)";
-        }
-        if (accuracy < LocationUtils.ACCURACY_GOOD_THRESHOLD) {
-            return "Good (±" + Math.round(accuracy) + "m)";
-        }
-        if (accuracy < LocationUtils.ACCURACY_FAIR_THRESHOLD) {
-            return "Fair (±" + Math.round(accuracy) + "m)";
-        }
-        return "Poor (±" + Math.round(accuracy) + "m)";
-    }
-
-    static coordinatesAreEqual(
-        coord1: Coordinates,
-        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 &&
-            Math.abs(coord1.longitude - coord2.longitude) < epsilon
-        );
-    }
-}

package/src/presentation/hooks/useLocation.ts

@@ -1,74 +0,0 @@
-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;
-    isLoading: boolean;
-    error: LocationError | null;
-    getCurrentLocation: () => Promise<LocationData | null>;
-}
-
-export function useLocation(config?: LocationConfig): UseLocationResult {
-    // Use stable reference for deep comparison of config object
-    const configStringRef = useRef<string>(LocationUtils.getStableReference(config));
-    const serviceRef = useRef(new LocationService(config));
-
-    const currentConfigString = LocationUtils.getStableReference(config);
-    if (configStringRef.current !== currentConfigString) {
-        configStringRef.current = currentConfigString;
-        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);
-        setError(null);
-
-        try {
-            const data = await serviceRef.current.getCurrentPosition();
-            if (mountedRef.current) {
-                setLocation(data);
-            }
-            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,
-                message: err instanceof Error ? err.message : "An unknown error occurred",
-            };
-
-            if (mountedRef.current) {
-                setError(errorObj);
-            }
-            return null;
-        } finally {
-            if (mountedRef.current) {
-                setIsLoading(false);
-            }
-        }
-    }, [configStringRef]);
-
-    return { location, isLoading, error, getCurrentLocation };
-}

package/src/presentation/hooks/useLocationWatch.ts

@@ -1,62 +0,0 @@
-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;
-    error: LocationError | null;
-    isWatching: boolean;
-    startWatching: () => Promise<void>;
-    stopWatching: () => void;
-}
-
-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);
-    const [isWatching, setIsWatching] = useState(false);
-
-    const stopWatching = useCallback(() => {
-        if (watcherRef.current) {
-            watcherRef.current.clearWatch();
-            watcherRef.current = null;
-            setIsWatching(false);
-        }
-    }, []);
-
-    const startWatching = useCallback(async () => {
-        stopWatching();
-        setError(null);
-
-        const watcher = new LocationWatcher(options);
-        watcherRef.current = watcher;
-
-        await watcher.watchPosition(
-            (data) => {
-                setLocation(data);
-                setError(null);
-            },
-            (err) => {
-                // Clear watcher reference on error to maintain consistent state
-                watcherRef.current = null;
-                setError(err);
-                setIsWatching(false);
-            },
-        );
-
-        if (watcher.isWatching()) {
-            setIsWatching(true);
-        }
-    }, [optionsStringRef, stopWatching]); // Use string ref for stable dependency
-
-    useEffect(() => {
-        return () => {
-            stopWatching();
-        };
-    }, [stopWatching]);
-
-    return { location, error, isWatching, startWatching, stopWatching };
-}