@sanvika/geolocation 0.2.1 → 0.3.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanvika/geolocation",
-  "version": "0.2.1",
-  "description": "Sanvika ecosystem geolocation SDK — IP lookup, browser geolocation, reverse geocoding (lat/lng → Indian state/city), Indian states constants",
+  "version": "0.3.1",
+  "description": "Sanvika ecosystem geolocation SDK — fully centralized via geolocation.sanvikaproduction.com. IP lookup, reverse/forward geocoding, Places autocomplete + details, Maps JS loader. Zero Google API keys in consumer projects.",
   "type": "module",
   "main": "./src/index.js",
   "module": "./src/index.js",
@@ -17,13 +17,7 @@
   "dependencies": {
     "@sanvika/logger": ">=0.2"
   },
-  "keywords": [
-    "sanvika",
-    "geolocation",
-    "ip",
-    "location",
-    "india"
-  ],
+  "keywords": ["sanvika", "geolocation", "ip", "location", "india"],
   "author": "Sanvika Production",
   "license": "UNLICENSED",
   "repository": {
@@ -33,4 +27,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/client/index.js

@@ -1,15 +1,127 @@
 // packages/sanvika-geolocation-sdk/src/client/index.js
-// Client-side (browser) geolocation with HTML5 GPS + cache/IP fallback
-// Usage: import { getLocationPromise, getFullLocationDetails } from "@sanvika/geolocation/client"
+// Client-side (browser) geolocation helpers.
+// Usage: import { ... } from "@sanvika/geolocation/client"
+//
+// Env vars (read from process.env in Next.js / similar):
+//   NEXT_PUBLIC_GEOLOCATION_URL=https://geolocation.sanvikaproduction.com
+//   NEXT_PUBLIC_GEOLOCATION_CLIENT_ID=fapk
+//
+// Consumer projects NO LONGER need proxy routes for geolocation.
+// All calls go directly to geolocation.sanvikaproduction.com via public clientId auth.
+// Only getUserLocation / updateUserLocation still need FAPK routes (they use SA SSO auth).
 
 import { createLogger } from "@sanvika/logger";
 import { setWithTTL, getWithTTL, TTL } from "./localStorageTTL.js";
 
+// ─── Direct service helpers (no consumer proxy routes needed) ────────────────
+
+function _geoUrl() {
+  return (typeof process !== "undefined" && process.env?.NEXT_PUBLIC_GEOLOCATION_URL)
+    || "https://geolocation.sanvikaproduction.com";
+}
+
+function _clientId() {
+  return (typeof process !== "undefined" && process.env?.NEXT_PUBLIC_GEOLOCATION_CLIENT_ID) || "";
+}
+
+async function _servicePost(path, body) {
+  const clientId = _clientId();
+  const qs = clientId ? `?clientId=${encodeURIComponent(clientId)}` : "";
+  try {
+    const res = await fetch(`${_geoUrl()}${path}${qs}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    return res.ok ? res.json() : { success: false };
+  } catch {
+    return { success: false };
+  }
+}
+
+/**
+ * Reverse geocode lat/lng → address parts via geolocation service directly.
+ * Replaces fetch("/api/location/getLocationDetails") in consumer projects.
+ */
+export async function reverseGeocode(latitude, longitude, opts = {}) {
+  const r = await _servicePost("/api/v1/geocode/reverse", { lat: latitude, lng: longitude });
+  if (!r.success || !r.found) return null;
+  return {
+    country: r.country || "",
+    state: r.normalizedState || r.state || "",
+    city: r.city || "",
+    nearbyLandmark: r.sublocality || "",
+    postalCode: r.postalCode || "",
+    fullAddress: r.fullAddress || "",
+    latitude: Number(latitude),
+    longitude: Number(longitude),
+    geoLocation: { type: "Point", coordinates: [Number(longitude), Number(latitude)] },
+    placeId: r.placeId || "",
+    source: opts.source || "reverse_geocode",
+  };
+}
+
+/**
+ * Forward geocode address → lat/lng via geolocation service directly.
+ * Replaces fetch("/api/location/getCoordinates") in consumer projects.
+ */
+export async function forwardGeocode(address, { country = "IN" } = {}) {
+  return _servicePost("/api/v1/geocode/forward", { address, country });
+}
+
+/**
+ * IP-based location lookup via geolocation service directly from browser.
+ * Replaces fetch("/api/location/getIpLocation") in consumer projects.
+ * Browser's real IP is detected server-side by the geolocation service.
+ */
+export async function getIpLocation() {
+  try {
+    const clientId = _clientId();
+    const qs = clientId ? `?clientId=${encodeURIComponent(clientId)}` : "";
+    const res = await fetch(`${_geoUrl()}/api/v1/locate${qs}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({}),
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (!data.success || !data.location) return null;
+    const l = data.location;
+    return { latitude: l.lat ?? null, longitude: l.lng ?? null, city: l.city || "Unknown", state: l.region || "", country: l.country || "India", source: "ip" };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Places autocomplete via geolocation service directly.
+ * Replaces fetch("/api/location/places/autocomplete") in consumer projects.
+ */
+export async function placesAutocomplete(input, { country = "IN", types = "geocode", language = "en", sessionToken } = {}) {
+  if (!input || input.trim().length < 2) return { success: true, predictions: [] };
+  return _servicePost("/api/v1/places/autocomplete", { input: input.trim(), country, types, language, sessionToken });
+}
+
+/**
+ * Place details by placeId via geolocation service directly.
+ * Replaces fetch("/api/location/places/details") in consumer projects.
+ */
+export async function placesDetails(placeId, { language = "en", sessionToken } = {}) {
+  if (!placeId) return { success: false };
+  return _servicePost("/api/v1/places/details", { placeId, language, sessionToken });
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+export {
+  loadGoogleMapsScript,
+  getMapsConfig,
+  resetMapsLoader,
+} from "./loadGoogleMapsScript.js";
+
 const logger = createLogger({ namespace: "SanvikaGeolocation" });
 const LOCATION_CACHE_KEY = "sanvika_location_cache";
 
-// ─── Internal helpers ────────────────────────────────────────────────────────
-
 async function tryFallbacks(options) {
   if (options.useCachedFallback) {
     const cached = getWithTTL(LOCATION_CACHE_KEY);
@@ -27,26 +139,18 @@ async function tryFallbacks(options) {
 
   if (options.useIpFallback) {
     try {
-      const res = await fetch("/api/location/getIpLocation");
-      const data = await res.json();
-      if (data.success && data.location) {
+      // Call geolocation service directly — no FAPK proxy needed
+      const ipLoc = await getIpLocation();
+      if (ipLoc?.latitude && ipLoc?.longitude) {
         logger.info("Using IP fallback for location");
-        return {
-          latitude: data.location.latitude,
-          longitude: data.location.longitude,
-          accuracy: 20000,
-          source: "ip",
-          timestamp: Date.now(),
-        };
+        return { latitude: ipLoc.latitude, longitude: ipLoc.longitude, accuracy: 20000, source: "ip", timestamp: Date.now() };
       }
-    } catch { /* silent — will throw below */ }
+    } catch { /* silent */ }
   }
 
   throw new Error("All location methods failed");
 }
 
-// ─── Main exports ────────────────────────────────────────────────────────────
-
 export function getLocationPromise(options = {}) {
   const finalOptions = {
     enableHighAccuracy: true,
@@ -111,17 +215,9 @@ export async function getFullLocationDetails(options = {}) {
   if (!locationData.latitude || !locationData.longitude) return locationData;
 
   try {
-    const res = await fetch("/api/location/getLocationDetails", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        latitude: locationData.latitude,
-        longitude: locationData.longitude,
-        source: locationData.source,
-      }),
-    });
-    const data = await res.json();
-    if (data.success) return { ...data.location, source: locationData.source, timestamp: locationData.timestamp };
+    // Call geolocation service directly — no FAPK proxy needed
+    const details = await reverseGeocode(locationData.latitude, locationData.longitude, { source: locationData.source });
+    if (details) return { ...details, source: locationData.source, timestamp: locationData.timestamp };
   } catch (error) {
     logger.error("Error fetching location details", error);
   }
@@ -162,16 +258,11 @@ export function getCachedLocation() {
 
 export async function getCityFromCoordinates(latitude, longitude) {
   const cached = getCachedLocation();
-  if (cached?.city) return cached.city;
-
+  if (cached?.address?.city) return cached.address.city;
   try {
-    const res = await fetch("/api/location/getLocationDetails", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ latitude, longitude, source: "city_fetch" }),
-    });
-    const data = await res.json();
-    if (data.success && data.location?.city) return data.location.city;
+    // Call geolocation service directly — no FAPK proxy needed
+    const details = await reverseGeocode(latitude, longitude);
+    if (details?.city) return details.city;
   } catch (error) {
     logger.error("Error getting city from coordinates:", error);
   }

package/src/client/loadGoogleMapsScript.js

@@ -0,0 +1,121 @@
+// packages/sanvika-geolocation-sdk/src/client/loadGoogleMapsScript.js
+// Browser-side loader for Google Maps JS API.
+// Fetches API key + Map ID from geolocation.sanvikaproduction.com (centralized),
+// then injects the standard Google Maps script tag with the centrally-issued key.
+//
+// Usage:
+//   import { loadGoogleMapsScript } from "@sanvika/geolocation/client";
+//   await loadGoogleMapsScript({ libraries: ["places", "marker"] });
+//
+// Env vars (auto-read from process.env):
+//   NEXT_PUBLIC_GEOLOCATION_URL=https://geolocation.sanvikaproduction.com
+//   NEXT_PUBLIC_GEOLOCATION_CLIENT_ID=fapk
+
+import { createLogger } from "@sanvika/logger";
+
+const logger = createLogger({ namespace: "SanvikaGeolocation.MapsLoader" });
+
+let inflight = null;
+let cachedConfig = null;
+
+function readEnv(key) {
+  try {
+    return (typeof process !== "undefined" && process.env?.[key]) || null;
+  } catch {
+    return null;
+  }
+}
+
+async function fetchMapsConfig({ apiBase, clientId }) {
+  if (cachedConfig) return cachedConfig;
+  const url = `${apiBase}/api/v1/mapsjs/config?clientId=${encodeURIComponent(clientId)}`;
+  const res = await fetch(url, { credentials: "omit" });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok || !data?.success) {
+    throw new Error(`mapsjs/config failed: ${data?.error || `HTTP_${res.status}`}`);
+  }
+  cachedConfig = data.config;
+  return cachedConfig;
+}
+
+export async function loadGoogleMapsScript({
+  libraries = ["places", "marker"],
+  version = "weekly",
+  apiBase: apiBaseInput,
+  clientId: clientIdInput,
+} = {}) {
+  if (typeof window === "undefined") {
+    throw new Error("loadGoogleMapsScript must run in the browser");
+  }
+  if (window.google?.maps?.Map) return window.google;
+  if (inflight) return inflight;
+
+  const apiBase = (apiBaseInput || readEnv("NEXT_PUBLIC_GEOLOCATION_URL") || "").replace(/\/$/, "");
+  const clientId = clientIdInput || readEnv("NEXT_PUBLIC_GEOLOCATION_CLIENT_ID");
+  if (!apiBase || !clientId) {
+    throw new Error("loadGoogleMapsScript: NEXT_PUBLIC_GEOLOCATION_URL and NEXT_PUBLIC_GEOLOCATION_CLIENT_ID are required");
+  }
+
+  inflight = (async () => {
+    const config = await fetchMapsConfig({ apiBase, clientId });
+
+    return new Promise((resolve, reject) => {
+      const callbackName = `__sanvika_maps_cb_${Date.now()}`;
+      window[callbackName] = () => {
+        delete window[callbackName];
+        if (window.google?.maps?.Map) {
+          logger.info("Google Maps loaded", { libraries, mapId: !!config.mapId });
+          resolve(window.google);
+        } else {
+          reject(new Error("Maps loaded but window.google.maps.Map missing"));
+        }
+      };
+
+      const params = new URLSearchParams({
+        key: config.apiKey,
+        v: version,
+        libraries: libraries.join(","),
+        loading: "async",
+        callback: callbackName,
+      });
+      if (config.mapId) params.set("map_ids", config.mapId);
+
+      const existing = document.querySelector("script[data-sanvika-maps]");
+      if (existing) {
+        if (window.google?.maps?.Map) {
+          delete window[callbackName];
+          resolve(window.google);
+        }
+        return;
+      }
+
+      const script = document.createElement("script");
+      script.src = `https://maps.googleapis.com/maps/api/js?${params.toString()}`;
+      script.async = true;
+      script.defer = true;
+      script.dataset.sanvikaMaps = "1";
+      script.onerror = (e) => {
+        delete window[callbackName];
+        inflight = null;
+        reject(e);
+      };
+      document.head.appendChild(script);
+    });
+  })();
+
+  try {
+    return await inflight;
+  } catch (e) {
+    inflight = null;
+    throw e;
+  }
+}
+
+export function getMapsConfig() {
+  return cachedConfig;
+}
+
+export function resetMapsLoader() {
+  cachedConfig = null;
+  inflight = null;
+}

package/src/server/index.js

@@ -1,13 +1,11 @@
 // packages/sanvika-geolocation-sdk/src/server/index.js
-// Server-side IP geolocation via ip-api.com (free, no API key, 45 req/min)
-// + Reverse geocoding: lat/lng → Indian state/city via Google Geocoding API
-
-export {
-  detectStateFromCoordinates,
-  isUserInTargetStates,
-  clearStateCache,
-  getStateCacheStats,
-} from "./stateDetection.js";
+// Server-side helpers — all Google Maps + IP lookup calls route through
+// geolocation.sanvikaproduction.com. Consumer projects don't need any
+// Google API keys in their own env.
+//
+// Required env vars in consumer projects:
+//   GEOLOCATION_URL=https://geolocation.sanvikaproduction.com
+//   GEOLOCATION_CLIENT_SECRET=<plain text, registered in admin panel>
 
 export {
   INDIAN_STATES,
@@ -18,91 +16,116 @@ export {
   isValidIndianState,
 } from "./india.js";
 
+export {
+  GeolocationServiceClient,
+  getServiceClient,
+  resetServiceClient,
+} from "./serviceClient.js";
+
 import { createLogger } from "@sanvika/logger";
+import { getServiceClient } from "./serviceClient.js";
+import { normalizeStateName } from "./india.js";
 
 const logger = createLogger({ namespace: "SanvikaGeolocation" });
 
-const locationCache = new Map();
-const CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours
-
 export function isPrivateIp(ip) {
+  if (!ip) return true;
   const privateRanges = [
-    /^127\./,
-    /^10\./,
-    /^172\.(1[6-9]|2[0-9]|3[0-1])\./,
-    /^192\.168\./,
-    /^::1$/,
-    /^fe80:/i,
-    /^fc00:/i,
-    /^fd00:/i,
+    /^127\./, /^10\./, /^172\.(1[6-9]|2[0-9]|3[0-1])\./, /^192\.168\./,
+    /^::1$/, /^fe80:/i, /^fc00:/i, /^fd00:/i,
   ];
   return privateRanges.some((r) => r.test(ip));
 }
 
-function getDefaultLocation() {
+function defaultLocation() {
   return {
-    city: "Unknown",
-    state: "Unknown",
-    country: "India",
-    countryCode: "IN",
-    zipCode: null,
-    latitude: null,
-    longitude: null,
-    timezone: "Asia/Kolkata",
-    source: "default",
+    city: "Unknown", state: "Unknown", country: "India", countryCode: "IN",
+    zipCode: null, latitude: null, longitude: null,
+    timezone: "Asia/Kolkata", source: "default",
   };
 }
 
+/** Resolve approximate location from an IP via geolocation service (cached server-side). */
 export async function getLocationFromIp(ip) {
-  if (!ip || ip === "unknown" || isPrivateIp(ip)) {
-    return getDefaultLocation();
-  }
+  if (!ip || ip === "unknown" || isPrivateIp(ip)) return defaultLocation();
+  const r = await getServiceClient().request("/api/v1/locate", { body: { ip } });
+  if (!r.success || !r.location) return defaultLocation();
+  const l = r.location;
+  return {
+    city: l.city || "Unknown",
+    state: l.region || "Unknown",
+    country: l.country || "India",
+    countryCode: l.countryCode || "IN",
+    zipCode: null,
+    latitude: l.lat ?? null,
+    longitude: l.lng ?? null,
+    timezone: l.timezone || "Asia/Kolkata",
+    source: r.source || "lookup",
+  };
+}
 
-  const cached = locationCache.get(ip);
-  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
-    return cached.data;
+/** Reverse geocode lat/lng → address parts (proxied via geolocation service, cached). */
+export async function reverseGeocode(latitude, longitude) {
+  const lat = typeof latitude === "string" ? parseFloat(latitude) : latitude;
+  const lng = typeof longitude === "string" ? parseFloat(longitude) : longitude;
+  if (!Number.isFinite(lat) || !Number.isFinite(lng)) {
+    return { success: false, error: "INVALID_COORDINATES" };
   }
+  return getServiceClient().request("/api/v1/geocode/reverse", { body: { lat, lng } });
+}
 
-  try {
-    const response = await fetch(
-      `http://ip-api.com/json/${ip}?fields=status,message,country,countryCode,region,regionName,city,zip,lat,lon,timezone`,
-      {
-        method: "GET",
-        headers: { Accept: "application/json" },
-        signal: AbortSignal.timeout(3000),
-      }
-    );
-
-    if (!response.ok) throw new Error(`ip-api returned ${response.status}`);
-
-    const data = await response.json();
+/** Forward geocode address → lat/lng (proxied, cached). */
+export async function forwardGeocode(address, { country = "IN" } = {}) {
+  if (!address) return { success: false, error: "ADDRESS_REQUIRED" };
+  return getServiceClient().request("/api/v1/geocode/forward", { body: { address, country } });
+}
 
-    if (data.status === "fail") {
-      logger.warn("IP lookup failed", { ip, message: data.message });
-      return getDefaultLocation();
-    }
+/** Server-side Places autocomplete — input → predictions[]. */
+export async function placesAutocomplete(input, { country = "IN", types = "geocode", language = "en", sessionToken } = {}) {
+  if (!input) return { success: false, error: "INPUT_REQUIRED" };
+  return getServiceClient().request("/api/v1/places/autocomplete", {
+    body: { input, country, types, language, sessionToken },
+  });
+}
 
-    const location = {
-      city: data.city || "Unknown",
-      state: data.regionName || data.region || "Unknown",
-      country: data.country || "India",
-      countryCode: data.countryCode || "IN",
-      zipCode: data.zip || null,
-      latitude: data.lat || null,
-      longitude: data.lon || null,
-      timezone: data.timezone || "Asia/Kolkata",
-      source: "ip_api",
-    };
+/** Server-side Place details by placeId. */
+export async function placesDetails(placeId, { language = "en", fields, sessionToken } = {}) {
+  if (!placeId) return { success: false, error: "PLACE_ID_REQUIRED" };
+  return getServiceClient().request("/api/v1/places/details", {
+    body: { placeId, language, fields, sessionToken },
+  });
+}
 
-    locationCache.set(ip, { data: location, timestamp: Date.now() });
-    logger.info("IP location resolved", { city: location.city });
-    return location;
-  } catch (error) {
-    logger.warn("IP geolocation failed", { error: error.message });
-    return getDefaultLocation();
+/**
+ * Detect Indian state + city from coordinates.
+ * Now proxied through reverseGeocode (which calls geolocation service) — no Google key in consumer env.
+ */
+export async function detectStateFromCoordinates(latitude, longitude) {
+  const lat = typeof latitude === "string" ? parseFloat(latitude) : latitude;
+  const lng = typeof longitude === "string" ? parseFloat(longitude) : longitude;
+  if (!Number.isFinite(lat) || !Number.isFinite(lng)) {
+    return { state: null, city: null, fromCache: false };
   }
+  const r = await reverseGeocode(lat, lng);
+  if (!r.success || !r.found) return { state: null, city: null, fromCache: false };
+  const state = r.normalizedState || normalizeStateName(r.state);
+  if (state) {
+    logger.info("State detected", { state, city: r.city });
+  } else if (r.state) {
+    logger.warn("State not recognized as Indian", { rawState: r.state });
+  }
+  return { state, city: r.city || null, fromCache: false };
 }
 
-export function clearLocationCache() {
-  locationCache.clear();
+export async function isUserInTargetStates(latitude, longitude, targetStates) {
+  if (!Array.isArray(targetStates) || targetStates.length === 0) return false;
+  const { state } = await detectStateFromCoordinates(latitude, longitude);
+  if (!state) return false;
+  const normalized = targetStates.map(normalizeStateName).filter(Boolean);
+  return normalized.includes(state);
 }
+
+// Legacy no-ops kept for backwards compatibility.
+export function clearLocationCache() {}
+export function clearStateCache() {}
+export function getStateCacheStats() { return { keys: 0 }; }

package/src/server/serviceClient.js

@@ -0,0 +1,69 @@
+// packages/sanvika-geolocation-sdk/src/server/serviceClient.js
+// HTTP client for geolocation.sanvikaproduction.com — used by all server-side helpers.
+// Env vars: GEOLOCATION_URL, GEOLOCATION_CLIENT_SECRET (or pass to constructor).
+
+const DEFAULT_TIMEOUT_MS = 6000;
+
+function readEnv(key) {
+  try {
+    return (typeof process !== "undefined" && process.env?.[key]) || null;
+  } catch {
+    return null;
+  }
+}
+
+export class GeolocationServiceClient {
+  #url;
+  #secret;
+
+  constructor({ url, secret } = {}) {
+    const finalUrl = url || readEnv("GEOLOCATION_URL");
+    const finalSecret = secret || readEnv("GEOLOCATION_CLIENT_SECRET");
+    if (!finalUrl || !finalSecret) {
+      throw new Error("@sanvika/geolocation/server: GEOLOCATION_URL and GEOLOCATION_CLIENT_SECRET are required");
+    }
+    this.#url = finalUrl.replace(/\/$/, "");
+    this.#secret = finalSecret;
+  }
+
+  get baseUrl() { return this.#url; }
+
+  async request(path, { method = "POST", body, query } = {}) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
+
+    const qs = query ? "?" + new URLSearchParams(query).toString() : "";
+    const init = {
+      method,
+      headers: { "x-client-secret": this.#secret },
+      signal: controller.signal,
+    };
+    if (body !== undefined) {
+      init.headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(body);
+    }
+
+    try {
+      const res = await fetch(`${this.#url}${path}${qs}`, init);
+      const json = await res.json().catch(() => ({}));
+      if (!res.ok || !json.success) {
+        return { success: false, status: res.status, error: json?.error || `HTTP_${res.status}` };
+      }
+      return { success: true, ...json };
+    } catch (err) {
+      return { success: false, error: err.name === "AbortError" ? "TIMEOUT" : err.message };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+}
+
+let _instance = null;
+export function getServiceClient() {
+  if (!_instance) _instance = new GeolocationServiceClient();
+  return _instance;
+}
+
+export function resetServiceClient() {
+  _instance = null;
+}

package/src/server/stateDetection.js

@@ -1,112 +0,0 @@
-// Reverse geocoding: lat/lng → Indian state + city via Google Geocoding API
-// Supports GOOGLE_MAPS_API_KEY (server-safe) or NEXT_PUBLIC_GOOGLE_MAPS_API_KEY (Next.js)
-
-import { createLogger } from "@sanvika/logger";
-import { normalizeStateName } from "./india.js";
-
-const logger = createLogger({ namespace: "SanvikaGeolocation.StateDetection" });
-
-// In-memory cache — key: "lat_lng" rounded to 2dp (~1.1km accuracy)
-const stateCache = new Map();
-const CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours
-
-function getCacheKey(lat, lng) {
-  return `${Math.round(lat * 100) / 100}_${Math.round(lng * 100) / 100}`;
-}
-
-function getApiKey() {
-  return (
-    (typeof process !== "undefined" && process.env?.GOOGLE_MAPS_API_KEY) ||
-    (typeof process !== "undefined" && process.env?.NEXT_PUBLIC_GOOGLE_MAPS_API_KEY) ||
-    null
-  );
-}
-
-export async function detectStateFromCoordinates(latitude, longitude) {
-  const lat = typeof latitude === "string" ? parseFloat(latitude) : latitude;
-  const lng = typeof longitude === "string" ? parseFloat(longitude) : longitude;
-
-  if (!lat || !lng || !Number.isFinite(lat) || !Number.isFinite(lng)) {
-    logger.warn("Invalid coordinates", { latitude, longitude });
-    return { state: null, city: null, fromCache: false };
-  }
-
-  const key = getCacheKey(lat, lng);
-  const cached = stateCache.get(key);
-  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
-    return { state: cached.state, city: cached.city, fromCache: true };
-  }
-
-  const apiKey = getApiKey();
-  if (!apiKey) {
-    logger.error("Google Maps API key not configured (set GOOGLE_MAPS_API_KEY or NEXT_PUBLIC_GOOGLE_MAPS_API_KEY)");
-    return { state: null, city: null, fromCache: false };
-  }
-
-  try {
-    const url = new URL("https://maps.googleapis.com/maps/api/geocode/json");
-    url.searchParams.set("latlng", `${lat},${lng}`);
-    url.searchParams.set("key", apiKey);
-    url.searchParams.set("result_type", "administrative_area_level_1|locality");
-
-    const res = await fetch(url.toString(), {
-      signal: AbortSignal.timeout(5000),
-    });
-
-    if (!res.ok) throw new Error(`Geocoding API returned ${res.status}`);
-
-    const data = await res.json();
-
-    if (data.status !== "OK") {
-      logger.warn("Geocoding API non-OK status", { status: data.status, lat, lng });
-      return { state: null, city: null, fromCache: false };
-    }
-
-    let rawState = null;
-    let city = null;
-
-    for (const result of (data.results || [])) {
-      for (const component of (result.address_components || [])) {
-        if (component.types.includes("administrative_area_level_1") && !rawState) {
-          rawState = component.long_name;
-        }
-        if (component.types.includes("locality") && !city) {
-          city = component.long_name;
-        }
-      }
-      if (rawState && city) break;
-    }
-
-    const state = normalizeStateName(rawState);
-
-    if (state) {
-      logger.info("State detected", { state, city, rawState });
-    } else if (rawState) {
-      logger.warn("State not recognized as Indian state", { rawState });
-    }
-
-    stateCache.set(key, { state, city, rawState, timestamp: Date.now() });
-    return { state, city, fromCache: false };
-  } catch (error) {
-    logger.error("State detection failed", { error: error.message, lat, lng });
-    return { state: null, city: null, fromCache: false };
-  }
-}
-
-export async function isUserInTargetStates(latitude, longitude, targetStates) {
-  if (!Array.isArray(targetStates) || targetStates.length === 0) return false;
-  const { state } = await detectStateFromCoordinates(latitude, longitude);
-  if (!state) return false;
-  const normalized = targetStates.map(normalizeStateName).filter(Boolean);
-  const match = normalized.includes(state);
-  logger.debug("State targeting", { state, targetStates: normalized, match });
-  return match;
-}
-
-export function clearStateCache() {
-  stateCache.clear();
-}
-
-export function getStateCacheStats() {
-  return { keys: stateCache.size };
-}