Merge pull request #3 from aboutbits/location-provider

Location provider

Author: NatanCieplinski

src/index.ts

@@ -1,5 +1,18 @@
 import { useInterval } from './useInterval/useInterval'
 import { AsyncState, getAsyncState } from './async-data/asyncState'
 import { AsyncView } from './async-data/AsyncView'
+import {
+  LocationProvider,
+  LocationContext,
+  LocationContextValue,
+} from './location-provider/LocationProvider'
 
-export { useInterval, AsyncState, getAsyncState, AsyncView }
+export {
+  useInterval,
+  AsyncState,
+  getAsyncState,
+  AsyncView,
+  LocationProvider,
+  LocationContext,
+  LocationContextValue,
+}

src/location-provider/LocationProvider.tsx

@@ -0,0 +1,42 @@
+import React, { useEffect, useState } from 'react'
+import { createContext } from 'react'
+import { useInterval } from '../index'
+import { getCurrentLocation } from './getCurrentLocation'
+
+export type LocationContextValue = {
+  location: GeolocationPosition | null
+}
+
+export const LocationContext = createContext<LocationContextValue>({
+  location: null,
+})
+
+export const LocationProvider: React.FC<{
+  highAccuracy: boolean
+  delay: number
+}> = ({ highAccuracy, delay, children }) => {
+  const [location, setLocation] = useState<LocationContextValue>({
+    location: null,
+  })
+
+  const updateLocation = async () => {
+    const position = await getCurrentLocation(highAccuracy).catch(
+      () => location.location
+    )
+    setLocation({ location: position })
+  }
+
+  useEffect(() => {
+    updateLocation()
+  }, [])
+
+  useInterval(() => {
+    updateLocation()
+  }, delay)
+
+  return (
+    <LocationContext.Provider value={location}>
+      {children}
+    </LocationContext.Provider>
+  )
+}

src/location-provider/getCurrentLocation.ts

@@ -0,0 +1,23 @@
+const getCurrentLocation = (
+  highAccuracy = false
+): Promise<GeolocationPosition> => {
+  return new Promise<GeolocationPosition>((resolve, reject) => {
+    const successCallback = (position: GeolocationPosition): void => {
+      resolve(position)
+    }
+
+    const errorCallback = (error: GeolocationPositionError) => {
+      reject(error.message)
+    }
+
+    if (navigator.geolocation) {
+      navigator.geolocation.getCurrentPosition(successCallback, errorCallback, {
+        enableHighAccuracy: highAccuracy,
+      })
+    } else {
+      reject('Geolocation not supported')
+    }
+  })
+}
+
+export { getCurrentLocation }