@magicfeedback/popup-sdk 1.1.2 → 1.1.4

package/dist/react-native.mjs

@@ -392,8 +392,8 @@ var AnalyticsManager = class {
   constructor(options = {}) {
     this.events = [];
     this.attributes = {};
-    this.miniService = null;
-    this.miniServiceEnteredAt = 0;
+    /** Mini-services activos: nombre → timestamp de entrada. El orden de inserción marca el "más reciente". */
+    this.activeMiniServices = /* @__PURE__ */ new Map();
     this.sink = options.sink ?? dryRunSink;
     this.now = options.now ?? (() => Date.now());
     this.publicKey = options.publicKey;
@@ -414,24 +414,38 @@ var AnalyticsManager = class {
       this.attributes[k] = String(v);
     }
   }
-  /** Marca el inicio de un mini-service; etiqueta los eventos siguientes con `mini_service`. */
+  /**
+   * Marca el inicio de un mini-service; etiqueta los eventos siguientes con `mini_service`.
+   * Admite varios activos a la vez (concurrencia); el "actual" para etiquetar es el más reciente.
+   * Reentrar con un nombre ya activo refresca su orden y su tiempo de entrada.
+   */
   enterMiniService(name, entryPointType) {
-    this.miniService = name;
-    this.miniServiceEnteredAt = this.now();
-    this.track("mini_service_enter", { entry_point_type: entryPointType ?? null });
-  }
-  /** Cierra el mini-service activo emitiendo `mini_service_exit` con su duración (#27). No-op si no hay ninguno. */
-  exitMiniService() {
-    const name = this.miniService;
-    if (name == null) return;
-    const durationSeconds = Math.max(0, Math.round((this.now() - this.miniServiceEnteredAt) / 1e3));
-    this.miniService = null;
-    this.track("mini_service_exit", { mini_service: name, duration_seconds: durationSeconds });
+    this.activeMiniServices.delete(name);
+    this.activeMiniServices.set(name, this.now());
+    this.track("deepdots_mini_service_enter", { entry_point_type: entryPointType ?? null });
+  }
+  /**
+   * Cierra el mini-service `name` emitiendo `mini_service_exit` con su duración (#27).
+   * No-op si ese nombre no está activo. Cierre coherente con concurrencia.
+   */
+  exitMiniService(name) {
+    const enteredAt = this.activeMiniServices.get(name);
+    if (enteredAt === void 0) return;
+    const durationSeconds = Math.max(0, Math.round((this.now() - enteredAt) / 1e3));
+    this.activeMiniServices.delete(name);
+    this.track("deepdots_mini_service_exit", { mini_service: name, duration_seconds: durationSeconds });
+  }
+  /** Cierra TODOS los mini-services activos (orden LIFO). Para el cierre por lifecycle (background/cierre). */
+  exitAllMiniServices() {
+    for (const name of Array.from(this.activeMiniServices.keys()).reverse()) {
+      this.exitMiniService(name);
+    }
   }
   /** Registra un evento de analítica (modelo GA: nombre + params). */
   track(name, params) {
+    const current = this.getMiniService();
     const merged = {
-      ...this.miniService ? { mini_service: this.miniService } : {},
+      ...current ? { mini_service: current } : {},
       ...params ?? {}
     };
     this.events.push({
@@ -443,9 +457,11 @@ var AnalyticsManager = class {
       this.onFlushNeeded?.();
     }
   }
-  /** Mini-service activo (para inyectarlo en la metadata del survey, #33). */
+  /** Mini-service actual (el más reciente aún activo) para etiquetar eventos + metadata del survey (#33). */
   getMiniService() {
-    return this.miniService;
+    let last = null;
+    for (const name of this.activeMiniServices.keys()) last = name;
+    return last;
   }
   /** Nº de eventos pendientes de flush. */
   pending() {
@@ -784,11 +800,153 @@ var ContactManager = class {
   }
 };
 
+// src/analytics/crash-reporter.ts
+var STACK_MAX = 8e3;
+var QUEUE_KEY = "deepdots.crash.queue";
+var MAX_QUEUED = 20;
+function crashRecordToParams(r) {
+  const params = {
+    crashed_at: r.crashedAt,
+    crash_type: r.crashType,
+    message: r.message,
+    stack: r.stack,
+    fatal: r.fatal,
+    handled: r.handled,
+    severity: r.severity
+  };
+  if (r.sessionId) params.crashed_session_id = r.sessionId;
+  if (r.appVersion) params.crashed_app_version = r.appVersion;
+  if (r.osVersion) params.crashed_os_version = r.osVersion;
+  if (r.deviceModel) params.crashed_device_model = r.deviceModel;
+  if (r.context) {
+    for (const [k, v] of Object.entries(r.context)) params[`ctx_${k}`] = v;
+  }
+  return params;
+}
+var CrashReporter = class {
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? (() => Date.now());
+  }
+  isEnabled() {
+    return this.options.enabled ? this.options.enabled() : true;
+  }
+  /** Construye un CrashRecord capturando contexto en el momento del crash. */
+  buildRecord(error, severity, handled, fatal, context) {
+    const err = error;
+    const isErr = error instanceof Error;
+    const dev = this.options.device();
+    const ctx = context ? Object.fromEntries(Object.entries(context).map(([k, v]) => [k, String(v)])) : void 0;
+    return {
+      crashedAt: this.now(),
+      crashType: isErr && err.name || "Error",
+      message: isErr ? String(err.message ?? "") : String(error),
+      stack: (isErr && typeof err.stack === "string" ? err.stack : "").slice(0, STACK_MAX),
+      fatal,
+      handled,
+      severity,
+      sessionId: this.options.sessionId(),
+      appVersion: dev.appVersion,
+      osVersion: dev.osVersion,
+      deviceModel: dev.deviceModel,
+      context: ctx
+    };
+  }
+  /** API pública del host: reporta un error (app viva) → emite el evento ya. */
+  reportError(error, options = {}) {
+    if (!this.isEnabled()) return;
+    const severity = options.severity ?? "error";
+    const handled = options.handled ?? true;
+    const fatal = severity === "fatal";
+    const record = this.buildRecord(error, severity, handled, fatal, options.context);
+    this.options.emit(crashRecordToParams(record));
+  }
+  /** Captura un error no manejado (fatal) → persiste a disco para replay en el siguiente arranque. */
+  captureUnhandled(error) {
+    this.persist(this.buildRecord(error, "fatal", false, true));
+  }
+  /** Persiste un crash no capturado a disco para reenviarlo en el siguiente arranque. */
+  persist(record) {
+    let queue = [];
+    try {
+      const raw = this.options.storage.getItem(QUEUE_KEY);
+      if (raw) queue = JSON.parse(raw);
+      if (!Array.isArray(queue)) queue = [];
+    } catch {
+      queue = [];
+    }
+    queue.push(record);
+    if (queue.length > MAX_QUEUED) queue = queue.slice(queue.length - MAX_QUEUED);
+    try {
+      this.options.storage.setItem(QUEUE_KEY, JSON.stringify(queue));
+    } catch {
+    }
+  }
+  /** Lee y vacía la cola de crashes pendientes (llamado en init para el replay). */
+  drainPendingCrashes() {
+    let queue = [];
+    try {
+      const raw = this.options.storage.getItem(QUEUE_KEY);
+      if (raw) queue = JSON.parse(raw);
+      if (!Array.isArray(queue)) queue = [];
+    } catch {
+      queue = [];
+    }
+    if (queue.length) {
+      try {
+        this.options.storage.removeItem(QUEUE_KEY);
+      } catch {
+      }
+    }
+    return queue;
+  }
+  /** Instala los handlers globales de errores no capturados (no-op sin `window`). */
+  install() {
+    if (typeof window === "undefined") return;
+    window.addEventListener("error", (e) => {
+      if (!this.isEnabled()) return;
+      this.captureUnhandled(e.error ?? e.message ?? "error");
+    });
+    window.addEventListener("unhandledrejection", (e) => {
+      if (!this.isEnabled()) return;
+      this.captureUnhandled(e.reason ?? "unhandledrejection");
+    });
+  }
+  /** Engancha `global.ErrorUtils` de RN (no hay `window`): persiste y encadena al handler previo. */
+  installReactNative(errorUtils) {
+    const previous = errorUtils.getGlobalHandler?.();
+    errorUtils.setGlobalHandler((error, isFatal) => {
+      if (this.isEnabled()) this.captureUnhandled(error);
+      previous?.(error, isFatal);
+    });
+  }
+  /** @internal Test seam: ejercita el camino de persistencia (window handlers no son testeables en vitest). */
+  _persistForTest(error) {
+    this.captureUnhandled(error);
+  }
+};
+
+// src/analytics/messaging.ts
+function buildMessageParams(stage, o) {
+  const p = {
+    stage,
+    message_id: o.id,
+    message_title: o.title,
+    channel: o.channel
+  };
+  if (o.campaign) p.campaign = o.campaign;
+  if (o.value !== void 0) p.value = o.value;
+  if (o.currency) p.currency = o.currency;
+  return { ...p, ...o.params ?? {} };
+}
+
 // src/core/deepdots-popups.ts
 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 RESERVED_EVENT_PREFIX = "deepdots_";
+var CUSTOM_EVENT_PREFIX = "deepdots_event_";
 var DeepdotsPopups = class {
   constructor() {
     this.config = null;
@@ -818,6 +976,8 @@ var DeepdotsPopups = class {
     this.analyticsFeedbackSessionId = void 0;
     /** Timer del flush periódico de analytics (cada ANALYTICS_FLUSH_INTERVAL_MS). */
     this.analyticsFlushTimer = void 0;
+    /** Crash & error reporting (#14–17). Null hasta init(). */
+    this.crashReporter = null;
     /** Observador de navegación (Fase 2): emite page_view por el canal de analytics. */
     this.navObserver = null;
     /** Tiempo activo (engagement time, #8). */
@@ -869,25 +1029,44 @@ var DeepdotsPopups = class {
         this.analyticsFeedbackSessionId = id;
       }
     }) : void 0;
+    const device = config.device ?? collectDeviceInfo(config.appVersion);
     this.analytics = new AnalyticsManager({
       sink: analyticsSink,
       publicKey: config.analytics?.publicKey ?? this.config.apiKey,
       language: typeof navigator !== "undefined" ? navigator.language : void 0,
       platform: config.platform ?? "web",
-      device: config.device ?? collectDeviceInfo(config.appVersion),
+      device,
       maxBatchSize: ANALYTICS_MAX_BATCH_SIZE,
       onFlushNeeded: () => this.flushAnalytics()
     });
+    this.crashReporter = new CrashReporter({
+      storage,
+      emit: (params) => this.track("deepdots_app_crash", params),
+      device: () => ({ appVersion: device.app_version, osVersion: device.os_version, deviceModel: device.device_model }),
+      sessionId: () => this.tracking?.getSessionId() ?? null,
+      now: () => Date.now(),
+      enabled: () => this.tracking?.isTrackingEnabled() ?? false
+    });
+    if (this.tracking?.isTrackingEnabled()) {
+      this.crashReporter.install();
+    }
     collectGeoInfo().then((geo) => {
       if (geo) this.analytics?.updateDevice(geo);
     }).catch(() => {
     });
     this.navObserver = new NavigationObserver();
-    this.navObserver.onVisit((v) => this.track("page_view", { screen: v.screen, duration_seconds: v.durationSeconds }));
+    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.track("deepdots_session_start", {});
+    const pendingCrashes = this.crashReporter.drainPendingCrashes();
+    if (this.tracking?.isTrackingEnabled()) {
+      for (const rec of pendingCrashes) {
+        this.track("deepdots_app_crash", crashRecordToParams(rec));
+      }
+    }
     this.initialized = true;
     this.log("SDK initialized", this.config);
     if (this.renderer.init) this.renderer.init();
@@ -920,14 +1099,25 @@ var DeepdotsPopups = class {
   /** Registra un evento de analítica (modelo GA: nombre + params). No-op si tracking off. */
   track(name, params) {
     if (!this.tracking?.isTrackingEnabled()) return;
-    this.analytics?.track(name, params);
-    this.log("analytics \xB7 track:", name, params ?? {});
+    const eventName = name.startsWith(RESERVED_EVENT_PREFIX) ? name : `${CUSTOM_EVENT_PREFIX}${name}`;
+    this.analytics?.track(eventName, params);
+    this.log("analytics \xB7 track:", eventName, params ?? {});
   }
   /** User attributes para breakdowns (registration_status, pass_type, sector, pass_status…). */
   setUserAttributes(attributes) {
     if (!this.tracking?.isTrackingEnabled()) return;
     this.analytics?.setUserAttributes(attributes);
   }
+  /** Reporta un error del host (manejado o no) → evento `deepdots_app_crash`. No-op si tracking off. */
+  reportError(error, options) {
+    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. */
+  installReactNativeCrashHandler(errorUtils) {
+    if (!this.tracking?.isTrackingEnabled()) return;
+    this.crashReporter?.installReactNative(errorUtils);
+  }
   /**
    * Info interna del usuario que solo conoce el host (idioma, edad, plan…), persistida en el
    * Contact del backend para segmentación/targeting de popups. Identificada por el `userId` del
@@ -945,23 +1135,27 @@ var DeepdotsPopups = class {
     this.analytics?.enterMiniService(name, entryPointType);
     this.log("analytics \xB7 enterMiniService:", name, entryPointType ?? "");
   }
-  /** Cierra el mini-service activo (emite `mini_service_exit` con duración, #27). No-op si tracking off. */
-  exitMiniService() {
+  /** Cierra el mini-service `name` (emite `mini_service_exit` con duración, #27). No-op si tracking off o si ese no está activo. */
+  exitMiniService(name) {
     if (!this.tracking?.isTrackingEnabled()) return;
-    this.analytics?.exitMiniService();
-    this.log("analytics \xB7 exitMiniService");
+    this.analytics?.exitMiniService(name);
+    this.log("analytics \xB7 exitMiniService:", name);
   }
   /** Findability (#31/#35): registra una búsqueda. `has_results` se deriva de `resultsCount`. */
   trackSearch(query, resultsCount, params) {
-    this.track("search", { query, results_count: resultsCount, has_results: resultsCount > 0, ...params ?? {} });
+    this.track("deepdots_search", { query, results_count: resultsCount, has_results: resultsCount > 0, ...params ?? {} });
   }
   /** Findability friction (#34/#35): señal de fricción con su `friction_topic`. */
   trackFindabilityFriction(frictionTopic, params) {
-    this.track("findability_friction", { friction_topic: frictionTopic, ...params ?? {} });
+    this.track("deepdots_findability_friction", { friction_topic: frictionTopic, ...params ?? {} });
   }
   /** Funnel: un paso del embudo, correlacionado por `taskId`. El backend reconstruye conversión/drop-off/tiempo. */
   trackFunnelStep(funnel, step, taskId, params) {
-    this.track("funnel_step", { funnel, step, task_id: taskId, ...params ?? {} });
+    this.track("deepdots_funnel_step", { funnel, step, task_id: taskId, ...params ?? {} });
+  }
+  /** Messaging (#18–22): registra una etapa del funnel de una notificación (push/in-app). No-op si tracking off. */
+  trackMessage(stage, options) {
+    this.track("deepdots_message", buildMessageParams(stage, options));
   }
   /**
    * Navegación MANUAL (entornos sin History API, p. ej. React Native con React Navigation).
@@ -987,7 +1181,7 @@ var DeepdotsPopups = class {
   onBackground() {
     this.navObserver?.stop();
     this.navStarted = false;
-    this.exitMiniService();
+    if (this.tracking?.isTrackingEnabled()) this.analytics?.exitAllMiniServices();
     this.flushEngagement();
     this.engagement?.pause();
     this.flushAnalytics();
@@ -1010,7 +1204,7 @@ var DeepdotsPopups = class {
   flushEngagement() {
     if (!this.tracking?.isTrackingEnabled()) return;
     const ms = this.engagement?.consume() ?? 0;
-    if (ms > 0) this.track("user_engagement", { engagement_time_msec: ms });
+    if (ms > 0) this.track("deepdots_user_engagement", { engagement_time_msec: ms });
   }
   analyticsIdentity() {
     return {
@@ -1025,7 +1219,7 @@ var DeepdotsPopups = class {
     window.addEventListener("pagehide", () => {
       clearInterval(this.analyticsFlushTimer);
       this.navObserver?.stop();
-      this.exitMiniService();
+      if (this.tracking?.isTrackingEnabled()) this.analytics?.exitAllMiniServices();
       this.flushEngagement();
       this.flushAnalytics();
     });
@@ -1691,6 +1885,10 @@ function setupReactNative(sdk2, config, deps = {}) {
   const device = deps.deviceInfo ? collectRnDevice(deps.deviceInfo) : config.device;
   const platform = deps.platform ?? config.platform;
   sdk2.init({ ...config, storage, device, platform });
+  const errorUtils = deps.errorUtils ?? globalThis.ErrorUtils;
+  if (errorUtils && typeof errorUtils.setGlobalHandler === "function") {
+    sdk2.installReactNativeCrashHandler(errorUtils);
+  }
   let subscription;
   if (deps.appState?.addEventListener) {
     subscription = deps.appState.addEventListener("change", (state) => {