@magicfeedback/popup-sdk 1.8.1 → 1.8.3

package/dist/react-native.mjs

@@ -968,10 +968,13 @@ function createDefaultRenderer() {
 
 // src/analytics/analytics-manager.ts
 function createDryRunSink(log = console.log) {
-  return (payload) => log(
-    "[DeepdotsAnalytics] (dry-run \xB7 NOT sent \xB7 no init.analytics) POST /sdk/feedback \u2192",
-    JSON.stringify(payload, null, 2)
-  );
+  return (payload, meta) => {
+    if (meta?.resetSession) return;
+    log(
+      "[DeepdotsAnalytics] (dry-run \xB7 NOT sent \xB7 no init.analytics) POST /sdk/feedback \u2192",
+      JSON.stringify(payload, null, 2)
+    );
+  };
 }
 var dryRunSink = createDryRunSink();
 var AnalyticsManager = class {
@@ -1038,6 +1041,19 @@ var AnalyticsManager = class {
       this.exitMiniService(name);
     }
   }
+  /**
+   * Olvida la sesión en curso SIN emitir nada: vacía el buffer y los mini-services activos
+   * (sin `mini_service_exit`). Para una sesión que el backend ya cerró por inactividad: lo
+   * que quedara pendiente pertenecía a ella y no debe llegar con la sesión nueva.
+   */
+  discardSession(identity) {
+    this.events = [];
+    this.activeMiniServices.clear();
+    try {
+      void this.sink({ ...this.buildPayload(identity), events: [] }, { resetSession: true });
+    } catch {
+    }
+  }
   /**
    * Olvida lo que pertenecía al usuario anterior (user attributes + métricas) al cambiar de
    * usuario. NO toca el buffer de eventos: el cierre de sesión ya lo vació con la identidad
@@ -1208,14 +1224,7 @@ function createFeedbackSink(options) {
   const post = async (body, final, sessionEnd = false) => {
     const json = JSON.stringify(body);
     const small = json.length <= KEEPALIVE_MAX_BYTES;
-    if (final && options.sendBeaconImpl && small) {
-      const payload = typeof Blob !== "undefined" ? new Blob([json], { type: "application/json" }) : json;
-      if (options.sendBeaconImpl(url, payload)) {
-        options.log?.("[DeepdotsAnalytics] final flush via sendBeacon");
-        return;
-      }
-      options.log?.("[DeepdotsAnalytics] sendBeacon rejected the batch; falling back to fetch");
-    }
+    if (final) options.log?.("[DeepdotsAnalytics] final flush via fetch keepalive");
     const f = options.fetchImpl ?? (typeof fetch !== "undefined" ? fetch : void 0);
     if (!f) {
       options.log?.("[DeepdotsAnalytics] no fetch available; payload not sent", body);
@@ -1225,6 +1234,9 @@ function createFeedbackSink(options) {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: json,
+      // La API autentica por `publicKey` en el body y responde `Allow-Origin: *`: una
+      // petición con credenciales fallaría el CORS. Explícito para no depender del default.
+      credentials: "omit",
       // keepalive: el POST sobrevive a la navegación mientras el body sea pequeño.
       ...small ? { keepalive: true } : {}
     });
@@ -1251,6 +1263,12 @@ function createFeedbackSink(options) {
     }
   };
   return async (envelope, meta) => {
+    if (meta?.resetSession) {
+      feedbackSessionId = void 0;
+      firstPostInFlight = null;
+      options.onSessionReset?.();
+      return;
+    }
     const final = meta?.final === true;
     const sessionEnd = meta?.sessionEnd === true;
     if (!feedbackSessionId && firstPostInFlight && !final) {
@@ -1317,6 +1335,23 @@ var NavigationObserver = class {
     this.closeCurrent();
     this.currentScreen = null;
   }
+  /**
+   * Olvida la pantalla actual SIN emitir su visita. Para una sesión que el backend ya dio
+   * por cerrada: su visita no tiene dónde ir, y mandarla con la sesión nueva la contaría
+   * donde no ocurrió. Después, `restart()` vuelve a empezar en la pantalla actual.
+   */
+  discard() {
+    this.currentScreen = null;
+  }
+  /**
+   * Retoma el seguimiento en la pantalla actual tras un `stop()`, cuando se abre una sesión
+   * nueva sin navegar (cambio de usuario, vuelta de la bfcache). No-op si nunca se instaló
+   * (navegación manual por `setScreen`, RN) o si ya hay pantalla en curso.
+   */
+  restart() {
+    if (!this.installed || this.currentScreen != null || typeof window === "undefined") return;
+    this.begin(window.location.href);
+  }
   closeCurrent() {
     if (this.currentScreen == null) return;
     const exit = this.now();
@@ -1837,6 +1872,10 @@ var EXIT_QUEUE_STORAGE_KEY = "__deepdots_exit_popup_queue__";
 var DAY_IN_MS = 24 * 60 * 60 * 1e3;
 var ANALYTICS_MAX_BATCH_SIZE = 20;
 var ANALYTICS_FLUSH_INTERVAL_MS = 3e4;
+var ANALYTICS_HEARTBEAT_MS = 5 * 6e4;
+var ANALYTICS_SESSION_TIMEOUT_MS = 30 * 6e4;
+var ANALYTICS_SERVER_IDLE_MS = 60 * 6e4;
+var ANALYTICS_SESSION_DISCARD_MS = ANALYTICS_SERVER_IDLE_MS - 10 * 6e4;
 var RESERVED_EVENT_PREFIX = "deepdots_";
 var CUSTOM_EVENT_PREFIX = "deepdots_event_";
 var DeepdotsPopups = class {
@@ -1900,11 +1939,21 @@ var DeepdotsPopups = class {
      * nueva al volver a foreground o al conceder el consentimiento más tarde.
      */
     this.sessionOpen = false;
+    /** Último `user_engagement` emitido (ms epoch): marca el latido. */
+    this.lastEngagementAt = 0;
+    /** Cuándo se ocultó la pestaña por última vez (ms epoch); null si está visible. */
+    this.hiddenAt = null;
     /**
      * Idioma resuelto en init() (explícito > navigator.language > Intl). Única fuente de
      * verdad para el context de analytics Y para la segmentación por idioma de los popups.
      */
     this.language = void 0;
+    /** `geolocation` del init: si es false no se usa ni la caché ni el lookup. */
+    this.geoEnabled = true;
+    /** Solo se consulta a terceros si el país/ciudad se va a enviar (analytics configurado). */
+    this.geoWanted = false;
+    /** Evita más de un lookup por instancia (el consentimiento puede ir y venir). */
+    this.geoLookupStarted = false;
   }
   /** Initialize the SDK with configuration */
   init(config) {
@@ -1956,8 +2005,6 @@ var DeepdotsPopups = class {
       baseUrl: this.baseUrl,
       keys: config.analytics,
       log: (...a) => this.log(...a),
-      // sendBeacon: único transporte que sobrevive al cierre de la página.
-      sendBeaconImpl: typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function" ? (url, body) => navigator.sendBeacon(url, body) : void 0,
       onSessionId: (id) => {
         this.analyticsFeedbackSessionId = id;
       },
@@ -1992,20 +2039,13 @@ var DeepdotsPopups = class {
     if (this.tracking?.isTrackingEnabled()) {
       this.crashReporter.install();
     }
-    const cachedGeo = readCachedGeo(storage, Date.now());
-    if (cachedGeo) this.analytics.updateDevice(cachedGeo);
-    fetchGeo().then((geo) => {
-      if (geo) {
-        this.analytics?.updateDevice(geo);
-        writeCachedGeo(storage, geo, Date.now());
-      }
-    }).catch(() => {
-    });
+    this.geoEnabled = config.geolocation ?? true;
+    this.geoWanted = this.geoEnabled && !!config.analytics;
+    this.resolveGeo();
     this.navObserver = new NavigationObserver();
     this.navObserver.onVisit((v) => this.track("deepdots_page_view", { screen: v.screen, duration_seconds: v.durationSeconds }));
     this.navObserver.install();
     this.engagement = new EngagementTracker();
-    this.engagement.resume();
     this.setupAnalyticsFlush();
     this.openSession();
     const pendingCrashes = this.crashReporter.drainPendingCrashes();
@@ -2043,6 +2083,7 @@ var DeepdotsPopups = class {
     if (!enabled) this.closeSession("tracking_disabled");
     this.tracking?.setTrackingEnabled(enabled);
     if (enabled) this.openSession();
+    if (enabled) this.resolveGeo();
     this.log("tracking \xB7 setTrackingEnabled:", enabled, "\xB7 session_id:", this.tracking?.getSessionId() ?? null);
   }
   // ───────── Analytics (canal separado del feedback, vinculado por user_id) ─────────
@@ -2224,6 +2265,7 @@ var DeepdotsPopups = class {
     this.navStarted = false;
     this.analytics?.exitAllMiniServices();
     this.flushEngagement();
+    this.engagement?.pause();
     this.track("deepdots_session_end", { reason });
     this.flushAnalytics({ final: reason === "page_hide", sessionEnd: true });
     this.analyticsFeedbackSessionId = void 0;
@@ -2238,7 +2280,14 @@ var DeepdotsPopups = class {
     if (this.sessionOpen) return;
     if (!this.tracking?.isTrackingEnabled()) return;
     this.sessionOpen = true;
+    this.lastEngagementAt = Date.now();
     this.track("deepdots_session_start", {});
+    this.navObserver?.restart();
+    if (this.isDocumentVisible()) this.engagement?.resume();
+  }
+  /** Web: si la pestaña se ve. Sin `document` (RN) manda AppState vía onForeground/onBackground. */
+  isDocumentVisible() {
+    return typeof document === "undefined" || document.visibilityState !== "hidden";
   }
   /** Payload que se ENVIARÍA al endpoint de analytics (no envía ni vacía el buffer). */
   previewAnalytics() {
@@ -2251,8 +2300,8 @@ var DeepdotsPopups = class {
   }
   /**
    * Envía el lote acumulado de analytics y vacía el buffer.
-   * `final: true` (cierre de página/app) cambia el transporte a `sendBeacon`, que sobrevive
-   * al unload; un lote que falle por red o 5xx se re-encola para el siguiente flush.
+   * `final: true` (cierre de página/app): el lote no espera al primer POST en vuelo, porque
+   * el documento se muere; un lote que falle por red o 5xx se re-encola para el siguiente flush.
    */
   flushAnalytics(options) {
     if (!this.tracking?.isTrackingEnabled()) return;
@@ -2262,7 +2311,76 @@ var DeepdotsPopups = class {
   flushEngagement() {
     if (!this.tracking?.isTrackingEnabled()) return;
     const ms = this.engagement?.consume() ?? 0;
-    if (ms > 0) this.track("deepdots_user_engagement", { engagement_time_msec: ms });
+    if (ms > 0) {
+      this.track("deepdots_user_engagement", { engagement_time_msec: ms });
+      this.lastEngagementAt = Date.now();
+    }
+  }
+  /** Tick del flush periódico: latido de engagement si toca, y envío de lo acumulado. */
+  onAnalyticsFlushTick() {
+    if (this.sessionOpen && this.isDocumentVisible() && Date.now() - this.lastEngagementAt >= ANALYTICS_HEARTBEAT_MS) {
+      this.flushEngagement();
+    }
+    this.flushAnalytics();
+  }
+  /**
+   * La pestaña vuelve a verse. Tras más de ANALYTICS_SESSION_TIMEOUT_MS oculta, la sesión
+   * anterior termina y empieza otra: seguir con el mismo sessionId mezclaba dos visitas y,
+   * si el backend ya la había cerrado por inactividad, la partía en dos feedbacks.
+   *  - Oculta menos de ANALYTICS_SESSION_DISCARD_MS: el backend aún la tiene abierta → se
+   *    cierra con normalidad (page_view de la pantalla, session_end `idle_timeout`, completed).
+   *  - Más: ya la cerró el backend → se descarta sin enviar nada.
+   */
+  onDocumentVisible() {
+    const hiddenFor = this.hiddenAt === null ? 0 : Date.now() - this.hiddenAt;
+    this.hiddenAt = null;
+    if (!this.sessionOpen) return;
+    if (hiddenFor < ANALYTICS_SESSION_TIMEOUT_MS) {
+      this.engagement?.resume();
+      return;
+    }
+    if (hiddenFor < ANALYTICS_SESSION_DISCARD_MS) {
+      this.closeSession("idle_timeout");
+    } else {
+      this.discardSession();
+    }
+    this.openSession();
+  }
+  /** Olvida la sesión abierta sin enviar nada (ver onDocumentVisible). */
+  discardSession() {
+    this.sessionOpen = false;
+    this.navObserver?.discard();
+    this.analytics?.discardSession(this.analyticsIdentity());
+    this.engagement?.consume();
+    this.engagement?.pause();
+    this.analyticsFeedbackSessionId = void 0;
+    this.tracking?.setSessionId(null);
+    this.log("tracking \xB7 session discarded after", ANALYTICS_SESSION_DISCARD_MS / 6e4, "min hidden");
+  }
+  /**
+   * Geolocalización por IP (país/ciudad para analytics). La caché persistente es local y se
+   * aplica siempre que `geolocation` no esté desactivado. El lookup a terceros (ipapi.co →
+   * ipwho.is → ipinfo.io, fallback con timeout) solo se hace si el dato se va a ENVIAR:
+   * analytics configurado + tracking activo + caché ausente o caducada. Una vez por instancia.
+   */
+  resolveGeo() {
+    const storage = this.storage;
+    if (!this.geoEnabled || !storage || !this.analytics) return;
+    const cachedGeo = readCachedGeo(storage, Date.now());
+    if (cachedGeo) {
+      this.analytics.updateDevice(cachedGeo);
+      return;
+    }
+    if (!this.geoWanted || this.geoLookupStarted) return;
+    if (!this.tracking?.isTrackingEnabled()) return;
+    this.geoLookupStarted = true;
+    fetchGeo().then((geo) => {
+      if (geo) {
+        this.analytics?.updateDevice(geo);
+        writeCachedGeo(storage, geo, Date.now());
+      }
+    }).catch(() => {
+    });
   }
   analyticsIdentity() {
     return {
@@ -2272,22 +2390,32 @@ var DeepdotsPopups = class {
   }
   /** Flush automático al ocultar/cerrar la página (no perder el lote pendiente). */
   setupAnalyticsFlush() {
+    this.startAnalyticsFlushTimer();
     if (typeof document === "undefined" || typeof window === "undefined") return;
-    this.analyticsFlushTimer = setInterval(() => this.flushAnalytics(), ANALYTICS_FLUSH_INTERVAL_MS);
     window.addEventListener("pagehide", () => {
       clearInterval(this.analyticsFlushTimer);
       this.closeSession("page_hide");
     });
+    window.addEventListener("pageshow", (event) => {
+      if (!event.persisted) return;
+      this.startAnalyticsFlushTimer();
+      this.openSession();
+    });
     document.addEventListener("visibilitychange", () => {
       if (document.visibilityState === "hidden") {
         this.flushEngagement();
         this.engagement?.pause();
         this.flushAnalytics();
+        this.hiddenAt = Date.now();
       } else if (document.visibilityState === "visible") {
-        this.engagement?.resume();
+        this.onDocumentVisible();
       }
     });
   }
+  startAnalyticsFlushTimer() {
+    clearInterval(this.analyticsFlushTimer);
+    this.analyticsFlushTimer = setInterval(() => this.onAnalyticsFlushTick(), ANALYTICS_FLUSH_INTERVAL_MS);
+  }
   /** Enable auto-launch functionality with configured triggers */
   autoLaunch() {
     if (!this.initialized) {
@@ -2381,6 +2509,7 @@ var DeepdotsPopups = class {
     this.emitEvent("popup_shown", def.surveyId, { popupId: def.id });
   }
   shouldShow(def, pathUrl, skipPathCheck = false) {
+    if (this.storage) this.loadPopupState(this.storage);
     if (this.isPathExcluded(def, pathUrl)) {
       return false;
     }
@@ -2907,22 +3036,32 @@ var DeepdotsPopups = class {
     this.persistPopupState();
   }
   /**
-   * Rehidrata el estado de redisplay desde el storage. `answeredSurveys` se reconstruye
-   * desde las entradas COMPLETED: es exactamente lo que persiste `markSurveyAnswered`.
+   * Fusiona el estado de redisplay del storage con el de memoria: por cada popup/survey gana
+   * la entrada MÁS RECIENTE. Fusionar y no sustituir es lo que hace convivir a varias
+   * pestañas sobre el mismo `localStorage`: se llama en el `init()`, antes de cada decisión
+   * de mostrar y antes de cada escritura. `answeredSurveys` se reconstruye desde las
+   * entradas COMPLETED: es exactamente lo que persiste `markSurveyAnswered`.
    */
   loadPopupState(storage) {
     const state = readPopupState(storage);
     Object.entries(state.lastShown).forEach(([popupId, timestamp]) => {
-      this.lastShown.set(popupId, timestamp);
+      if (timestamp > (this.lastShown.get(popupId) ?? -Infinity)) this.lastShown.set(popupId, timestamp);
     });
     Object.entries(state.progress).forEach(([surveyId, entry]) => {
+      const current = this.surveyProgress.get(surveyId);
+      if (current && current.timestamp >= entry.timestamp) return;
       this.surveyProgress.set(surveyId, { status: entry.status, timestamp: entry.timestamp });
       if (entry.status === "COMPLETED") this.answeredSurveys.add(surveyId);
     });
   }
-  /** Vuelca el estado de redisplay al storage. Sin storage (o bloqueado) degrada a memoria. */
+  /**
+   * Vuelca el estado de redisplay al storage. Sin storage (o bloqueado) degrada a memoria.
+   * Fusiona antes de escribir: escribir solo la foto en memoria borraba lo que otra pestaña
+   * hubiese guardado desde nuestro `init()`.
+   */
   persistPopupState() {
     if (!this.storage) return;
+    this.loadPopupState(this.storage);
     writePopupState(this.storage, {
       lastShown: Object.fromEntries(this.lastShown),
       progress: Object.fromEntries(this.surveyProgress)