@magicfeedback/popup-sdk 1.1.0 → 1.1.1

package/dist/react-native.mjs

@@ -0,0 +1,1675 @@
+import {
+  STORAGE_KEYS,
+  TrackingManager,
+  __require,
+  buildSurveyIdentity,
+  createDefaultStorage
+} from "./chunk-M6PEFLLQ.mjs";
+
+// src/react-native/index.tsx
+import { createContext, useContext, useEffect, useRef, useState } from "react";
+import { AppState, Modal, Platform, View } from "react-native";
+import { WebView } from "react-native-webview";
+
+// src/types/index.ts
+var POPUP_TRIGGER_CONDITION_STATUSES = [
+  "SHOWED",
+  "PARTIAL",
+  "COMPLETED"
+];
+
+// src/triggers/index.ts
+function setupTrigger(popups, trigger) {
+  switch (trigger.type) {
+    case "time":
+      setupTimeTrigger(popups, trigger);
+      break;
+    case "scroll":
+      setupScrollTrigger(popups, trigger);
+      break;
+    case "exit":
+      setupExitTrigger(popups, trigger);
+      break;
+    case "event":
+      setupEventTrigger(popups, trigger);
+      break;
+    case "click":
+      setupClickTrigger(popups, trigger);
+      break;
+  }
+}
+function setupTimeTrigger(popups, trigger) {
+  const delay = trigger.value || 5e3;
+  setTimeout(() => {
+    popups.triggerSurvey(trigger.surveyId, trigger.popupId);
+  }, delay);
+  popups.debug(`Time trigger set for ${delay}ms`);
+}
+function setupScrollTrigger(popups, trigger) {
+  const threshold = trigger.value || 50;
+  const handler = () => {
+    const scrollPercentage = window.scrollY / (document.documentElement.scrollHeight - window.innerHeight) * 100;
+    if (scrollPercentage >= threshold) {
+      popups.triggerSurvey(trigger.surveyId, trigger.popupId);
+      window.removeEventListener("scroll", handler);
+    }
+  };
+  window.addEventListener("scroll", handler);
+  popups.debug(`Scroll trigger set for ${threshold}%`);
+}
+function setupExitTrigger(popups, trigger) {
+  if (typeof window === "undefined") return;
+  const delaySeconds = parseExitDelaySeconds(trigger.value);
+  const historyRef = window.history;
+  const originalPushState = historyRef.pushState.bind(historyRef);
+  const originalReplaceState = historyRef.replaceState.bind(historyRef);
+  let lastUrl = normalizeUrl(window.location.href);
+  let lastQueuedKey = "";
+  let lastQueuedAt = 0;
+  const queueLeave = (fromRaw, toRaw) => {
+    const from = normalizeUrl(fromRaw);
+    const to = normalizeUrl(toRaw);
+    if (!from || !to || from === to) return;
+    const key = `${from}=>${to}`;
+    const now = Date.now();
+    if (key === lastQueuedKey && now - lastQueuedAt < 150) return;
+    lastQueuedKey = key;
+    lastQueuedAt = now;
+    popups.queueExitPopup(trigger.surveyId, delaySeconds, from, trigger.popupId);
+  };
+  const handleNavigation = (to) => {
+    const from = lastUrl;
+    queueLeave(from, to);
+    lastUrl = normalizeUrl(to);
+  };
+  const handleDocumentClick = (event) => {
+    if (event.defaultPrevented) return;
+    if (event.button !== 0) return;
+    if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+    const anchor = event.target?.closest?.("a");
+    if (!(anchor instanceof HTMLAnchorElement)) return;
+    const href = anchor.getAttribute("href");
+    if (!href || href.startsWith("javascript:") || href.startsWith("mailto:") || href.startsWith("tel:")) {
+      return;
+    }
+    const target = anchor.getAttribute("target");
+    if (target && target !== "_self") return;
+    let destination;
+    try {
+      destination = new URL(href, window.location.href);
+    } catch {
+      return;
+    }
+    if (destination.origin !== window.location.origin) return;
+    queueLeave(window.location.href, destination.href);
+  };
+  const handleHashChange = (event) => {
+    const to = event.newURL || window.location.href;
+    const from = event.oldURL || lastUrl;
+    queueLeave(from, to);
+    lastUrl = normalizeUrl(to);
+  };
+  const handlePopState = () => {
+    handleNavigation(window.location.href);
+  };
+  historyRef.pushState = function(data, unused, url) {
+    const from = window.location.href;
+    const result = originalPushState(data, unused, url);
+    queueLeave(from, window.location.href);
+    lastUrl = normalizeUrl(window.location.href);
+    return result;
+  };
+  historyRef.replaceState = function(data, unused, url) {
+    const from = window.location.href;
+    const result = originalReplaceState(data, unused, url);
+    queueLeave(from, window.location.href);
+    lastUrl = normalizeUrl(window.location.href);
+    return result;
+  };
+  document.addEventListener("click", handleDocumentClick, true);
+  window.addEventListener("hashchange", handleHashChange);
+  window.addEventListener("popstate", handlePopState);
+  popups.debug("Exit trigger set (deferred to next route)", {
+    surveyId: trigger.surveyId,
+    delaySeconds
+  });
+}
+function setupEventTrigger(popups, trigger) {
+  popups.debug("Event trigger registered", {
+    popupId: trigger.popupId,
+    surveyId: trigger.surveyId,
+    eventName: String(trigger.value || "")
+  });
+}
+function parseExitDelaySeconds(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Math.max(0, value);
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return Math.max(0, parsed);
+  }
+  return 0;
+}
+function normalizeUrl(value) {
+  if (!value) return "";
+  const withoutIndex = value.replace(/\/index\.html(?=($|[?#]))/i, "");
+  return withoutIndex.length > 1 && withoutIndex.endsWith("/") ? withoutIndex.slice(0, -1) : withoutIndex;
+}
+function setupClickTrigger(popups, trigger) {
+  const targetId = typeof trigger.value === "string" ? trigger.value : "";
+  if (!targetId) {
+    popups.debug("Click trigger missing element id", trigger);
+    return;
+  }
+  const attach = () => {
+    const el = document.getElementById(targetId);
+    if (!el) {
+      popups.debug("Click trigger target not found", targetId);
+      return false;
+    }
+    const handler = (e) => {
+      if (e.defaultPrevented) return;
+      popups.triggerSurvey(trigger.surveyId, trigger.popupId);
+      el.removeEventListener("click", handler);
+    };
+    el.addEventListener("click", handler);
+    popups.debug(`Click trigger set for #${targetId}`);
+    return true;
+  };
+  if (typeof document === "undefined") return;
+  if (attach()) return;
+  window.addEventListener("DOMContentLoaded", () => attach(), { once: true });
+}
+
+// src/config/env.ts
+var ENVIRONMENT_MAP = {
+  development: {
+    apiBaseUrl: "https://api-dev.deepdots.com"
+  },
+  production: {
+    apiBaseUrl: "https://api.deepdots.com"
+  }
+};
+function resolveEnvironment(nodeEnv) {
+  return ENVIRONMENT_MAP[nodeEnv || "production"];
+}
+
+// src/ui/surveyHtml.ts
+function buildSurveyHtml(opts) {
+  const env = opts.env === "development" ? "dev" : "prod";
+  const version = opts.version ?? "2.2.4";
+  const cdn = `https://cdn.jsdelivr.net/npm/@magicfeedback/native@${version}/dist/magicfeedback-sdk.browser.js`;
+  const sid = JSON.stringify(opts.surveyId);
+  const pid = JSON.stringify(opts.productId);
+  const profileJson = JSON.stringify(opts.profile ?? []);
+  const metaJson = JSON.stringify(opts.metadata ?? []);
+  return `<!DOCTYPE html><html><head>
+<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+<meta name="color-scheme" content="light"/>
+<style>html,body{margin:0;padding:0;background:transparent;font-family:-apple-system,system-ui,sans-serif}#mf{width:100%;box-sizing:border-box}#mf *{max-width:100%;box-sizing:border-box}</style>
+</head><body>
+<div id="mf"></div>
+<script>
+(function(){
+  function emit(s){ try{ if(window.ReactNativeWebView){ window.ReactNativeWebView.postMessage(s); } }catch(e){} }
+  function emitJSON(n,p){ try{ emit(JSON.stringify({name:n,payload:p||{}})); }catch(e){} }
+  window.DeepdotsClose = function(){ emitJSON('popup_close'); };
+  var initialized=false;
+  function initMF(){
+    if(initialized || !window.magicfeedback) return initialized;
+    initialized=true;
+    try{
+      window.magicfeedback.init({ debug:false, env:'${env}' });
+      var form = window.magicfeedback.form(${sid}, ${pid}, ${profileJson}, ${metaJson});
+      window.DeepdotsForm = form;
+      form.generate('mf', {
+        addButton:false,
+        getMetaData:true,
+        onLoadedEvent:function(){ emitJSON('loaded'); },
+        beforeSubmitEvent:function(){ emitJSON('before_submit'); },
+        afterSubmitEvent:function(p){
+          try{ if(p && p.completed){ emitJSON('survey_completed', p); } else { emitJSON('after_submit', p); } }
+          catch(e){ emitJSON('after_submit'); }
+        },
+        onBackEvent:function(p){ emitJSON('back', p); }
+      }).catch(function(e){ emit('error:init'); });
+    }catch(e){ emit('error:exception'); }
+    return true;
+  }
+  var s=document.createElement('script'); s.src=${JSON.stringify(cdn)}; s.async=true;
+  s.onload=function(){ initMF(); };
+  s.onerror=function(){ emit('error:load'); };
+  document.head.appendChild(s);
+  var tries=0, t=setInterval(function(){ if(initMF()||++tries>40){ clearInterval(t); } },150);
+})();
+</script>
+</body></html>`;
+}
+
+// src/platform/react-native-renderer.ts
+var ReactNativePopupRenderer = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.emitFn = null;
+    this.onCloseFn = null;
+    this.currentSurveyId = null;
+    this.partialEmitted = false;
+  }
+  init() {
+  }
+  show(surveyId, productId, _actions, emit, onClose, env = "production", userId, _style, sessionId, miniService) {
+    this.emitFn = emit;
+    this.onCloseFn = onClose;
+    this.currentSurveyId = surveyId;
+    this.partialEmitted = false;
+    const { profile, metadata } = buildSurveyIdentity(userId ?? null, sessionId ?? null, miniService ?? null);
+    const html = buildSurveyHtml({ surveyId, productId, env, profile, metadata });
+    if (this.options.onShow) {
+      this.options.onShow({ surveyId, productId, html });
+    } else {
+      console.warn(
+        "[Deepdots] ReactNativePopupRenderer sin onShow: pasa { onShow } a new ReactNativePopupRenderer({...}) para montar el WebView del survey."
+      );
+    }
+  }
+  hide() {
+    this.options.onHide?.();
+    this.currentSurveyId = null;
+  }
+  /**
+   * El host la conecta al `onMessage` del WebView. Traduce los mensajes del survey a
+   * eventos del SDK: primera interacción → `popup_clicked` (PARTIAL), completado →
+   * `survey_completed` (COMPLETED) y cierra el popup.
+   */
+  handleMessage(raw) {
+    const surveyId = this.currentSurveyId;
+    if (!surveyId || !this.emitFn) return;
+    let name;
+    try {
+      name = JSON.parse(raw).name;
+    } catch {
+      name = raw;
+    }
+    switch (name) {
+      case "loaded":
+      case "before_submit":
+      case "after_submit":
+      case "back":
+        if (!this.partialEmitted) {
+          this.partialEmitted = true;
+          this.emitFn("popup_clicked", surveyId, { action: "partial" });
+        }
+        break;
+      case "survey_completed":
+        this.emitFn("survey_completed", surveyId);
+        this.onCloseFn?.();
+        break;
+      case "popup_close":
+        this.onCloseFn?.();
+        break;
+      default:
+        break;
+    }
+  }
+};
+function isReactNativeEnv() {
+  return typeof navigator !== "undefined" && navigator.product === "ReactNative";
+}
+function createReactNativeRenderer() {
+  return new ReactNativePopupRenderer();
+}
+
+// src/platform/renderer.ts
+var NoopPopupRenderer = class {
+  show() {
+  }
+  hide() {
+  }
+};
+var BrowserPopupRenderer = class {
+  constructor() {
+    this.container = null;
+    this.visible = false;
+  }
+  init() {
+    if (typeof document === "undefined") return;
+    if (!this.container) {
+      this.container = document.createElement("div");
+      this.container.id = "deepdots-popup-container";
+      this.container.style.cssText = `
+          position: fixed;
+          top: 0;
+          left: 0;
+          width: 100%;
+          height: 100%;
+          display: none;
+          z-index: 999999;
+          background: rgba(0, 0, 0, 0.5);
+          justify-content: center;
+          align-items: center;
+        `;
+    }
+    if (!document.body.contains(this.container)) {
+      document.body.appendChild(this.container);
+    }
+  }
+  show(surveyId, productId, actions, emit, onClose, env = "production", userId, style, sessionId, miniService) {
+    if (this.visible) return;
+    if (!this.container || !document.body.contains(this.container)) this.init();
+    if (!this.container) return;
+    this.visible = true;
+    const container = this.container;
+    void import("./renderPopup-7GGKR5BY.mjs").then(({ renderPopup }) => {
+      renderPopup(container, surveyId, productId, actions, emit, onClose, env, userId, style, sessionId, miniService);
+    });
+  }
+  hide() {
+    this.visible = false;
+    if (this.container) {
+      this.container.style.display = "none";
+      this.container.innerHTML = "";
+    }
+  }
+};
+function createDefaultRenderer() {
+  if (typeof document === "undefined") {
+    if (isReactNativeEnv()) return createReactNativeRenderer();
+    return new NoopPopupRenderer();
+  }
+  if (isReactNativeEnv()) return createReactNativeRenderer();
+  return new BrowserPopupRenderer();
+}
+
+// src/analytics/analytics-manager.ts
+var dryRunSink = (payload) => {
+  console.log(
+    "[DeepdotsAnalytics] (dry-run \xB7 NO enviado \xB7 sin init.analytics) POST /sdk/feedback \u2192",
+    JSON.stringify(payload, null, 2)
+  );
+};
+var AnalyticsManager = class {
+  constructor(options = {}) {
+    this.events = [];
+    this.attributes = {};
+    this.miniService = null;
+    this.miniServiceEnteredAt = 0;
+    this.sink = options.sink ?? dryRunSink;
+    this.now = options.now ?? (() => Date.now());
+    this.publicKey = options.publicKey;
+    this.language = options.language;
+    this.device = options.device;
+    this.platform = options.platform ?? "web";
+  }
+  /** Mezcla user attributes (se coercionan a string). Mutable en runtime. */
+  setUserAttributes(attrs) {
+    for (const [k, v] of Object.entries(attrs)) {
+      if (!k) continue;
+      this.attributes[k] = String(v);
+    }
+  }
+  /** Marca el inicio de un mini-service; etiqueta los eventos siguientes con `mini_service`. */
+  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 });
+  }
+  /** Registra un evento de analítica (modelo GA: nombre + params). */
+  track(name, params) {
+    const merged = {
+      ...this.miniService ? { mini_service: this.miniService } : {},
+      ...params ?? {}
+    };
+    this.events.push({
+      name,
+      timestamp: this.now(),
+      params: Object.keys(merged).length ? merged : void 0
+    });
+  }
+  /** Mini-service activo (para inyectarlo en la metadata del survey, #33). */
+  getMiniService() {
+    return this.miniService;
+  }
+  /** Nº de eventos pendientes de flush. */
+  pending() {
+    return this.events.length;
+  }
+  /** Construye el envelope que se enviaría al endpoint de analytics. */
+  buildPayload(identity) {
+    return {
+      publicKey: this.publicKey,
+      userId: identity.userId,
+      sessionId: identity.sessionId,
+      context: {
+        platform: this.platform,
+        language: this.language,
+        device: this.device,
+        attributes: { ...this.attributes }
+      },
+      events: [...this.events]
+    };
+  }
+  /** Envía (vía sink) el lote acumulado y vacía el buffer. No-op si no hay eventos. */
+  flush(identity) {
+    if (this.events.length === 0) return null;
+    const payload = this.buildPayload(identity);
+    this.sink(payload);
+    this.events = [];
+    return payload;
+  }
+};
+
+// src/analytics/feedback-payload.ts
+function pushKV(list, key, value) {
+  if (value === void 0 || value === null || value === "") return;
+  list.push({ key, value: String(value) });
+}
+function buildAnalyticsFeedbackBody(envelope, keys, feedbackSessionId) {
+  const { context } = envelope;
+  const metrics = envelope.events.map((e) => ({
+    key: e.name,
+    value: JSON.stringify({ timestamp: e.timestamp, ...e.params ?? {} })
+  }));
+  const profile = [];
+  pushKV(profile, "external-user-id", envelope.userId);
+  const metadata = [];
+  pushKV(metadata, "user_id", envelope.userId);
+  pushKV(metadata, "session_id", envelope.sessionId);
+  pushKV(metadata, "platform", context.platform);
+  pushKV(metadata, "language", context.language);
+  if (context.device) {
+    pushKV(metadata, "device_type", context.device.device_type);
+    pushKV(metadata, "os_version", context.device.os_version);
+    pushKV(metadata, "device_model", context.device.device_model);
+    pushKV(metadata, "app_version", context.device.app_version);
+    pushKV(metadata, "user_agent", context.device.user_agent);
+  }
+  for (const [k, v] of Object.entries(context.attributes ?? {})) {
+    pushKV(metadata, k, v);
+  }
+  return {
+    feedback: {
+      text: "",
+      answers: [],
+      metadata,
+      metrics,
+      profile,
+      finished: false
+    },
+    publicKey: keys.publicKey,
+    integration: keys.integration,
+    completed: false,
+    // finished: false,
+    ...feedbackSessionId ? { sessionId: feedbackSessionId } : {}
+  };
+}
+function createFeedbackSink(options) {
+  let feedbackSessionId;
+  return (envelope) => {
+    const body = buildAnalyticsFeedbackBody(envelope, options.keys, feedbackSessionId);
+    const f = options.fetchImpl ?? (typeof fetch !== "undefined" ? fetch : void 0);
+    if (!f) {
+      options.log?.("[DeepdotsAnalytics] no fetch disponible; payload no enviado", body);
+      return;
+    }
+    options.log?.("[DeepdotsAnalytics] POST /sdk/feedback \u2192", body);
+    f(`${options.baseUrl}/sdk/feedback`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    }).then(async (res) => {
+      if (res.ok) {
+        try {
+          const data = await res.json();
+          if (data?.sessionId && data.sessionId !== feedbackSessionId) {
+            feedbackSessionId = data.sessionId;
+            options.log?.("[DeepdotsAnalytics] feedbackSessionId cacheado:", feedbackSessionId);
+          }
+        } catch {
+        }
+      }
+    }).catch((err) => options.log?.("[DeepdotsAnalytics] error enviando feedback", err));
+  };
+}
+
+// src/tracking/navigation-observer.ts
+var UUID_PREFIX = /^[0-9a-f]{8}-[0-9a-f]{4}-/i;
+function normalizeScreen(href) {
+  let pathAndHash;
+  try {
+    const u = new URL(href, "http://deepdots.local");
+    pathAndHash = u.pathname + (u.hash || "");
+  } catch {
+    pathAndHash = href;
+  }
+  pathAndHash = pathAndHash.replace(/\?[^#]*/g, "");
+  const collapsed = pathAndHash.split("/").map((seg) => /^[0-9]+$/.test(seg) || UUID_PREFIX.test(seg) ? ":id" : seg).join("/");
+  return collapsed || "/";
+}
+var NavigationObserver = class {
+  constructor(options = {}) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.currentScreen = null;
+    this.entryAt = 0;
+    this.installed = false;
+    this.domHandlers = [];
+    this.now = options.now ?? (() => Date.now());
+  }
+  onVisit(listener) {
+    this.listeners.add(listener);
+  }
+  /** Fija la pantalla inicial (sin emitir visita; su duración se cierra al salir). */
+  begin(href) {
+    this.currentScreen = normalizeScreen(href);
+    this.entryAt = this.now();
+  }
+  /** Navega a una pantalla nueva: cierra la anterior (emite visita) y abre la nueva. */
+  visit(href) {
+    const next = normalizeScreen(href);
+    if (next === this.currentScreen) return;
+    this.closeCurrent();
+    this.currentScreen = next;
+    this.entryAt = this.now();
+  }
+  /** Cierra la pantalla actual emitiendo su visita (p. ej. al cerrar la app/pestaña). */
+  stop() {
+    this.closeCurrent();
+    this.currentScreen = null;
+  }
+  closeCurrent() {
+    if (this.currentScreen == null) return;
+    const exit = this.now();
+    const visit = {
+      screen: this.currentScreen,
+      entry: this.entryAt,
+      exit,
+      durationSeconds: Math.max(0, Math.round((exit - this.entryAt) / 1e3))
+    };
+    this.listeners.forEach((l) => {
+      try {
+        l(visit);
+      } catch {
+      }
+    });
+  }
+  /** Instala los hooks de History en el navegador y registra la pantalla actual. */
+  install() {
+    if (this.installed || typeof window === "undefined" || typeof history === "undefined") return;
+    this.installed = true;
+    const handle = () => this.visit(window.location.href);
+    const originalPush = history.pushState.bind(history);
+    const originalReplace = history.replaceState.bind(history);
+    history.pushState = (data, unused, url) => {
+      const r = originalPush(data, unused, url);
+      handle();
+      return r;
+    };
+    history.replaceState = (data, unused, url) => {
+      const r = originalReplace(data, unused, url);
+      handle();
+      return r;
+    };
+    window.addEventListener("popstate", handle);
+    window.addEventListener("hashchange", handle);
+    this.domHandlers.push(() => {
+      history.pushState = originalPush;
+      history.replaceState = originalReplace;
+      window.removeEventListener("popstate", handle);
+      window.removeEventListener("hashchange", handle);
+    });
+    this.begin(window.location.href);
+  }
+  uninstall() {
+    this.domHandlers.forEach((off) => off());
+    this.domHandlers = [];
+    this.installed = false;
+  }
+};
+
+// src/analytics/device-info.ts
+function parseDeviceType(ua) {
+  const s = (ua || "").toLowerCase();
+  if (/ipad|tablet|playbook|silk/.test(s) || /android/.test(s) && !/mobile/.test(s)) {
+    return "tablet";
+  }
+  if (/mobi|iphone|ipod|windows phone/.test(s) || /android/.test(s) && /mobile/.test(s)) {
+    return "mobile";
+  }
+  return "desktop";
+}
+function collectDeviceInfo(appVersion) {
+  const ua = typeof navigator !== "undefined" ? navigator.userAgent : "";
+  return {
+    device_type: parseDeviceType(ua),
+    user_agent: ua || void 0,
+    app_version: appVersion
+  };
+}
+
+// src/analytics/engagement-tracker.ts
+var EngagementTracker = class {
+  constructor(now = () => Date.now()) {
+    this.activeMs = 0;
+    this.lastResumeAt = null;
+    this.now = now;
+  }
+  /** Reanuda el conteo (pestaña visible / app en foreground). Idempotente. */
+  resume() {
+    if (this.lastResumeAt === null) this.lastResumeAt = this.now();
+  }
+  /** Pausa el conteo (pestaña oculta / app en background), acumulando el tramo activo. */
+  pause() {
+    if (this.lastResumeAt !== null) {
+      this.activeMs += this.now() - this.lastResumeAt;
+      this.lastResumeAt = null;
+    }
+  }
+  /** Devuelve los ms activos acumulados desde la última lectura y reinicia (sin parar el timer). */
+  consume() {
+    if (this.lastResumeAt !== null) {
+      const t = this.now();
+      this.activeMs += t - this.lastResumeAt;
+      this.lastResumeAt = t;
+    }
+    const ms = this.activeMs;
+    this.activeMs = 0;
+    return ms;
+  }
+  isActive() {
+    return this.lastResumeAt !== null;
+  }
+};
+
+// src/contact/contact-manager.ts
+function stableSerialize(attrs) {
+  const sorted = {};
+  for (const key of Object.keys(attrs).sort()) {
+    sorted[key] = attrs[key];
+  }
+  return JSON.stringify(sorted);
+}
+var ContactManager = class {
+  constructor(options) {
+    this.storage = options.storage;
+    this.publicKey = options.publicKey;
+    this.userId = options.userId;
+    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.
+   */
+  async setAttributes(attributes) {
+    const serialized = stableSerialize(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
+    });
+    this.storage.setItem(STORAGE_KEYS.contactAttributes, serialized);
+    return true;
+  }
+};
+
+// src/core/deepdots-popups.ts
+var EXIT_QUEUE_STORAGE_KEY = "__deepdots_exit_popup_queue__";
+var DAY_IN_MS = 24 * 60 * 60 * 1e3;
+var DeepdotsPopups = class {
+  constructor() {
+    this.config = null;
+    this.listeners = /* @__PURE__ */ new Map();
+    this.triggers = [];
+    this.initialized = false;
+    this.renderer = createDefaultRenderer();
+    this.popupContainer = null;
+    // deprecated: mantenido para compatibilidad interna
+    this.popupDefinitions = [];
+    this.popupsLoaded = false;
+    this.pendingAutoLaunch = false;
+    this.answeredSurveys = /* @__PURE__ */ new Set();
+    this.surveyProgress = /* @__PURE__ */ new Map();
+    this.lastShown = /* @__PURE__ */ new Map();
+    // popupId -> timestamp mostrado
+    this.surveyToPopupId = /* @__PURE__ */ new Map();
+    // surveyId -> popupId
+    this.deferredExitTimers = [];
+    this.baseUrl = "";
+    this.env = "production";
+    /** Identidad + sesión (Fase 1 tracking). Null hasta init(). */
+    this.tracking = null;
+    /** Capa de analytics (canal separado del feedback). Null hasta init(). */
+    this.analytics = null;
+    /** Observador de navegación (Fase 2): emite page_view por el canal de analytics. */
+    this.navObserver = null;
+    /** Tiempo activo (engagement time, #8). */
+    this.engagement = null;
+    /** Atributos internos del usuario identificado → POST /sdk/popups/contact. Null si no hay userId. */
+    this.contact = null;
+    /** Marca si ya se inició la navegación manual (setScreen) — para RN sin History API. */
+    this.navStarted = false;
+  }
+  /** Initialize the SDK with configuration */
+  init(config) {
+    if (this.initialized) {
+      this.log("SDK already initialized");
+      return;
+    }
+    const env = resolveEnvironment(config.nodeEnv);
+    this.baseUrl = env.apiBaseUrl;
+    this.env = config.nodeEnv || "production";
+    this.config = {
+      apiKey: config.apiKey || void 0,
+      debug: config.debug || false,
+      userId: config.userId || void 0
+    };
+    const storage = config.storage ?? createDefaultStorage();
+    this.tracking = new TrackingManager({
+      storage,
+      clientUserId: this.config.userId,
+      enabled: config.trackingEnabled ?? true
+    });
+    if (this.config.userId) {
+      const userId = this.config.userId;
+      const publicKey = this.config.apiKey ?? "";
+      this.contact = new ContactManager({
+        storage,
+        publicKey,
+        userId,
+        post: (body) => this.postContact(body)
+      });
+      if (config.contactAttributes) {
+        void this.setContactAttributes(config.contactAttributes);
+      }
+    }
+    this.log("tracking \xB7 user_id:", this.tracking.getUserId(), "\xB7 new_user:", this.tracking.isNewUser(), "\xB7 enabled:", this.tracking.isTrackingEnabled());
+    const analyticsSink = config.analytics ? createFeedbackSink({
+      baseUrl: this.baseUrl,
+      keys: config.analytics,
+      log: (...a) => this.log(...a)
+    }) : void 0;
+    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)
+    });
+    this.navObserver = new NavigationObserver();
+    this.navObserver.onVisit((v) => this.track("page_view", { screen: v.screen, duration_seconds: v.durationSeconds }));
+    this.navObserver.install();
+    this.engagement = new EngagementTracker();
+    this.engagement.resume();
+    this.setupAnalyticsFlush();
+    this.initialized = true;
+    this.log("SDK initialized", this.config);
+    if (this.renderer.init) this.renderer.init();
+    this.setupPopupContainer();
+    this.fetchPopupsFromServer().then((defs) => {
+      this.popupDefinitions = this.validatePopupDefinitions(defs);
+      this.popupsLoaded = true;
+      this.log("Popups loaded from API", this.popupDefinitions);
+      this.configureTriggersFromDefinitions();
+      this.processDeferredExitQueue();
+      if (this.pendingAutoLaunch) {
+        this.startTriggers();
+      }
+    });
+  }
+  /** User id actual (generado por el SDK o provisto por el cliente). Null si tracking off. */
+  getUserId() {
+    return this.tracking?.getUserId() ?? null;
+  }
+  /** Session id de navegación actual. Null si tracking off. */
+  getSessionId() {
+    return this.tracking?.getSessionId() ?? null;
+  }
+  /** Activa/desactiva el tracking (identidad + sesión + analytics). Kill-switch del contrato §7bis. */
+  setTrackingEnabled(enabled) {
+    this.tracking?.setTrackingEnabled(enabled);
+    this.log("tracking \xB7 setTrackingEnabled:", enabled, "\xB7 session_id:", this.tracking?.getSessionId() ?? null);
+  }
+  // ───────── Analytics (canal separado del feedback, vinculado por user_id) ─────────
+  /** 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 ?? {});
+  }
+  /** User attributes para breakdowns (registration_status, pass_type, sector, pass_status…). */
+  setUserAttributes(attributes) {
+    if (!this.tracking?.isTrackingEnabled()) return;
+    this.analytics?.setUserAttributes(attributes);
+  }
+  /**
+   * 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
+   * init. Solo envía si los atributos cambiaron (diff en storage). No-op si tracking off o sin userId.
+   * @returns `true` si se envió al backend, `false` si no hubo cambios o está deshabilitado.
+   */
+  async setContactAttributes(attributes) {
+    if (!this.tracking?.isTrackingEnabled()) return false;
+    if (!this.contact) return false;
+    return this.contact.setAttributes(attributes);
+  }
+  /** Marca el inicio de un mini-service; etiqueta los eventos siguientes. No-op si tracking off. */
+  enterMiniService(name, entryPointType) {
+    if (!this.tracking?.isTrackingEnabled()) return;
+    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() {
+    if (!this.tracking?.isTrackingEnabled()) return;
+    this.analytics?.exitMiniService();
+    this.log("analytics \xB7 exitMiniService");
+  }
+  /** 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 ?? {} });
+  }
+  /** Findability friction (#34/#35): señal de fricción con su `friction_topic`. */
+  trackFindabilityFriction(frictionTopic, params) {
+    this.track("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 ?? {} });
+  }
+  /**
+   * Navegación MANUAL (entornos sin History API, p. ej. React Native con React Navigation).
+   * El host la llama en cada cambio de pantalla; emite `page_view` al salir de la anterior.
+   */
+  setScreen(name) {
+    if (!this.navObserver) return;
+    if (!this.navStarted) {
+      this.navObserver.begin(name);
+      this.navStarted = true;
+    } else {
+      this.navObserver.visit(name);
+    }
+  }
+  /** App a foreground (RN: AppState 'active'): reanuda el engagement time. */
+  onForeground() {
+    this.engagement?.resume();
+  }
+  /**
+   * App a background (RN: AppState 'background'): cierra pantalla actual (page_view),
+   * mini-service (mini_service_exit), emite engagement y hace flush del lote.
+   */
+  onBackground() {
+    this.navObserver?.stop();
+    this.navStarted = false;
+    this.exitMiniService();
+    this.flushEngagement();
+    this.engagement?.pause();
+    this.flushAnalytics();
+  }
+  /** Payload que se ENVIARÍA al endpoint de analytics (no envía ni vacía el buffer). */
+  previewAnalytics() {
+    return this.analytics?.buildPayload(this.analyticsIdentity()) ?? {
+      userId: null,
+      sessionId: null,
+      context: { platform: "web", attributes: {} },
+      events: []
+    };
+  }
+  /** Envía (hoy dry-run → console.log) el lote acumulado de analytics y vacía el buffer. */
+  flushAnalytics() {
+    if (!this.tracking?.isTrackingEnabled()) return;
+    this.analytics?.flush(this.analyticsIdentity());
+  }
+  /** Emite un evento `user_engagement` con el tiempo activo acumulado (#8). */
+  flushEngagement() {
+    if (!this.tracking?.isTrackingEnabled()) return;
+    const ms = this.engagement?.consume() ?? 0;
+    if (ms > 0) this.track("user_engagement", { engagement_time_msec: ms });
+  }
+  analyticsIdentity() {
+    return {
+      userId: this.tracking?.getUserId() ?? null,
+      sessionId: this.tracking?.getSessionId() ?? null
+    };
+  }
+  /** Flush automático al ocultar/cerrar la página (no perder el lote pendiente). */
+  setupAnalyticsFlush() {
+    if (typeof document === "undefined" || typeof window === "undefined") return;
+    window.addEventListener("pagehide", () => {
+      this.navObserver?.stop();
+      this.exitMiniService();
+      this.flushEngagement();
+      this.flushAnalytics();
+    });
+    document.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "hidden") {
+        this.flushEngagement();
+        this.engagement?.pause();
+        this.flushAnalytics();
+      } else if (document.visibilityState === "visible") {
+        this.engagement?.resume();
+      }
+    });
+  }
+  /** Enable auto-launch functionality with configured triggers */
+  autoLaunch() {
+    if (!this.initialized) {
+      throw new Error("SDK not initialized. Call init() first.");
+    }
+    if (!this.popupsLoaded) {
+      this.pendingAutoLaunch = true;
+      this.log("Auto-launch deferred until popups are loaded");
+      return;
+    }
+    this.startTriggers();
+  }
+  /** Inicia los triggers configurados */
+  startTriggers() {
+    this.log("Auto-launch enabled");
+    this.triggers.forEach((trigger) => setupTrigger(this, trigger));
+  }
+  /** Configure triggers for auto-launching popups (manual) */
+  configureTriggers(triggers) {
+    if (!this.initialized) {
+      throw new Error("SDK not initialized. Call init() first.");
+    }
+    this.triggers = triggers;
+    this.log("Triggers configured", triggers);
+  }
+  /** Deriva triggers desde las definiciones de popup */
+  configureTriggersFromDefinitions() {
+    const derived = [];
+    this.debug("Validated popup definitions", this.popupDefinitions);
+    this.popupDefinitions.forEach((def) => {
+      def.triggers.forEach((trigger) => {
+        const type = this.mapPopupTriggerType(trigger.type);
+        if (!type) {
+          this.debug("Unsupported trigger type", trigger.type);
+          return;
+        }
+        const value = type === "time" && typeof trigger.value === "number" ? trigger.value * 1e3 : trigger.value;
+        derived.push({ type, value, surveyId: def.surveyId, popupId: def.id });
+      });
+    });
+    if (derived.length) {
+      this.configureTriggers(derived);
+    }
+  }
+  /** Lógica para evaluar condiciones antes de mostrar una encuesta */
+  triggerSurvey(surveyId, popupId) {
+    const def = this.findPopupDefinition(surveyId, popupId);
+    if (!def) {
+      this.debug("No popup definition for trigger", { surveyId, popupId });
+      return;
+    }
+    if (!this.shouldShow(def)) {
+      this.debug("Conditions prevented showing popup", def.id);
+      return;
+    }
+    this.showDefinition(def);
+  }
+  /** Trigger popups configured with trigger.type = 'event' and matching trigger.value */
+  triggerEvent(eventName) {
+    if (!this.initialized) {
+      throw new Error("SDK not initialized. Call init() first.");
+    }
+    const normalized = String(eventName || "").trim();
+    if (!normalized) {
+      this.debug("Ignoring empty event trigger name");
+      return;
+    }
+    const candidates = this.popupDefinitions.filter((def) => {
+      return def.triggers.some((trigger) => {
+        const triggerValue = String(trigger.value ?? "").trim();
+        return trigger.type === "event" && triggerValue === normalized;
+      });
+    });
+    if (!candidates.length) {
+      this.debug("No event popup definitions found", { eventName: normalized });
+      return;
+    }
+    const matched = candidates.find((def) => this.shouldShow(def));
+    if (!matched) {
+      this.debug("Event popup blocked by conditions/segments", { eventName: normalized });
+      return;
+    }
+    this.showDefinition(matched);
+  }
+  showDefinition(def) {
+    this.log("Showing popup (definition)", def);
+    this.surveyToPopupId.set(def.surveyId, def.id);
+    this.lastShown.set(def.id, Date.now());
+    this.renderPopup(def.surveyId, def.productId, def.actions, def.style);
+    this.emitEvent("popup_shown", def.surveyId, { popupId: def.id });
+  }
+  shouldShow(def, pathUrl, skipPathCheck = false) {
+    if (!skipPathCheck && !this.matchesSegmentsPath(def, pathUrl)) {
+      return false;
+    }
+    if (!this.matchesSegmentsLang(def)) {
+      return false;
+    }
+    const cooldowns = def.cooldown || [];
+    if (cooldowns.length && !cooldowns.every((cooldown) => this.evaluateCooldown(def, cooldown))) {
+      return false;
+    }
+    const legacyConditions = def.legacyConditions || [];
+    if (!legacyConditions.length) return true;
+    return legacyConditions.every((condition) => this.evaluateLegacyCondition(def, condition));
+  }
+  matchesSegmentsLang(def) {
+    const langs = def.segments?.lang;
+    if (!langs || langs.length === 0) return true;
+    const browserLang = (typeof navigator !== "undefined" ? navigator.language : "").toLowerCase();
+    if (!browserLang) {
+      this.debug("No navigator.language available for lang comparison", { popupId: def.id, langs });
+      return true;
+    }
+    const matches = langs.some((lang) => browserLang.startsWith(lang.toLowerCase()));
+    if (!matches) {
+      this.debug("Lang mismatch for popup", { popupId: def.id, langs, browserLang });
+    }
+    return matches;
+  }
+  matchesSegmentsPath(def, pathUrl) {
+    const paths = def.segments?.path;
+    if (!paths || paths.length === 0) return true;
+    if (typeof window === "undefined" || !window.location) {
+      this.debug("No window.location available for path comparison", { popupId: def.id, paths });
+      return true;
+    }
+    const normalizedHref = this.normalizeUrl(pathUrl || window.location.href || "");
+    const currentUrl = this.safeParseUrl(normalizedHref);
+    const normalizedPath = this.normalizeUrl(currentUrl?.pathname || window.location.pathname || "");
+    const matches = paths.some((rawCandidate) => {
+      const candidate = this.normalizeUrl(rawCandidate);
+      let match = false;
+      if (candidate.startsWith("http://") || candidate.startsWith("https://")) {
+        match = normalizedHref === candidate;
+      } else if (candidate.startsWith("/")) {
+        match = normalizedHref.includes(candidate);
+      } else {
+        match = normalizedPath === candidate;
+      }
+      this.debug("Path comparison", {
+        popupId: def.id,
+        candidate,
+        currentPath: normalizedPath,
+        currentHref: normalizedHref,
+        match
+      });
+      return match;
+    });
+    if (!matches) {
+      this.debug("No path match for popup", { popupId: def.id, paths, currentPath: normalizedPath });
+    }
+    return matches;
+  }
+  evaluateCooldown(def, condition) {
+    switch (condition.answered) {
+      case "SHOWED":
+        return this.hasCooldownElapsed(this.lastShown.get(def.id), condition.cooldownDays);
+      case "PARTIAL":
+      case "COMPLETED": {
+        const progress = this.surveyProgress.get(def.surveyId);
+        if (!progress || progress.status !== condition.answered) {
+          return true;
+        }
+        return this.hasCooldownElapsed(progress.timestamp, condition.cooldownDays);
+      }
+      default:
+        return true;
+    }
+  }
+  evaluateLegacyCondition(def, condition) {
+    if (!condition.answered && this.answeredSurveys.has(def.surveyId)) {
+      return false;
+    }
+    return this.hasCooldownElapsed(this.lastShown.get(def.id), condition.cooldownDays);
+  }
+  hasCooldownElapsed(timestamp, cooldownDays) {
+    if (!timestamp || !cooldownDays) {
+      return true;
+    }
+    return Date.now() - timestamp >= cooldownDays * DAY_IN_MS;
+  }
+  /** Marcar encuesta como contestada externamente */
+  markSurveyAnswered(surveyId) {
+    this.answeredSurveys.add(surveyId);
+    this.markSurveyProgress(surveyId, "COMPLETED");
+  }
+  /** Queue an exit popup so it can render after navigation */
+  queueExitPopup(surveyId, delaySeconds, sourceUrl, popupId) {
+    const def = this.findPopupDefinition(surveyId, popupId);
+    if (!def) {
+      this.debug("No popup definition for exit trigger", { surveyId, popupId });
+      return;
+    }
+    const originUrl = sourceUrl || (typeof window !== "undefined" ? window.location.href : "");
+    if (!originUrl) {
+      this.debug("Exit popup skipped: missing source URL", { surveyId });
+      return;
+    }
+    if (!this.shouldShow(def, originUrl)) {
+      this.debug("Exit popup skipped by conditions/path", { popupId: def.id, sourceUrl: originUrl });
+      return;
+    }
+    const safeDelayMs = Number.isFinite(delaySeconds) ? Math.max(0, delaySeconds * 1e3) : 0;
+    const deferred = {
+      id: def.id,
+      surveyId: def.surveyId,
+      sourceUrl: this.normalizeUrl(originUrl),
+      dueAt: Date.now() + safeDelayMs
+    };
+    const queue = this.getDeferredExitQueue().filter((item) => !(item.id === deferred.id && item.sourceUrl === deferred.sourceUrl));
+    queue.push(deferred);
+    this.setDeferredExitQueue(queue);
+    this.scheduleDeferredExitPopup(deferred);
+    this.debug("Exit popup queued", deferred);
+  }
+  processDeferredExitQueue() {
+    const queue = this.getDeferredExitQueue();
+    if (!queue.length) return;
+    const pending = [];
+    const now = Date.now();
+    queue.forEach((item) => {
+      const def = this.popupDefinitions.find((popup) => popup.id === item.id && popup.surveyId === item.surveyId);
+      if (!def) {
+        return;
+      }
+      if (item.dueAt <= now) {
+        this.tryShowDeferredExitPopup(item);
+        return;
+      }
+      pending.push(item);
+      this.scheduleDeferredExitPopup(item);
+    });
+    this.setDeferredExitQueue(pending);
+  }
+  scheduleDeferredExitPopup(item) {
+    if (typeof window === "undefined") return;
+    const delay = Math.max(0, item.dueAt - Date.now());
+    const timer = window.setTimeout(() => this.tryShowDeferredExitPopup(item), delay);
+    this.deferredExitTimers.push(timer);
+  }
+  tryShowDeferredExitPopup(item) {
+    const def = this.popupDefinitions.find((popup) => popup.id === item.id && popup.surveyId === item.surveyId);
+    if (!def) {
+      this.removeDeferredExitPopup(item);
+      return;
+    }
+    const currentUrl = typeof window !== "undefined" ? this.normalizeUrl(window.location.href || "") : "";
+    if (!currentUrl || currentUrl === this.normalizeUrl(item.sourceUrl)) {
+      this.removeDeferredExitPopup(item);
+      this.debug("Exit popup dropped because route did not change", item);
+      return;
+    }
+    if (!this.shouldShow(def, void 0, true)) {
+      this.removeDeferredExitPopup(item);
+      this.debug("Exit popup skipped at render-time conditions", item);
+      return;
+    }
+    this.showDefinition(def);
+    this.removeDeferredExitPopup(item);
+  }
+  findPopupDefinition(surveyId, popupId) {
+    if (popupId) {
+      const byId = this.popupDefinitions.find((popup) => popup.id === popupId);
+      if (byId) return byId;
+    }
+    return this.popupDefinitions.find((popup) => popup.surveyId === surveyId);
+  }
+  removeDeferredExitPopup(item) {
+    const queue = this.getDeferredExitQueue().filter((entry) => !(entry.id === item.id && entry.sourceUrl === item.sourceUrl));
+    this.setDeferredExitQueue(queue);
+  }
+  getDeferredExitQueue() {
+    if (typeof window === "undefined") return [];
+    try {
+      const raw = window.sessionStorage.getItem(EXIT_QUEUE_STORAGE_KEY);
+      if (!raw) return [];
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed)) return [];
+      return parsed.filter((entry) => {
+        if (typeof entry !== "object" || entry === null) return false;
+        const item = entry;
+        return typeof item.id === "string" && typeof item.surveyId === "string" && typeof item.sourceUrl === "string" && typeof item.dueAt === "number" && Number.isFinite(item.dueAt);
+      }).map((item) => ({
+        ...item,
+        sourceUrl: this.normalizeUrl(item.sourceUrl)
+      }));
+    } catch {
+      return [];
+    }
+  }
+  setDeferredExitQueue(queue) {
+    if (typeof window === "undefined") return;
+    try {
+      if (!queue.length) {
+        window.sessionStorage.removeItem(EXIT_QUEUE_STORAGE_KEY);
+        return;
+      }
+      window.sessionStorage.setItem(EXIT_QUEUE_STORAGE_KEY, JSON.stringify(queue));
+    } catch {
+    }
+  }
+  /** Fetch al servidor para obtener popups */
+  async fetchPopupsFromServer() {
+    const apiKey = this.config?.apiKey;
+    const baseUrl = this.baseUrl;
+    const userId = this.config?.userId;
+    if (!apiKey || !baseUrl) {
+      this.log("Missing apiKey or baseUrl. Skipping popups fetch.");
+      return [];
+    }
+    const filter = userId ? { where: { userId } } : null;
+    const query = filter ? `?filter=${encodeURIComponent(JSON.stringify(filter))}` : "";
+    const endpoint = `${baseUrl}/sdk/${encodeURIComponent(apiKey)}/popups${query}`;
+    try {
+      const response = await fetch(endpoint);
+      if (!response.ok) {
+        this.log("Failed to fetch popups", response.status, response.statusText);
+        return [];
+      }
+      const raw = await response.text();
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed)) {
+        this.log("Unexpected popups payload", parsed);
+        return [];
+      }
+      this.debug("Fetched popups payload", parsed);
+      return parsed;
+    } catch (error) {
+      this.log("Error fetching popups", error);
+      return [];
+    }
+  }
+  /** Envía los atributos de contact a la API (`POST /sdk/popups/contact`). */
+  async postContact(body) {
+    const baseUrl = this.baseUrl;
+    if (!baseUrl) return;
+    const endpoint = `${baseUrl}/sdk/popups/contact`;
+    try {
+      const 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);
+    }
+  }
+  /** Notifica eventos de popup a la API */
+  async postPopupEvent(status, popupId, userId) {
+    const apiKey = this.config?.apiKey;
+    const baseUrl = this.baseUrl;
+    if (!apiKey || !baseUrl) {
+      return;
+    }
+    const endpoint = `${baseUrl}/sdk/popups`;
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          publicKey: apiKey,
+          status,
+          popupId,
+          userId: userId || void 0
+        })
+      });
+      if (!response.ok) {
+        this.log("Failed to post popup event", response.status, response.statusText);
+        return;
+      }
+      try {
+        const data = await response.json();
+        if (data && typeof data.sessionId === "string") {
+          this.tracking?.setSessionId(data.sessionId);
+          this.log("tracking \xB7 session_id from backend:", data.sessionId);
+        }
+      } catch {
+      }
+    } catch (error) {
+      this.log("Error posting popup event", error);
+    }
+  }
+  /** Add an event listener */
+  on(eventType, listener) {
+    if (!this.listeners.has(eventType)) {
+      this.listeners.set(eventType, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(eventType).add(listener);
+  }
+  /** Remove an event listener */
+  off(eventType, listener) {
+    const listeners = this.listeners.get(eventType);
+    if (listeners) {
+      listeners.delete(listener);
+    }
+  }
+  /** Setup popup container element */
+  setupPopupContainer() {
+    if (typeof document === "undefined") {
+      return;
+    }
+    this.popupContainer = document.createElement("div");
+    this.popupContainer.id = "deepdots-popup-container";
+    this.popupContainer.style.cssText = `
+          position: fixed;
+          top: 0;
+          left: 0;
+          width: 100%;
+          height: 100%;
+          display: none;
+          z-index: 999999;
+          background: rgba(0, 0, 0, 0.5);
+          justify-content: center;
+          align-items: center;
+        `;
+    document.body.appendChild(this.popupContainer);
+  }
+  /** Render the popup UI */
+  renderPopup(surveyId, productId, actions, style) {
+    const userId = this.tracking?.getUserId() ?? this.config?.userId;
+    const sessionId = this.tracking?.getSessionId() ?? void 0;
+    const miniService = this.analytics?.getMiniService() ?? void 0;
+    this.log("tracking \xB7 survey identity \u2192", { userId: userId ?? null, sessionId: sessionId ?? null, miniService: miniService ?? null });
+    if (this.renderer) {
+      this.renderer.show(
+        surveyId,
+        productId,
+        actions,
+        (type, id, payload) => this.emitEvent(type, id, payload),
+        () => this.hidePopup(),
+        this.env,
+        userId,
+        style,
+        sessionId,
+        miniService
+      );
+      return;
+    }
+    if (!this.popupContainer) return;
+    const container = this.popupContainer;
+    void import("./renderPopup-7GGKR5BY.mjs").then(({ renderPopup }) => {
+      renderPopup(
+        container,
+        surveyId,
+        productId,
+        actions,
+        (type, id, payload) => this.emitEvent(type, id, payload),
+        () => this.hidePopup(),
+        this.env,
+        userId,
+        style,
+        sessionId,
+        miniService
+      );
+    });
+  }
+  /** Hide the popup */
+  hidePopup() {
+    if (this.renderer) {
+      this.renderer.hide();
+      return;
+    }
+    if (this.popupContainer) {
+      this.popupContainer.style.display = "none";
+      this.popupContainer.innerHTML = "";
+    }
+  }
+  /** Emit an event */
+  emitEvent(type, surveyId, data) {
+    const event = { type, surveyId, timestamp: Date.now(), data };
+    this.log("Event emitted", event);
+    const isPartialClick = type === "popup_clicked" && data?.action === "partial";
+    if (isPartialClick) {
+      this.markSurveyProgress(surveyId, "PARTIAL");
+    }
+    if (type === "survey_completed") {
+      this.markSurveyAnswered(surveyId);
+    }
+    if (type === "popup_shown" || type === "survey_completed" || isPartialClick) {
+      const popupIdFromData = data?.popupId;
+      const popupId = popupIdFromData || this.surveyToPopupId.get(surveyId);
+      if (popupId) {
+        const userIdFromData = data?.userId;
+        const status = type === "popup_shown" ? "SHOWED" /* SHOWED */ : type === "survey_completed" ? "COMPLETED" /* COMPLETED */ : "PARTIAL" /* PARTIAL */;
+        void this.postPopupEvent(status, popupId, userIdFromData || this.tracking?.getUserId() || this.config?.userId);
+      } else {
+        this.debug("No popupId available to post event", { type, surveyId });
+      }
+    }
+    const listeners = this.listeners.get(type);
+    if (listeners) {
+      listeners.forEach((listener) => {
+        try {
+          listener(event);
+        } catch (error) {
+          console.error("Error in event listener:", error);
+        }
+      });
+    }
+  }
+  /** Log debug messages */
+  log(...args) {
+    if (this.config?.debug) {
+      console.log("[DeepdotsPopups]", ...args);
+    }
+  }
+  /** External debug method for triggers */
+  debug(...args) {
+    this.log(...args);
+  }
+  /** Set a custom renderer */
+  setRenderer(renderer) {
+    this.renderer = renderer;
+    if (this.initialized && this.renderer.init) {
+      this.renderer.init();
+    }
+  }
+  normalizeUrl(value) {
+    if (!value) return "";
+    const withoutIndex = value.replace(/\/index\.html(?=($|[?#]))/i, "");
+    return withoutIndex.length > 1 && withoutIndex.endsWith("/") ? withoutIndex.slice(0, -1) : withoutIndex;
+  }
+  safeParseUrl(url) {
+    if (!url) return null;
+    try {
+      return new URL(url, typeof window !== "undefined" ? window.location.href : void 0);
+    } catch {
+      return null;
+    }
+  }
+  mapPopupTriggerType(type) {
+    switch (type) {
+      case "time_on_page":
+        return "time";
+      case "scroll":
+        return "scroll";
+      case "exit":
+        return "exit";
+      case "click":
+        return "click";
+      case "event":
+        return "event";
+      default:
+        return null;
+    }
+  }
+  markSurveyProgress(surveyId, status) {
+    const current = this.surveyProgress.get(surveyId);
+    if (current?.status === "COMPLETED" && status !== "COMPLETED") {
+      return;
+    }
+    this.surveyProgress.set(surveyId, { status, timestamp: Date.now() });
+  }
+  isPopupDefinition(value) {
+    if (typeof value !== "object" || value === null) return false;
+    const popup = value;
+    return typeof popup.id === "string" && typeof popup.title === "string" && typeof popup.message === "string" && typeof popup.surveyId === "string" && typeof popup.productId === "string" && Array.isArray(popup.triggers) && popup.triggers.length > 0 && popup.triggers.every((trigger) => this.isPopupTrigger(trigger)) && (!popup.cooldown || popup.cooldown.every((condition) => this.isPopupTriggerCondition(condition)));
+  }
+  isPopupTrigger(value) {
+    if (typeof value !== "object" || value === null) return false;
+    const trigger = value;
+    return this.isPopupTriggerType(trigger.type) && (typeof trigger.value === "number" || typeof trigger.value === "string");
+  }
+  isPopupTriggerType(value) {
+    return value === "time_on_page" || value === "scroll" || value === "exit" || value === "click" || value === "event";
+  }
+  isPopupTriggerCondition(value) {
+    if (typeof value !== "object" || value === null) return false;
+    const condition = value;
+    return POPUP_TRIGGER_CONDITION_STATUSES.includes(condition.answered) && typeof condition.cooldownDays === "number" && Number.isFinite(condition.cooldownDays) && condition.cooldownDays >= 0;
+  }
+  isLegacyPopupTriggerCondition(value) {
+    if (typeof value !== "object" || value === null) return false;
+    const condition = value;
+    if (condition.answered !== void 0 && typeof condition.answered !== "boolean") {
+      return false;
+    }
+    if (condition.cooldownDays !== void 0) {
+      return typeof condition.cooldownDays === "number" && Number.isFinite(condition.cooldownDays) && condition.cooldownDays >= 0;
+    }
+    return true;
+  }
+  normalizeTriggers(value) {
+    const items = Array.isArray(value) ? value : value ? [value] : [];
+    return items.filter((trigger) => this.isPopupTrigger(trigger)).map((trigger) => ({
+      type: trigger.type,
+      value: trigger.value
+    }));
+  }
+  normalizeCooldown(value) {
+    if (!Array.isArray(value)) return [];
+    return value.filter((condition) => this.isPopupTriggerCondition(condition));
+  }
+  normalizeLegacyConditions(value) {
+    if (!Array.isArray(value)) return [];
+    return value.filter((condition) => this.isLegacyPopupTriggerCondition(condition));
+  }
+  normalizePopupDefinition(def) {
+    if (typeof def !== "object" || def === null) return null;
+    const raw = def;
+    const rawTriggers = raw.triggers ?? raw.trigger;
+    const triggers = this.normalizeTriggers(rawTriggers);
+    if (!triggers.length) return null;
+    const rawTriggerList = Array.isArray(rawTriggers) ? rawTriggers : rawTriggers ? [rawTriggers] : [];
+    const legacyConditions = [
+      ...this.normalizeLegacyConditions(raw.conditions),
+      ...rawTriggerList.flatMap((trigger) => this.normalizeLegacyConditions(trigger.condition))
+    ];
+    const cooldown = this.normalizeCooldown(raw.cooldown);
+    return {
+      ...raw,
+      triggers,
+      cooldown,
+      legacyConditions
+    };
+  }
+  validatePopupDefinitions(defs) {
+    return defs.map((def) => this.normalizePopupDefinition(def)).filter((def) => !!def && this.isPopupDefinition(def));
+  }
+};
+
+// src/react-native/setup.ts
+function mmkvStorage(mmkv) {
+  return {
+    getItem: (k) => mmkv.getString(k) ?? null,
+    setItem: (k, v) => mmkv.set(k, v),
+    removeItem: (k) => mmkv.delete(k)
+  };
+}
+function collectRnDevice(d) {
+  return {
+    device_type: d.isTablet?.() ? "tablet" : "mobile",
+    os_version: d.getSystemVersion?.(),
+    device_model: d.getDeviceId?.(),
+    app_version: d.getVersion?.()
+  };
+}
+function setupReactNative(sdk2, config, deps = {}) {
+  if (deps.renderer) sdk2.setRenderer(deps.renderer);
+  const storage = deps.mmkv ? mmkvStorage(deps.mmkv) : config.storage;
+  const device = deps.deviceInfo ? collectRnDevice(deps.deviceInfo) : config.device;
+  const platform = deps.platform ?? config.platform;
+  sdk2.init({ ...config, storage, device, platform });
+  let subscription;
+  if (deps.appState?.addEventListener) {
+    subscription = deps.appState.addEventListener("change", (state) => {
+      if (state === "active") sdk2.onForeground();
+      else sdk2.onBackground();
+    });
+  }
+  return () => {
+    if (subscription && typeof subscription.remove === "function") subscription.remove();
+  };
+}
+
+// src/react-native/index.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var sdk = new DeepdotsPopups();
+var DeepdotsContext = createContext(sdk);
+var useDeepdots = () => useContext(DeepdotsContext);
+function optionalRequire(name) {
+  try {
+    return __require(name);
+  } catch {
+    return null;
+  }
+}
+function DeepdotsProvider({ config, children }) {
+  const [survey, setSurvey] = useState(null);
+  const rendererRef = useRef(null);
+  useEffect(() => {
+    const renderer = new ReactNativePopupRenderer({
+      onShow: (p) => setSurvey(p),
+      onHide: () => setSurvey(null)
+    });
+    rendererRef.current = renderer;
+    const MmkvMod = optionalRequire("react-native-mmkv");
+    const mmkv = MmkvMod?.MMKV ? new MmkvMod.MMKV({ id: "deepdots-sdk" }) : null;
+    const deviceInfo = optionalRequire("react-native-device-info")?.default ?? null;
+    const dispose = setupReactNative(sdk, config, {
+      mmkv,
+      deviceInfo,
+      appState: AppState,
+      platform: Platform.OS === "ios" ? "ios" : "android",
+      renderer
+    });
+    return dispose;
+  }, []);
+  return /* @__PURE__ */ jsxs(DeepdotsContext.Provider, { value: sdk, children: [
+    children,
+    survey ? /* @__PURE__ */ jsx(Modal, { visible: true, transparent: true, animationType: "slide", children: /* @__PURE__ */ jsx(View, { style: { flex: 1 }, children: /* @__PURE__ */ jsx(
+      WebView,
+      {
+        originWhitelist: ["*"],
+        javaScriptEnabled: true,
+        source: { html: survey.html },
+        onMessage: (e) => rendererRef.current?.handleMessage(e.nativeEvent.data)
+      }
+    ) }) }) : null
+  ] });
+}
+export {
+  DeepdotsProvider,
+  ReactNativePopupRenderer,
+  setupReactNative,
+  useDeepdots
+};
+//# sourceMappingURL=react-native.mjs.map