expo-realtime-maps-navigation/lib/hooks/useLiveLocation.js

JavaScript-pure React Native navigation package with Google Places + HERE Routing APIs, dual maps support, and complete customization - No native modules required!

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.calculateBearing = exports.calculateDistance = exports.useLocationHealth = exports.useCurrentHeading = exports.useCurrentPosition = exports.useLocationStatus = exports.useLiveLocation = void 0;
const react_1 = require("react");
const HereNavProvider_1 = require("../components/HereNavProvider");
const useLiveLocation = () => {
    const { location } = (0, HereNavProvider_1.useHereNavContext)();
    const locationData = (0, react_1.useMemo)(() => {
        const hasLocation = !!location.position;
        const hasHeading = location.heading !== null;
        const isSimulated = location.source === 'simulated';
        let gpsQuality = 'unknown';
        if (location.accuracy !== null) {
            if (location.accuracy <= 5) {
                gpsQuality = 'excellent';
            }
            else if (location.accuracy <= 10) {
                gpsQuality = 'good';
            }
            else if (location.accuracy <= 20) {
                gpsQuality = 'fair';
            }
            else {
                gpsQuality = 'poor';
            }
        }
        const isAccurate = location.accuracy !== null && location.accuracy <= 10;
        const isStale = location.timestamp ? Date.now() - location.timestamp.getTime() > 30000 : true;
        const formattedAccuracy = location.accuracy !== null ? `±${Math.round(location.accuracy)}m` : 'Unknown';
        const formattedCoordinates = location.position
            ? `${location.position.latitude.toFixed(6)}, ${location.position.longitude.toFixed(6)}`
            : 'No location';
        return {
            position: location.position,
            heading: location.heading,
            accuracy: location.accuracy,
            source: location.source,
            timestamp: location.timestamp,
            isAccurate,
            isStale,
            formattedAccuracy,
            formattedCoordinates,
            gpsQuality,
            hasLocation,
            hasHeading,
            isSimulated,
        };
    }, [location]);
    return locationData;
};
exports.useLiveLocation = useLiveLocation;
const useLocationStatus = () => {
    const location = (0, exports.useLiveLocation)();
    return (0, react_1.useMemo)(() => {
        if (!location.hasLocation) {
            return {
                status: 'no_location',
                message: 'Location not available',
                color: '#FF3B30',
            };
        }
        if (location.isStale) {
            return {
                status: 'stale',
                message: 'Location data is stale',
                color: '#FF9500',
            };
        }
        if (location.gpsQuality === 'poor') {
            return {
                status: 'poor_accuracy',
                message: `Poor GPS signal (${location.formattedAccuracy})`,
                color: '#FF9500',
            };
        }
        if (location.gpsQuality === 'fair') {
            return {
                status: 'fair_accuracy',
                message: `GPS accuracy ${location.formattedAccuracy}`,
                color: '#FFCC00',
            };
        }
        return {
            status: 'good',
            message: `GPS accuracy ${location.formattedAccuracy}`,
            color: '#34C759',
        };
    }, [location]);
};
exports.useLocationStatus = useLocationStatus;
const useCurrentPosition = () => {
    const { location } = (0, HereNavProvider_1.useHereNavContext)();
    return (0, react_1.useMemo)(() => {
        return location.position;
    }, [location.position]);
};
exports.useCurrentPosition = useCurrentPosition;
const useCurrentHeading = () => {
    const { location } = (0, HereNavProvider_1.useHereNavContext)();
    return (0, react_1.useMemo)(() => {
        return location.heading;
    }, [location.heading]);
};
exports.useCurrentHeading = useCurrentHeading;
const useLocationHealth = () => {
    const location = (0, exports.useLiveLocation)();
    const { permissions } = (0, HereNavProvider_1.useHereNavContext)();
    return (0, react_1.useMemo)(() => {
        if (permissions.location !== 'granted') {
            return {
                isHealthy: false,
                issue: 'permission_denied',
                message: 'Location permission not granted',
                suggestion: 'Enable location permission in Settings',
                severity: 'critical',
            };
        }
        if (!location.hasLocation) {
            return {
                isHealthy: false,
                issue: 'no_location',
                message: 'No location data available',
                suggestion: 'Move to an area with clear sky view',
                severity: 'critical',
            };
        }
        if (location.isStale) {
            return {
                isHealthy: false,
                issue: 'stale_location',
                message: 'Location data is outdated',
                suggestion: 'Check if location services are enabled',
                severity: 'warning',
            };
        }
        if (location.gpsQuality === 'poor') {
            return {
                isHealthy: false,
                issue: 'poor_accuracy',
                message: 'GPS accuracy is poor',
                suggestion: 'Move away from buildings or tunnels',
                severity: 'warning',
            };
        }
        return {
            isHealthy: true,
            issue: null,
            message: 'Location services working properly',
            suggestion: null,
            severity: 'info',
        };
    }, [location, permissions.location]);
};
exports.useLocationHealth = useLocationHealth;
const calculateDistance = (point1, point2) => {
    const R = 6371e3;
    const φ1 = (point1.latitude * Math.PI) / 180;
    const φ2 = (point2.latitude * Math.PI) / 180;
    const Δφ = ((point2.latitude - point1.latitude) * Math.PI) / 180;
    const Δλ = ((point2.longitude - point1.longitude) * Math.PI) / 180;
    const a = Math.sin(Δφ / 2) * Math.sin(Δφ / 2) +
        Math.cos(φ1) * Math.cos(φ2) * Math.sin(Δλ / 2) * Math.sin(Δλ / 2);
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
    return R * c;
};
exports.calculateDistance = calculateDistance;
const calculateBearing = (point1, point2) => {
    const φ1 = (point1.latitude * Math.PI) / 180;
    const φ2 = (point2.latitude * Math.PI) / 180;
    const Δλ = ((point2.longitude - point1.longitude) * Math.PI) / 180;
    const y = Math.sin(Δλ) * Math.cos(φ2);
    const x = Math.cos(φ1) * Math.sin(φ2) - Math.sin(φ1) * Math.cos(φ2) * Math.cos(Δλ);
    let bearing = (Math.atan2(y, x) * 180) / Math.PI;
    bearing = (bearing + 360) % 360;
    return bearing;
};
exports.calculateBearing = calculateBearing;