updates on the ui changes and changed into doormile

src/lib/distance.js

@@ -0,0 +1,78 @@
+/**
+ * Calculates distance (in km) between origin and destination.
+ * Uses OSRM as primary driving distance source, and falls back to Haversine with a 1.3 multiplier.
+ * 
+ * @param {Object} origin - { latitude, longitude }
+ * @param {Object} destination - { latitude, longitude }
+ * @returns {Promise<number>} - Round distance in KM
+ */
+// Duration from the most recent OSRM route, in minutes, or null when the
+// Haversine fallback was used (a straight-line estimate has no honest
+// duration — better to show nothing than a made-up ETA).
+let lastRouteDurationMin = null;
+
+export const getLastRouteDurationMin = () => lastRouteDurationMin;
+
+export const calculateDrivingDistance = async (origin, destination) => {
+  const lat1 = origin?.latitude;
+  const lon1 = origin?.longitude;
+  const lat2 = destination?.latitude;
+  const lon2 = destination?.longitude;
+
+  if (lat1 == null || lon1 == null || lat2 == null || lon2 == null) {
+    throw new Error("Invalid coordinates");
+  }
+
+  // 1. Try OSRM API (either self-hosted or public demo server for fallback)
+  const osrmBaseUrl = import.meta.env.VITE_OSRM_URL || "https://router.project-osrm.org";
+  try {
+    const url = `${osrmBaseUrl}/route/v1/driving/${lon1},${lat1};${lon2},${lat2}?overview=false`;
+    const response = await fetch(url);
+    if (response.ok) {
+      const data = await response.json();
+      if (data.routes && data.routes.length > 0) {
+        const distanceInMeters = data.routes[0].distance;
+        const distanceInKm = distanceInMeters / 1000;
+        // OSRM already returns the driving duration alongside the distance;
+        // it was being discarded. Cached here so callers that want an ETA get
+        // a REAL routed figure instead of dividing km by a guessed speed.
+        lastRouteDurationMin = Number.isFinite(data.routes[0].duration) ? Math.round(data.routes[0].duration / 60) : null;
+        return Math.round(distanceInKm);
+      }
+    }
+  } catch (error) {
+    console.warn("OSRM API failed, falling back to Haversine math:", error);
+  }
+
+  // 2. Fallback: Haversine Formula with 1.3x multiplier
+  const toRad = (val) => (val * Math.PI) / 180;
+  const R = 6371; // Earth radius in km
+  const dLat = toRad(lat2 - lat1);
+  const dLon = toRad(lon2 - lon1);
+  const a =
+    Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+    Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) *
+    Math.sin(dLon / 2) * Math.sin(dLon / 2);
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  const aerialDistance = R * c;
+
+  // No route was fetched, so there is no honest duration to report.
+  lastRouteDurationMin = null;
+  return Math.round(aerialDistance * 1.3);
+};
+
+/**
+ * Calculates total charge based on distance and pricing tier
+ * 
+ * @param {number} distanceKm 
+ * @param {number} basePrice 
+ * @param {number} pricePerKm 
+ * @param {number} minKm 
+ * @returns {number}
+ */
+export const calculateTotalCharge = (distanceKm, basePrice, pricePerKm, minKm) => {
+  if (distanceKm < minKm) {
+    return basePrice;
+  }
+  return (distanceKm - minKm) * pricePerKm + basePrice;
+};