@magicfeedback/popup-sdk 1.16.0 → 1.17.0

package/dist/react-native.mjs

@@ -1279,97 +1279,166 @@ async function safeBodyText(res) {
     return "";
   }
 }
+var PENDING_MAX = 50;
+var PENDING_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var POST_TIMEOUT_MS = 2e4;
+function pendingKey(integration) {
+  return `__deepdots_analytics_pending__:${integration}`;
+}
+function generateSessionId() {
+  const c = globalThis.crypto;
+  if (typeof c?.randomUUID === "function") return c.randomUUID();
+  const b = new Uint8Array(16);
+  if (typeof c?.getRandomValues === "function") c.getRandomValues(b);
+  else for (let i = 0; i < 16; i++) b[i] = Math.floor(Math.random() * 256);
+  b[6] = b[6] & 15 | 64;
+  b[8] = b[8] & 63 | 128;
+  const h = Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
 function createFeedbackSink(options) {
-  let feedbackSessionId = options.initialSessionId || void 0;
-  let firstPostInFlight = null;
-  let generation = 0;
   const url = `${options.baseUrl}/sdk/feedback`;
-  const post = async (body, final, sessionEnd = false) => {
-    const postGeneration = generation;
+  const newSessionId = options.newSessionId ?? generateSessionId;
+  const now = options.now ?? (() => Date.now());
+  const storageKey = pendingKey(options.keys.integration);
+  let feedbackSessionId = options.initialSessionId || void 0;
+  let announcedId = feedbackSessionId;
+  const pending2 = loadPending();
+  let draining = null;
+  function loadPending() {
+    if (!options.storage) return [];
+    try {
+      const raw = options.storage.getItem(storageKey);
+      const list = raw ? JSON.parse(raw) : [];
+      return Array.isArray(list) ? list.filter((p) => p?.body && now() - p.at <= PENDING_MAX_AGE_MS) : [];
+    } catch {
+      return [];
+    }
+  }
+  function savePending() {
+    if (!options.storage) return;
+    try {
+      if (pending2.length) options.storage.setItem(storageKey, JSON.stringify(pending2));
+      else options.storage.removeItem(storageKey);
+    } catch {
+    }
+  }
+  function addPending(batch) {
+    pending2.push(batch);
+    if (pending2.length > PENDING_MAX) pending2.splice(0, pending2.length - PENDING_MAX);
+    savePending();
+  }
+  function removePending(batch) {
+    const i = pending2.indexOf(batch);
+    if (i >= 0) pending2.splice(i, 1);
+    savePending();
+  }
+  async function post(body, final) {
     const json = JSON.stringify(body);
     const small = json.length <= KEEPALIVE_MAX_BYTES;
     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);
-      return;
+      return "drop";
     }
-    const res = await f(url, {
-      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 } : {}
-    });
-    if (!res.ok) {
+    let timer;
+    try {
+      const request = f(url, {
+        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 } : {}
+      });
+      const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("timeout")), POST_TIMEOUT_MS);
+      });
+      const res = await Promise.race([request, timeout]);
+      if (res.ok) return "ok";
       const detail = await safeBodyText(res);
       if (isRetryableStatus(res.status)) {
-        throw new Error(`POST /sdk/feedback ${res.status} (retryable): ${detail}`);
+        options.log?.(`[DeepdotsAnalytics] POST /sdk/feedback ${res.status} (retryable): ${detail}`);
+        return "retry";
       }
       options.log?.(
         `[DeepdotsAnalytics] POST /sdk/feedback rejected with ${res.status}; batch DISCARDED:`,
         detail
       );
-      return;
-    }
-    if (sessionEnd) {
-      let closedId = body.sessionId;
-      try {
-        const data = await res.json();
-        closedId = data?.sessionId ?? closedId;
-      } catch {
-      }
-      try {
-        if (closedId) options.onSessionClosed?.(closedId);
-      } catch {
-      }
-      return;
+      return "drop";
+    } catch (error) {
+      options.log?.("[DeepdotsAnalytics] POST /sdk/feedback failed (will retry):", error);
+      return "retry";
+    } finally {
+      clearTimeout(timer);
     }
