Upload 4 files

src/lib/notifications.ts

@@ -0,0 +1,60 @@
+export async function requestNotificationPermission(): Promise<boolean> {
+  if (!('Notification' in window)) {
+    console.warn('This browser does not support notifications');
+    return false;
+  }
+
+  if (Notification.permission === 'granted') {
+    return true;
+  }
+
+  if (Notification.permission !== 'denied') {
+    const permission = await Notification.requestPermission();
+    return permission === 'granted';
+  }
+
+  return false;
+}
+
+export function showNotification(title: string, options?: NotificationOptions): Notification | null {
+  if (!('Notification' in window) || Notification.permission !== 'granted') {
+    return null;
+  }
+
+  const notification = new Notification(title, {
+    icon: '/favicon.ico',
+    badge: '/favicon.ico',
+    ...options
+  });
+
+  setTimeout(() => notification.close(), 5000);
+
+  return notification;
+}
+
+export function showWeatherAlert(weather: string, temp: number): void {
+  const badWeather = ['Rain', 'Drizzle', 'Snow', 'Thunderstorm', 'Fog', 'Mist'];
+  if (!badWeather.includes(weather)) return;
+
+  showNotification('Weather Alert', {
+    body: `${weather} detected! Temperature: ${Math.round(temp - 273.15)}°C. Drive safely!`,
+    tag: 'weather-alert',
+    requireInteraction: false
+  });
+}
+
+export function showRouteAlert(distance: string, duration: string, safetyScore: number): void {
+  const emoji = safetyScore >= 70 ? '✅' : safetyScore >= 40 ? '⚠️' : '🚨';
+  showNotification('Route Ready', {
+    body: `${emoji} ${distance} • ${duration} • Safety: ${safetyScore}%`,
+    tag: 'route-ready'
+  });
+}
+
+export function showIncidentAlert(incidentType: string, severity: string): void {
+  showNotification('Incident Nearby', {
+    body: `${incidentType} reported - ${severity} severity. Please drive carefully.`,
+    tag: 'incident-alert',
+    requireInteraction: true
+  });
+}

src/lib/orsApi.ts

@@ -0,0 +1,114 @@
+import axios from 'axios';
+
+const API_KEY = import.meta.env.VITE_OPENROUTESERVICE_API_KEY || '';
+
+export async function getORSRoute(
+  start: [number, number],
+  end: [number, number],
+  profile: string = 'driving-car'
+): Promise<any> {
+  const res = await axios.post(
+    `https://api.openrouteservice.org/v2/directions/${profile}`,
+    {
+      coordinates: [
+        [start[0], start[1]],
+        [end[0], end[1]]
+      ]
+    },
+    {
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': API_KEY
+      },
+      params: {
+        geometries: 'geojson',
+        overview: 'full',
+        steps: true
+      }
+    }
+  );
+
+  return res.data;
+}
+
+export async function getORSRouteWithWaypoints(
+  coordinates: [number, number][],
+  profile: string = 'driving-car'
+): Promise<any> {
+  const res = await axios.post(
+    `https://api.openrouteservice.org/v2/directions/${profile}`,
+    {
+      coordinates: coordinates.map(([lng, lat]) => [lng, lat])
+    },
+    {
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': API_KEY
+      },
+      params: {
+        geometries: 'geojson',
+        overview: 'full',
+        steps: true
+      }
+    }
+  );
+
+  return res.data;
+}
+
+export async function searchLocation(query: string) {
+  const res = await axios.get(
+    `https://nominatim.openstreetmap.org/search?format=json&q=${encodeURIComponent(query)}&limit=10`
+  );
+  return res.data;
+}
+
+export async function reverseGeocode(lat: number, lon: number) {
+  const res = await axios.get(
+    `https://nominatim.openstreetmap.org/reverse?format=json&lat=${lat}&lon=${lon}`
+  );
+  return res.data;
+}
+
+export function decodePolyline(encoded: string): [number, number][] {
+  const poly: [number, number][] = [];
+  let index = 0;
+  const len = encoded.length;
+  let lat = 0;
+  let lng = 0;
+
+  while (index < len) {
+    let b;
+    let shift = 0;
+    let result = 0;
+
+    do {
+      b = encoded.charCodeAt(index++) - 63;
+      result |= (b & 0x1f) << shift;
+      shift += 5;
+    } while (b >= 0x20);
+
+    const dlat = (result & 1) !== 0 ? ~(result >> 1) : (result >> 1);
+    lat += dlat;
+
+    shift = 0;
+    result = 0;
+
+    do {
+      b = encoded.charCodeAt(index++) - 63;
+      result |= (b & 0x1f) << shift;
+      shift += 5;
+    } while (b >= 0x20);
+
+    const dlng = (result & 1) !== 0 ? ~(result >> 1) : (result >> 1);
+    lng += dlng;
+
+    poly.push([lat / 1e5, lng / 1e5]);
+  }
+
+  return poly;
+}
+
+export function coordsToLeaflet(coords: [number, number][]): [number, number][] {
+  return coords.map(([lng, lat]) => [lat, lng] as [number, number]);
+}

