@reservamos/browser-analytics 1.1.7 → 1.1.8-alpha.0

package/dist/browser-analytics.esm.js

@@ -13427,7 +13427,7 @@ function observeIdentifyResult(stage, report, onTimeout) {
   }, 5e3);
   return { complete };
 }
-const version = "1.1.7";
+const version = "1.1.8-alpha.0";
 const MIXPANEL_DISTINCT_ID_CACHE_KEY = "mp_distinct_id";
 const SDK_SUPER_PROPERTIES = {
   "Event Source": "sdk",
@@ -13448,11 +13448,7 @@ function init$2(mixpanelToken, debug = false, proxyUrl) {
 }
 function identify$1(userId, properties, report) {
   mixpanel.identify(userId);
-  try {
-    updateCachedDistinctId(userId);
-  } catch {
-    report == null ? void 0 : report("cache", "unavailable");
-  }
+  if (!updateCachedDistinctId(userId)) report == null ? void 0 : report("cache", "unavailable");
   if (!report) {
     mixpanel.people.set(properties);
     return;
@@ -13491,18 +13487,25 @@ function track(eventName, properties) {
   mixpanel.track(eventName, { ...properties, "Reservamos Version": version });
 }
 const getMixpanelDistinctId = () => {
-  const cachedId = localStorage.getItem(MIXPANEL_DISTINCT_ID_CACHE_KEY);
-  if (mixpanel && mixpanel.get_distinct_id) {
-    const distinctId = mixpanel.get_distinct_id();
+  var _a;
+  const distinctId = (_a = mixpanel == null ? void 0 : mixpanel.get_distinct_id) == null ? void 0 : _a.call(mixpanel);
+  if (distinctId) {
     updateCachedDistinctId(distinctId);
     return distinctId;
-  } else if (cachedId) {
-    return cachedId;
   }
-  return null;
+  try {
+    return localStorage.getItem(MIXPANEL_DISTINCT_ID_CACHE_KEY);
+  } catch {
+    return null;
+  }
 };
 function updateCachedDistinctId(distinctId) {
-  localStorage.setItem(MIXPANEL_DISTINCT_ID_CACHE_KEY, distinctId);
+  try {
+    localStorage.setItem(MIXPANEL_DISTINCT_ID_CACHE_KEY, distinctId);
+    return true;
+  } catch {
+    return false;
+  }
 }
 const mixpanelService = {
   init: init$2,
@@ -13528,8 +13531,8 @@ const getCachedFingerprint = () => {
   return readCachedFingerprint();
 };
 function readCachedFingerprint(context) {
-  const { cacheName = DEFAULT_CACHE_NAME } = window.fingerprintConfig;
   try {
+    const { cacheName = DEFAULT_CACHE_NAME } = window.fingerprintConfig ?? {};
     const cachedData = JSON.parse(localStorage.getItem(cacheName) || "null");
     if (cachedData && cachedData.expiresAt > Date.now()) {
       return cachedData.fingerprint;
@@ -13592,17 +13595,11 @@ function getFingerprintForIdentify(context) {
   return readFingerprint(false, context);
 }
 async function readFingerprint(cacheOnly, context) {
-  if (!window.fingerprintConfig) {
-    if (cacheOnly) {
-      return "";
-    }
-    throw new Error("Fingerprint configuration is not initialized.");
-  }
   const cachedFingerprint = readCachedFingerprint(context);
   if (cachedFingerprint) {
     return cachedFingerprint;
   }
-  if (cacheOnly || !isFingerprintReady()) {
+  if (cacheOnly || !window.fingerprintConfig || !isFingerprintReady()) {
     return "";
   }
   const { visitorId } = await requestIdentification(false, context);
@@ -14089,21 +14086,37 @@ async function init$1(config) {
     appName: appName2
   } = config;
   await mixpanelService.init(mixpanelToken, debug, mixpanelProxyUrl);
-  try {
-    await fingerprintService.initFingerprint(
-      identificationKey,
-      identifyProxyUrl
-    );
-  } catch (error) {
-    console.error("Error initializing identification service:", error);
-  }
-  await geolocationService.init();
   configService.setEnvironment(isSandbox ? "sandbox" : "prod");
   if (appName2) {
     configService.setAppName(appName2);
   }
   a$1.setConfig(configService.getCoreAPIConfig());
   onLoaded();
+  await Promise.all([
+    initializeOptionalStage(
+      "fingerprint",
+      () => fingerprintService.initFingerprint(identificationKey, identifyProxyUrl)
+    ),
+    initializeOptionalStage("geolocation", () => geolocationService.init())
+  ]);
+}
+function initializeOptionalStage(stage, initialize) {
+  return new Promise((resolve) => {
+    let active = true;
+    const finish = (reason) => {
+      if (!active) return;
+      active = false;
+      clearTimeout(timer);
+      if (reason)
+        console.error("SDK initialization diagnostic", { stage, reason });
+      resolve();
+    };
+    const timer = setTimeout(() => finish("timeout"), 3e3);
+    void Promise.resolve().then(initialize).then(
+      () => finish(),
+      () => finish("failed")
+    );
+  });
 }
 function isTrackerReady() {
   return mixpanelService.isReady();
@@ -14359,32 +14372,69 @@ function trackEventError(eventName, error, payload) {
     }
   });
 }
-async function tryTrackEvent(trackEventCallback) {
-  if (mixpanelService.isReady()) {
+async function tryTrackEvent(trackEventCallback, eventName = "Track Event Error") {
+  if (!mixpanelService.isReady()) {
+    const ready = await new Promise((resolve) => {
+      const finish = (isReady2) => {
+        clearTimeout(timer);
+        window.removeEventListener("Tracker Ready", onReady);
+        resolve(isReady2);
+      };
+      const onReady = () => {
+        if (mixpanelService.isReady()) finish(true);
+      };
+      const timer = setTimeout(() => finish(mixpanelService.isReady()), 5e3);
+      window.addEventListener("Tracker Ready", onReady);
+      onReady();
+    });
+    if (!ready) {
+      console.error("Tracking diagnostic", {
+        eventName,
+        stage: "readiness",
+        reason: "timeout"
+      });
+      return;
+    }
+  }
+  try {
     await trackEventCallback();
-  } else {
-    window.addEventListener("Tracker Ready", async () => {
-      await trackEventCallback();
+  } catch {
+    console.error("Tracking diagnostic", {
+      eventName,
+      stage: "submission",
+      reason: "failed"
     });
   }
 }
-async function trackEvent(eventName, eventProperties, meta = {}) {
-  if (!mixpanelService.isReady()) {
-    throw new Error("Mixpanel is not initialized.");
-  }
+function trackEvent(eventName, eventProperties, meta = {}) {
+  return tryTrackEvent(
+    () => submitEvent(eventName, eventProperties, meta),
+    eventName
+  );
+}
+async function submitEvent(eventName, eventProperties, meta) {
   try {
     validatorService.parseEventProps(eventName, eventProperties);
     const distinctId = mixpanelService.getMixpanelDistinctId();
     const botDetectionEnabled = botDetectionRelayService.isEnabledFor(eventName);
-    let fingerprint;
-    let fingerprintRequestId;
-    if (botDetectionEnabled && fingerprintService.isFingerprintReady()) {
-      const identification = await fingerprintService.identifyVisitor(true);
-      fingerprint = identification.visitorId;
-      fingerprintRequestId = identification.requestId;
+    let fingerprint = "";
+    if (botDetectionEnabled) {
+      try {
+        fingerprint = fingerprintService.getCachedFingerprint() ?? "";
+      } catch (error) {
+        console.error("Error reading cached fingerprint:", error);
+      }
     } else {
       const cacheOnly = !FP_TRIGGER_EVENTS.includes(eventName);
-      fingerprint = await fingerprintService.getFingerprint(cacheOnly);
+      try {
+        fingerprint = await fingerprintService.getFingerprint(cacheOnly);
+      } catch {
+        console.error("Tracking diagnostic", {
+          eventName,
+          stage: "fingerprint",
+          reason: "failed"
+        });
+      }
     }
     const defaultCoordinates = {};
     const coordinates = geolocationService.getCoordinates();
@@ -14409,19 +14459,29 @@ async function trackEvent(eventName, eventProperties, meta = {}) {
       ...meta
     };
     mixpanelService.track(eventName, properties);
-    if (fingerprintRequestId) {
-      void botDetectionRelayService.relay({
-        requestId: fingerprintRequestId,
-        visitorId: fingerprint,
-        ...distinctId && { distinctId },
-        eventName
-      });
+    if (botDetectionEnabled) {
+      void identifyAndRelayFingerprint(eventName, distinctId);
     }
   } catch (error) {
     console.error(`Error tracking event '${eventName}':`, error);
     trackEventError(eventName, error, eventProperties);
   }
 }
+async function identifyAndRelayFingerprint(eventName, distinctId) {
+  try {
+    if (!fingerprintService.isFingerprintReady()) return;
+    const identification = await fingerprintService.identifyVisitor(true);
+    if (!identification.requestId) return;
+    await botDetectionRelayService.relay({
+      requestId: identification.requestId,
+      visitorId: identification.visitorId,
+      ...distinctId && { distinctId },
+      eventName
+    });
+  } catch (error) {
+    console.error(`Error running Bot Detection for '${eventName}':`, error);
+  }
+}
 function extractTrackingParams() {
   try {
     const urlParams = new URLSearchParams(window.location.search);