+  }
+  function delivered(body) {
+    const id = body.sessionId;
+    if (!id) return;
     try {
-      const data = await res.json();
-      if (postGeneration !== generation) {
-        options.log?.("[DeepdotsAnalytics] sessionId of a closed session ignored:", data?.sessionId);
-        return;
-      }
-      if (data?.sessionId && data.sessionId !== feedbackSessionId) {
-        feedbackSessionId = data.sessionId;
-        options.log?.("[DeepdotsAnalytics] feedbackSessionId cached:", feedbackSessionId);
-        options.onSessionId?.(feedbackSessionId);
+      if (body.completed) {
+        options.onSessionClosed?.(id);
+      } else if (id === feedbackSessionId && id !== announcedId) {
+        announcedId = id;
+        options.log?.("[DeepdotsAnalytics] feedback session open:", id);
+        options.onSessionId?.(id);
       }
     } catch {
     }
-  };
+  }
+  async function send(batch, final, alreadyPending) {
+    const result = await post(batch.body, final);
+    if (result === "retry") {
+      if (!alreadyPending) addPending(batch);
+      return;
+    }
+    if (alreadyPending) removePending(batch);
+    if (result === "ok") delivered(batch.body);
+  }
+  function drain() {
+    const run = async () => {
+      for (let i = 0; i < pending2.length; ) {
+        const batch = pending2[i];
+        await send(batch, false, true);
+        if (pending2[i] === batch) return;
+      }
+    };
+    const next = draining ? draining.then(run) : run();
+    draining = next;
+    void next.finally(() => {
+      if (draining === next) draining = null;
+    });
+    return next;
+  }
+  if (pending2.length) {
+    savePending();
+    setTimeout(() => void drain(), 0);
+  }
   return async (envelope, meta) => {
     if (meta?.resetSession) {
       feedbackSessionId = void 0;
-      firstPostInFlight = null;
-      generation++;
       options.onSessionReset?.();
       return;
     }
     const final = meta?.final === true;
     const sessionEnd = meta?.sessionEnd === true;
-    if (!feedbackSessionId && firstPostInFlight && !final) {
-      await firstPostInFlight;
-    }
+    if (!feedbackSessionId) feedbackSessionId = newSessionId();
     const body = buildAnalyticsFeedbackBody(envelope, options.keys, feedbackSessionId, { sessionEnd });
     options.log?.("[DeepdotsAnalytics] POST /sdk/feedback \u2192", body);
-    const sent = post(body, final, sessionEnd);
+    const batch = { body, at: now() };
     if (sessionEnd) {
       feedbackSessionId = void 0;
-      firstPostInFlight = null;
-      generation++;
       options.onSessionReset?.();
-    } else if (!feedbackSessionId) {
-      firstPostInFlight = sent.then(
-        () => void 0,
-        () => void 0
-      );
+      addPending(batch);
+      await drain();
+      return;
     }
-    await sent;
+    const retries = pending2.length ? drain() : null;
+    await Promise.all([retries, send(batch, final, false)]);
   };
 }
 
@@ -1726,12 +1795,12 @@ var EngagementTracker = class {
 };
 
 // src/contact/contact-manager.ts
