Geolocation

navigator.geolocation.getCurrentPosition(
  (pos) => {
    const { latitude, longitude, accuracy } = pos.coords;
    console.log(latitude, longitude, `±${accuracy} m`);
  },
  (err) => console.error(err.code, err.message),
  { enableHighAccuracy: false, timeout: 10_000 },
);

const status = await navigator.permissions.query({
  name: "geolocation",
});
// "granted" | "denied" | "prompt"
status.addEventListener("change", () => {
  console.log(status.state); // never fires in Safari
});

function describe(err: GeolocationPositionError): string {
  switch (err.code) {
    case GeolocationPositionError.PERMISSION_DENIED:
      return "Location access is off";
    case GeolocationPositionError.POSITION_UNAVAILABLE:
      return "Couldn't find your location";
    case GeolocationPositionError.TIMEOUT:
      return "Finding your location took too long";
    default:
      return err.message;
  }
}

export function getPosition(
  options: PositionOptions = {},
  signal?: AbortSignal,
): Promise<GeolocationPosition> {
  return new Promise((resolve, reject) => {
    if (!window.isSecureContext) {
      reject(new Error("Geolocation needs HTTPS"));
      return;
    }
    signal?.throwIfAborted();
    signal?.addEventListener("abort", () =>
      reject(signal.reason),
    );
    navigator.geolocation.getCurrentPosition(
      resolve,
      reject, // GeolocationPositionError
      options,
    );
  });
}

type Fix = { lat: number; lng: number; accuracy: number };
 
export function watchLocation(
  onFix: (fix: Fix) => void,
  onError: (err: GeolocationPositionError) => void,
  maxAccuracy = 100, // meters
): () => void {
  const id = navigator.geolocation.watchPosition(
    ({ coords }) => {
      if (coords.accuracy > maxAccuracy) return;
      onFix({
        lat: coords.latitude,
        lng: coords.longitude,
        accuracy: coords.accuracy,
      });
    },
    onError,
    { enableHighAccuracy: true, maximumAge: 5_000 },
  );
  return () => navigator.geolocation.clearWatch(id);
}

import { useEffect, useState } from "react";
 
export function useGeolocation(options?: PositionOptions) {
  const [pos, setPos] = useState<GeolocationPosition>();
  const [error, setError] =
    useState<GeolocationPositionError>();
 
  useEffect(() => {
    const id = navigator.geolocation.watchPosition(
      setPos,
      setError,
      options,
    );
    return () => navigator.geolocation.clearWatch(id);
    // pass a stable (memoised) options object
  }, [options]);
 
  return { pos, error };
}

export type LatLng = { lat: number; lng: number };
 
const R = 6_371_008.8; // mean Earth radius, meters
const rad = (deg: number) => (deg * Math.PI) / 180;
 
export function distanceM(a: LatLng, b: LatLng): number {
  const dLat = rad(b.lat - a.lat);
  const dLng = rad(b.lng - a.lng);
  const h =
    Math.sin(dLat / 2) ** 2 +
    Math.cos(rad(a.lat)) *
      Math.cos(rad(b.lat)) *
      Math.sin(dLng / 2) ** 2;
  return 2 * R * Math.asin(Math.min(1, Math.sqrt(h)));
}
 
// London to Paris: ~343.5 km
distanceM(
  { lat: 51.5074, lng: -0.1278 },
  { lat: 48.8566, lng: 2.3522 },
);

import { distanceM, type LatLng } from "./haversine.ts";
import { getPosition } from "./get-position.ts";
 
type Place = LatLng & { name: string };
 
export async function nearest(places: Place[], n = 5) {
  const { coords } = await getPosition({
    maximumAge: 600_000,
    timeout: 8_000,
  });
  const me = { lat: coords.latitude, lng: coords.longitude };
  return places
    .map((p) => ({ ...p, meters: distanceM(me, p) }))
    .sort((a, b) => a.meters - b.meters)
    .slice(0, n);
}