@reservamos/browser-analytics 1.0.21 → 1.0.22-alpha.0

package/dist/browser-analytics.d.ts

@@ -22,6 +22,18 @@ export type AllowedPrimitive = string | boolean | number | undefined;
 export type EventData = Record<string, AllowedPrimitive | AllowedPrimitive[]>;
 export type EventMetadata = EventData;
 declare function trackCustomEvent(eventName: string, eventData?: EventData, meta?: EventMetadata): void;
+declare const geolocationSelectedSchema: z.ZodObject<{
+	"Selected City": z.ZodString;
+	"Selected Country Code": z.ZodString;
+}, "strip", z.ZodTypeAny, {
+	"Selected City": string;
+	"Selected Country Code": string;
+}, {
+	"Selected City": string;
+	"Selected Country Code": string;
+}>;
+export type GeolocationSelectedProps = z.infer<typeof geolocationSelectedSchema>;
+declare function trackGeolocationSelected(eventData: GeolocationSelectedProps, meta?: EventMetadata): void;
 declare const interestInHomeSchema: z.ZodObject<{
 	product: z.ZodEffects<z.ZodEnum<[
 		"web",
@@ -1286,6 +1298,7 @@ declare const analytics: {
 		pickedDeparture: typeof trackSearch;
 		customEvent: typeof trackCustomEvent;
 		purchaseCanceled: typeof trackPurchaseCanceled;
+		geolocationSelected: typeof trackGeolocationSelected;
 	};
 };
 

package/dist/browser-analytics.esm.js

@@ -4555,6 +4555,9 @@ async function initFingerprint(apiKey, proxyUrl) {
 }
 async function getFingerprint(cacheOnly = false) {
   if (!window.fingerprintConfig) {
+    if (cacheOnly) {
+      return "";
+    }
     throw new Error("Fingerprint configuration is not initialized.");
   }
   const cachedFingerprint = getCachedFingerprint();
@@ -13392,7 +13395,7 @@ function loadNoop(_src, onload) {
   onload();
 }
 var mixpanel = init_as_module(loadNoop);
-const version = "1.0.21";
+const version = "1.0.22-alpha.0";
 const MIXPANEL_DISTINCT_ID_CACHE_KEY = "mp_distinct_id";
 function init$2(mixpanelToken, debug = false, proxyUrl) {
   return new Promise((resolve) => {
@@ -13417,6 +13420,12 @@ function attachProperty(key, value) {
   }
   mixpanel.people.union(key, [value]);
 }
+function setPeopleProperties(properties) {
+  if (!isReady()) {
+    return;
+  }
+  mixpanel.people.set(properties);
+}
 function isReady() {
   return window.mixpanel !== void 0;
 }
@@ -13446,8 +13455,18 @@ const mixpanelService = {
   track,
   identify: identify$1,
   attachProperty,
+  setPeopleProperties,
   getMixpanelDistinctId
 };
+const geolocationSelectedSchema = z.object({
+  "Selected City": z.string().min(1, "Selected city is required"),
+  "Selected Country Code": z.string().min(1, "Selected Country Code is required")
+});
+const EVENT_NAME$a = "Geolocation Selected";
+function trackGeolocationSelected(eventData, meta = {}) {
+  trackEvent(EVENT_NAME$a, eventData, meta);
+  mixpanelService.setPeopleProperties(eventData);
+}
 const IdentifySchema = z.object({
   firstName: z.string().optional(),
   lastName: z.string().optional(),
@@ -13757,7 +13776,8 @@ const eventSchemas = {
   "Interest In Search": interestInSearchSchema,
   "View Results": viewResultsSchema,
   "Purchase Attempt": purchaseAttemptSchema,
-  "Picked Departure": pickedDepartureSchema
+  "Picked Departure": pickedDepartureSchema,
+  "Geolocation Selected": geolocationSelectedSchema
 };
 function parseEventProps(eventName, eventData) {
   const eventSchema = eventSchemas[eventName] || customEventSchema;
@@ -13807,7 +13827,6 @@ async function init$1(config) {
     mixpanelProxyUrl,
     identifyProxyUrl
   } = config;
-  geolocationService.init();
   await mixpanelService.init(mixpanelToken, debug, mixpanelProxyUrl);
   try {
     await fingerprintService.initFingerprint(
@@ -13817,6 +13836,7 @@ async function init$1(config) {
   } catch (error) {
     console.error("Error initializing identification service:", error);
   }
+  geolocationService.init();
   configService.setEnvironment(isSandbox ? "sandbox" : "prod");
   f.setConfig(configService.getCoreAPIConfig());
   onLoaded();
@@ -13826,47 +13846,164 @@ function isTrackerReady() {
 }
 let currentCoordinates = null;
 const GEOLOCATION_PERMISSION_KEY = "geolocationPermissionTimestamp";
+const GEOLOCATION_CACHE_KEY = "geolocationCache";
+const GEOLOCATION_TRACK_EVENT = "Geolocation Requested";
 const SEVEN_DAYS_IN_MS = 7 * 24 * 60 * 60 * 1e3;
+const GEOLOCATION_REQUEST_TIMEOUT_MS = 1e4;
+const GEOLOCATION_OPTIONS = {
+  enableHighAccuracy: true,
+  timeout: GEOLOCATION_REQUEST_TIMEOUT_MS,
+  maximumAge: 0
+};
+function safeGetItem(key) {
+  try {
+    return localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function safeSetItem(key, value) {
+  try {
+    localStorage.setItem(key, value);
+  } catch {
+  }
+}
+function toISO(timestamp) {
+  return new Date(timestamp).toISOString();
+}
+function isGeolocationCache(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const cache = value;
+  return typeof cache.lat === "number" && typeof cache.long === "number" && typeof cache.updatedAt === "string" && (cache.accuracy === void 0 || typeof cache.accuracy === "number");
+}
+function loadCoordinatesFromStorage() {
+  const raw = safeGetItem(GEOLOCATION_CACHE_KEY);
+  if (!raw) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return isGeolocationCache(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function saveCoordinatesToStorage(coords, updatedAt, accuracy) {
+  safeSetItem(
+    GEOLOCATION_CACHE_KEY,
+    JSON.stringify({
+      lat: coords.lat,
+      long: coords.long,
+      updatedAt,
+      ...accuracy !== void 0 && { accuracy }
+    })
+  );
+}
+function restoreCoordinatesFromStorage() {
+  const cache = loadCoordinatesFromStorage();
+  if (cache) {
+    currentCoordinates = { lat: cache.lat, long: cache.long };
+  }
+}
 function isPermissionTimestampValid(lastPermissionTimestamp) {
   if (!lastPermissionTimestamp) return false;
   const now = Date.now();
   return now - parseInt(lastPermissionTimestamp, 10) < SEVEN_DAYS_IN_MS;
 }
 function updatePermissionTimestamp(timestamp) {
-  localStorage.setItem(GEOLOCATION_PERMISSION_KEY, timestamp.toString());
+  safeSetItem(GEOLOCATION_PERMISSION_KEY, timestamp.toString());
+}
+function getGeolocationStatus(error) {
+  return error.code === error.PERMISSION_DENIED ? "denied" : "error";
+}
+function buildGeolocationEventProperties(data) {
+  const properties = {
+    "Geolocation Updated At": data.updatedAt,
+    "Geolocation Status": data.status
+  };
+  if (data.accuracy !== void 0) {
+    properties["Geolocation Accuracy"] = data.accuracy;
+  }
+  if (data.errorCode !== void 0) {
+    properties["Geolocation Error Code"] = data.errorCode;
+  }
+  const coordinates = getCoordinates();
+  if (coordinates) {
+    properties.$latitude = coordinates.lat;
+    properties.$longitude = coordinates.long;
+  }
+  return properties;
+}
+function buildGeolocationProfileProperties(data) {
+  const properties = {
+    "Geolocation Updated At": data.updatedAt,
+    "Geolocation Status": data.status
+  };
+  const coordinates = getCoordinates();
+  if (coordinates) {
+    properties.$latitude = coordinates.lat;
+    properties.$longitude = coordinates.long;
+  }
+  return properties;
+}
+function syncGeolocationToMixpanel(data) {
+  if (!isTrackerReady()) {
+    return;
+  }
+  const eventProperties = buildGeolocationEventProperties(data);
+  const profileProperties = buildGeolocationProfileProperties(data);
+  trackCustomEvent(GEOLOCATION_TRACK_EVENT, eventProperties);
+  mixpanelService.setPeopleProperties(profileProperties);
 }
 function init() {
+  restoreCoordinatesFromStorage();
   return new Promise((resolve) => {
-    const lastPermissionTimestamp = localStorage.getItem(
-      GEOLOCATION_PERMISSION_KEY
-    );
+    var _a;
+    const lastPermissionTimestamp = safeGetItem(GEOLOCATION_PERMISSION_KEY);
     if (isPermissionTimestampValid(lastPermissionTimestamp)) {
+      const cache = loadCoordinatesFromStorage();
+      const updatedAt2 = (cache == null ? void 0 : cache.updatedAt) ?? (lastPermissionTimestamp ? toISO(parseInt(lastPermissionTimestamp, 10)) : (/* @__PURE__ */ new Date()).toISOString());
+      syncGeolocationToMixpanel({
+        status: "skipped_cache",
+        updatedAt: updatedAt2,
+        accuracy: cache == null ? void 0 : cache.accuracy
+      });
       resolve(currentCoordinates);
       return;
     }
-    const GEOLOCATION_TRACK_EVENT = "Geolocation Requested";
     const now = Date.now();
+    const updatedAt = toISO(now);
+    if (!((_a = navigator.geolocation) == null ? void 0 : _a.getCurrentPosition)) {
+      syncGeolocationToMixpanel({ status: "error", updatedAt });
+      resolve(null);
+      return;
+    }
     navigator.geolocation.getCurrentPosition(
       (geolocation) => {
-        const { latitude: lat, longitude: long } = geolocation.coords;
+        const { latitude: lat, longitude: long, accuracy } = geolocation.coords;
         currentCoordinates = { lat, long };
+        saveCoordinatesToStorage(currentCoordinates, updatedAt, accuracy);
         updatePermissionTimestamp(now);
-        if (isTrackerReady()) {
-          trackCustomEvent(GEOLOCATION_TRACK_EVENT, {
-            geolocationAccepted: true
-          });
-        }
+        syncGeolocationToMixpanel({
+          status: "granted",
+          updatedAt,
+          accuracy
+        });
         resolve(currentCoordinates);
       },
-      () => {
+      (error) => {
+        const status = getGeolocationStatus(error);
         updatePermissionTimestamp(now);
-        if (isTrackerReady()) {
-          trackCustomEvent(GEOLOCATION_TRACK_EVENT, {
-            geolocationAccepted: false
-          });
-        }
+        syncGeolocationToMixpanel({
+          status,
+          updatedAt,
+          errorCode: error.code
+        });
         resolve(null);
-      }
+      },
+      GEOLOCATION_OPTIONS
     );
   });
 }
@@ -14369,7 +14506,8 @@ const analytics = {
     purchaseAttempt: trackPurchaseAttempt,
     pickedDeparture: trackSearch$1,
     customEvent: trackCustomEvent,
-    purchaseCanceled: trackPurchaseCanceled
+    purchaseCanceled: trackPurchaseCanceled,
+    geolocationSelected: trackGeolocationSelected
   }
 };
 export {