-function stableSerialize(attrs) {
+function stableSerialize(userId, attrs) {
   const sorted = {};
   for (const key of Object.keys(attrs).sort()) {
     sorted[key] = attrs[key];
   }
-  return JSON.stringify(sorted);
+  return JSON.stringify({ userId, attributes: sorted });
 }
 var ContactManager = class {
   constructor(options) {
@@ -1741,18 +1810,23 @@ var ContactManager = class {
     this.post = options.post;
   }
   /**
-   * Envía los atributos si cambiaron respecto a lo último enviado.
-   * @returns `true` si se envió, `false` si no hubo cambios.
+   * Envía los atributos si cambiaron respecto a lo último enviado. La caché solo se guarda
+   * cuando la API acepta el envío; si falla, la llamada siguiente reintenta. Nunca rechaza.
+   * @returns `true` si se envió, `false` si no hubo cambios o el envío falló.
    */
   async setAttributes(attributes) {
-    const serialized = stableSerialize(attributes);
+    const serialized = stableSerialize(this.userId, attributes);
     const last = this.storage.getItem(STORAGE_KEYS.contactAttributes);
     if (last === serialized) return false;
-    await this.post({
-      publicKey: this.publicKey,
-      userId: this.userId,
-      userAttributes: attributes
-    });
+    try {
+      await this.post({
+        publicKey: this.publicKey,
+        userId: this.userId,
+        userAttributes: attributes
+      });
+    } catch {
+      return false;
+    }
     this.storage.setItem(STORAGE_KEYS.contactAttributes, serialized);
     return true;
   }
@@ -1783,6 +1857,10 @@ function crashRecordToParams(r) {
 }
 var CrashReporter = class {
   constructor(options) {
+    /** Los handlers de `window` ya están puestos: `install()` es idempotente. */
+    this.windowInstalled = false;
+    /** ErrorUtils ya enganchados: engancharlos dos veces capturaría cada error dos veces. */
+    this.hookedErrorUtils = /* @__PURE__ */ new Set();
     this.options = options;
     this.now = options.now ?? (() => Date.now());
   }
@@ -1858,9 +1936,11 @@ var CrashReporter = class {
     }
     return queue;
   }
-  /** Instala los handlers globales de errores no capturados (no-op sin `window`). */
+  /** Instala los handlers globales de errores no capturados (no-op sin `window`). Idempotente. */
   install() {
+    if (this.windowInstalled) return;
     if (typeof window === "undefined" || typeof window.addEventListener !== "function") return;
+    this.windowInstalled = true;
     window.addEventListener("error", (e) => {
       if (!this.isEnabled()) return;
       this.captureUnhandled(e.error ?? e.message ?? "error");
@@ -1870,8 +1950,10 @@ var CrashReporter = class {
       this.captureUnhandled(e.reason ?? "unhandledrejection");
     });
   }
-  /** Engancha `global.ErrorUtils` de RN (no hay `window`): persiste y encadena al handler previo. */
+  /** Engancha `global.ErrorUtils` de RN (no hay `window`): persiste y encadena al handler previo. Idempotente por instancia de ErrorUtils. */
   installReactNative(errorUtils) {
+    if (this.hookedErrorUtils.has(errorUtils)) return;
+    this.hookedErrorUtils.add(errorUtils);
     const previous = errorUtils.getGlobalHandler?.();
     errorUtils.setGlobalHandler((error, isFatal) => {
       if (this.isEnabled()) this.captureUnhandled(error);
@@ -2084,6 +2166,8 @@ var DeepdotsPopups = class {
     this.analyticsFlushTimer = void 0;
     /** Crash & error reporting (#14–17). Null hasta init(). */
     this.crashReporter = null;
+    /** ErrorUtils de RN recibido del host (o del Provider); se engancha en cuanto haya consentimiento. */
+    this.rnErrorUtils = null;
     /** Protecciones del funnel de Messaging (#18–22). Vigencia de sesión: se reinicia en init(). */
     this.messageGuard = new MessageGuard();
     /** Observador de navegación (Fase 2): emite page_view por el canal de analytics. */
@@ -2184,6 +2268,10 @@ var DeepdotsPopups = class {
       keys: config.analytics,
       log: (...a) => this.log(...a),
       initialSessionId: resumable?.sessionId,
+      // En móvil (RN) la app puede morir con el lote de cierre sin entregar: se
+      // persiste y se reenvía en el arranque siguiente. En web el cierre sale con
+      // `keepalive` y varias pestañas compartirían el mismo storage.
+      storage: (config.platform ?? "web") !== "web" ? storage : void 0,
       onSessionId: (id) => {
         this.analyticsFeedbackSessionId = id;
         this.notifyFeedbackSession(id, "open");
@@ -2219,9 +2307,7 @@ var DeepdotsPopups = class {
       now: () => Date.now(),
       enabled: () => this.tracking?.isTrackingEnabled() ?? false
     });
-    if (this.tracking?.isTrackingEnabled()) {
-      this.crashReporter.install();
-    }
+    this.installCrashHandlers();
     this.geoEnabled = config.geolocation ?? true;
     this.geoWanted = this.geoEnabled && !!config.analytics;
     this.resolveGeo();
@@ -2290,6 +2376,7 @@ var DeepdotsPopups = class {
     if (!enabled) this.closeSession("tracking_disabled");
     this.tracking?.setTrackingEnabled(enabled);
     if (enabled) this.openSession("tracking_enabled");
+    if (enabled) this.installCrashHandlers();
     if (enabled) this.resolveGeo();
     this.log("tracking \xB7 setTrackingEnabled:", enabled, "\xB7 session_id:", this.tracking?.getSessionId() ?? null);
   }
@@ -2320,10 +2407,27 @@ var DeepdotsPopups = class {
     if (!this.tracking?.isTrackingEnabled()) return;
     this.crashReporter?.reportError(error, options);
   }
-  /** Engancha `global.ErrorUtils` de RN para capturar errores JS no manejados. No-op si tracking off. */
+  /**
+   * Engancha `global.ErrorUtils` de RN para capturar errores JS no manejados. Con tracking off
+   * se recuerda y se engancha cuando se conceda el consentimiento (`setTrackingEnabled(true)`).
+   */
   installReactNativeCrashHandler(errorUtils) {
-    if (!this.tracking?.isTrackingEnabled()) return;
-    this.crashReporter?.installReactNative(errorUtils);
+    this.rnErrorUtils = errorUtils;
+    this.installCrashHandlers();
+  }
+  /**
+   * Pone los handlers de errores no capturados: `window` en web y `ErrorUtils` en RN (el que
+   * pasó el host o, si no pasó ninguno, `globalThis.ErrorUtils`, para que un `init()` sin
+   * `setupReactNative` también capture). Solo con consentimiento; idempotente, así que se
+   * llama en `init()` y cada vez que se activa el tracking.
+   */
+  installCrashHandlers() {
+    if (!this.crashReporter || !this.tracking?.isTrackingEnabled()) return;
+    this.crashReporter.install();
+    const errorUtils = this.rnErrorUtils ?? globalThis.ErrorUtils;
+    if (errorUtils && typeof errorUtils.setGlobalHandler === "function") {
+      this.crashReporter.installReactNative(errorUtils);
+    }
   }
   /**
    * Info interna del usuario que solo conoce el host (idioma, edad, plan…), persistida en el
@@ -3146,25 +3250,31 @@ var DeepdotsPopups = class {
       return null;
     }
   }
-  /** Envía los atributos de contact a la API (`POST /sdk/popups/contact`). */
+  /**
+   * Envía los atributos de contact a la API (`POST /sdk/popups/contact`). Rechaza si no se
+   * pudo enviar (sin red o respuesta no-2xx), para que `ContactManager` no guarde la caché
+   * y la llamada siguiente reintente.
+   */
   async postContact(body) {
     const baseUrl = this.baseUrl;
-    if (!baseUrl) return;
+    if (!baseUrl) throw new Error("no base URL");
     const endpoint = `${baseUrl}/sdk/popups/contact`;
+    let response;
     try {
-      const response = await fetch(endpoint, {
+      response = await fetch(endpoint, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(body)
       });
-      if (!response.ok) {
-        this.log("Failed to post contact", response.status, response.statusText);
-        return;
-      }
-      this.log("contact \xB7 sent attributes for user:", body.userId);
     } catch (error) {
       this.log("Error posting contact", error);
+      throw error;
+    }
+    if (!response.ok) {
+      this.log("Failed to post contact", response.status, response.statusText);
+      throw new Error(`HTTP ${response.status}`);
     }
+    this.log("contact \xB7 sent attributes for user:", body.userId);
   }
   /** Notifica eventos de popup a la API */
   async postPopupEvent(status, popupId, userId) {