src/lib/routeCache.ts

@@ -0,0 +1,47 @@
+interface CacheEntry<T> {
+  data: T;
+  timestamp: number;
+}
+
+const cache = new Map<string, CacheEntry<unknown>>();
+const DEFAULT_TTL = 3 * 60 * 1000; // 3 minutes
+
+export function getCached<T>(key: string): T | null {
+  const entry = cache.get(key) as CacheEntry<T> | undefined;
+  if (!entry) return null;
+
+  const age = Date.now() - entry.timestamp;
+  if (age > DEFAULT_TTL) {
+    cache.delete(key);
+    return null;
+  }
+
+  return entry.data;
+}
+
+export function setCache<T>(key: string, data: T, ttl = DEFAULT_TTL): void {
+  if (!data || (Array.isArray(data) && data.length === 0)) {
+    return;
+  }
+  cache.set(key, { data, timestamp: Date.now() });
+}
+
+export function clearCache(): void {
+  cache.clear();
+}
+
+export function getCacheKey(prefix: string, ...params: (string | number | boolean)[]): string {
+  return `${prefix}:${params.join(':')}`;
+}
+
+export function generateRouteCacheKey(start: [number, number], end: [number, number], profile: string): string {
+  return getCacheKey('route', start.join(','), end.join(','), profile);
+}
+
+export function generateGeocodeCacheKey(query: string): string {
+  return getCacheKey('geocode', query.toLowerCase().trim());
+}
+
+export function generateWeatherCacheKey(lat: number, lon: number): string {
+  return getCacheKey('weather', lat.toFixed(3), lon.toFixed(3));
+}

src/lib/voiceNavigation.ts

@@ -0,0 +1,76 @@
+let utterance: SpeechSynthesisUtterance | null = null;
+
+export function speak(text: string): void {
+  if (!('speechSynthesis' in window)) {
+    console.warn('Speech synthesis not supported');
+    return;
+  }
+
+  window.speechSynthesis.cancel();
+
+  utterance = new SpeechSynthesisUtterance(text);
+  utterance.rate = 1.0;
+  utterance.pitch = 1.0;
+  utterance.volume = 1.0;
+
+  const voices = window.speechSynthesis.getVoices();
+  const englishVoice = voices.find(v => v.lang.startsWith('en') && v.name.includes('Google')) ||
+                       voices.find(v => v.lang.startsWith('en'));
+  if (englishVoice) {
+    utterance.voice = englishVoice;
+  }
+
+  window.speechSynthesis.speak(utterance);
+}
+
+export function stopSpeaking(): void {
+  if ('speechSynthesis' in window) {
+    window.speechSynthesis.cancel();
+  }
+}
+
+export function isSpeaking(): boolean {
+  if (!('speechSynthesis' in window)) return false;
+  return window.speechSynthesis.speaking;
+}
+
+export function getAvailableVoices(): SpeechSynthesisVoice[] {
+  if (!('speechSynthesis' in window)) return [];
+  return window.speechSynthesis.getVoices().filter(v => v.lang.startsWith('en'));
+}
+
+export function formatDirectionForSpeech(instruction: string): string {
+  return instruction
+    .replace(/onto/gi, 'onto')
+    .replace(/Continue/gi, 'Continue')
+    .replace(/Turn left/gi, 'Turn left')
+    .replace(/Turn right/gi, 'Turn right')
+    .replace(/Slight left/gi, 'Bear left')
+    .replace(/Slight right/gi, 'Bear right')
+    .replace(/km/g, 'kilometers')
+    .replace(/m/g, 'meters')
+    .trim();
+}
+
+export function speakDirection(step: { maneuver: { type?: string; modifier?: string; instruction?: string; name?: string }; distance?: number }): void {
+  let text = '';
+
+  if (step.maneuver.instruction) {
+    text = formatDirectionForSpeech(step.maneuver.instruction);
+  } else {
+    const type = step.maneuver.type || '';
+    const modifier = step.maneuver.modifier || '';
+    const name = step.maneuver.name || '';
+    text = `${type} ${modifier}`.trim();
+    if (name) text += ` onto ${name}`;
+  }
+
+  if (step.distance && step.distance > 0) {
+    const distText = step.distance >= 1000
+      ? `${(step.distance / 1000).toFixed(1)} kilometers`
+      : `${Math.round(step.distance)} meters`;
+    text += `. Then go ${distText}.`;
+  }
+
+  speak(text);
+}