@magicfeedback/popup-sdk 1.0.10 → 1.0.12

package/dist/index.mjs

@@ -1712,6 +1712,13 @@ var require_magicfeedback_sdk_browser = __commonJS({
   }
 });
 
+// src/types/index.ts
+var POPUP_TRIGGER_CONDITION_STATUSES = [
+  "SHOWED",
+  "PARTIAL",
+  "COMPLETED"
+];
+
 // src/ui/renderPopup.ts
 var import_native = __toESM(require_magicfeedback_sdk_browser());
 function ensureMagicFeedbackStyles(popup) {
@@ -1774,7 +1781,7 @@ function ensureResponsiveStyles(popup) {
   `;
   popup.appendChild(style);
 }
-async function renderPopup(container, surveyId, productId, actions, emit, onClose) {
+async function renderPopup(container, surveyId, productId, actions, emit, onClose, env = "production") {
   let surveyCompletedEmitted = false;
   let stylesInjected = false;
   const popup = document.createElement("div");
@@ -2058,7 +2065,7 @@ async function renderPopup(container, surveyId, productId, actions, emit, onClos
       setLoading(false);
       return;
     }
-    import_native.default.init({ debug: true, env: "prod" });
+    import_native.default.init({ debug: true, env: env === "production" ? "prod" : "dev" });
     formInstance = import_native.default.form(surveyId, productId);
     const generateOptions = {
       addButton: false,
@@ -2173,6 +2180,7 @@ async function renderPopup(container, surveyId, productId, actions, emit, onClos
         updateButtons("completed");
         return;
       }
+      emit("popup_clicked", surveyId, { action: "partial" });
       if (total > 1 && progress > 0 && progress < total) {
         updateButtons("in_progress_next");
       } else {
@@ -2209,12 +2217,18 @@ function setupTrigger(popups, trigger) {
     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);
+    popups.triggerSurvey(trigger.surveyId, trigger.popupId);
   }, delay);
   popups.debug(`Time trigger set for ${delay}ms`);
 }
@@ -2223,7 +2237,7 @@ function setupScrollTrigger(popups, trigger) {
   const handler = () => {
     const scrollPercentage = window.scrollY / (document.documentElement.scrollHeight - window.innerHeight) * 100;
     if (scrollPercentage >= threshold) {
-      popups.triggerSurvey(trigger.surveyId);
+      popups.triggerSurvey(trigger.surveyId, trigger.popupId);
       window.removeEventListener("scroll", handler);
     }
   };
@@ -2231,23 +2245,137 @@ function setupScrollTrigger(popups, trigger) {
   popups.debug(`Scroll trigger set for ${threshold}%`);
 }
 function setupExitTrigger(popups, trigger) {
-  const handler = (e) => {
-    if (e.clientY <= 0) {
-      popups.triggerSurvey(trigger.surveyId);
-      document.removeEventListener("mouseout", handler);
+  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);
   };
-  document.addEventListener("mouseout", handler);
-  popups.debug("Exit intent trigger set");
+  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.magicfeedback.com"
+    apiBaseUrl: "https://api-dev.deepdots.com"
   },
   production: {
-    apiBaseUrl: "https://api.magicfeedback.com"
+    apiBaseUrl: "https://api.deepdots.com"
   }
 };
 function resolveEnvironment(nodeEnv) {
@@ -2329,10 +2457,10 @@ var BrowserPopupRenderer = class {
       document.body.appendChild(this.container);
     }
   }
-  show(surveyId, productId, actions, emit, onClose) {
+  show(surveyId, productId, actions, emit, onClose, env = "production") {
     if (!this.container) this.init();
     if (!this.container) return;
-    renderPopup(this.container, surveyId, productId, actions, emit, onClose);
+    renderPopup(this.container, surveyId, productId, actions, emit, onClose, env);
   }
   hide() {
     if (this.container) {
@@ -2351,6 +2479,8 @@ function createDefaultRenderer() {
 }
 
 // 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;
@@ -2364,9 +2494,15 @@ var DeepdotsPopups = class {
     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";
   }
-  // popupId -> timestamp mostrado
   /** Initialize the SDK with configuration */
   init(config) {
     if (this.initialized) {
@@ -2374,27 +2510,31 @@ var DeepdotsPopups = class {
       return;
     }
     const env = resolveEnvironment(config.nodeEnv);
+    this.baseUrl = env.apiBaseUrl;
+    this.env = config.nodeEnv || "production";
     this.config = {
       apiKey: config.apiKey || void 0,
-      baseUrl: env.apiBaseUrl,
       mode: config.mode || "client",
       debug: config.debug || false,
-      popups: config.popups || []
+      popups: config.popups || [],
+      userId: config.userId || void 0
     };
     this.initialized = true;
     this.log("SDK initialized", this.config);
     if (this.renderer.init) this.renderer.init();
     this.setupPopupContainer();
     if (this.config.mode === "client") {
-      this.popupDefinitions = this.config.popups || [];
+      this.popupDefinitions = this.validatePopupDefinitions(this.config.popups || []);
       this.popupsLoaded = true;
       this.configureTriggersFromDefinitions();
+      this.processDeferredExitQueue();
     } else {
       this.fetchPopupsFromServer().then((defs) => {
-        this.popupDefinitions = defs;
+        this.popupDefinitions = this.validatePopupDefinitions(defs);
         this.popupsLoaded = true;
-        this.log("Popups loaded from server (fake)", defs);
+        this.log("Popups loaded from server (fake)", this.popupDefinitions);
         this.configureTriggersFromDefinitions();
+        this.processDeferredExitQueue();
         if (this.pendingAutoLaunch) {
           this.startTriggers();
         }
@@ -2420,7 +2560,6 @@ var DeepdotsPopups = class {
   }
   /** Show a popup immediately (supports legacy ShowOptions and new PopupDefinition) */
   show(options) {
-    console.log("Show popup called with options:", options);
     if (!this.initialized) {
       throw new Error("SDK not initialized. Call init() first.");
     }
@@ -2428,8 +2567,10 @@ var DeepdotsPopups = class {
     if (isDefinition) {
       const def = options;
       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);
-      this.emitEvent("popup_shown", def.surveyId);
+      this.emitEvent("popup_shown", def.surveyId, { popupId: def.id });
     } else {
       const opt = options;
       this.log("Showing popup (legacy options)", opt);
@@ -2439,7 +2580,7 @@ var DeepdotsPopups = class {
   }
   /** Mostrar popup por id de definición (usa surveyId interno) */
   showByPopupId(popupId) {
-    const def = this.popupDefinitions.find((p) => p.id === popupId);
+    const def = this.popupDefinitions.find((popup) => popup.id === popupId);
     if (!def) {
       this.log("Popup definition not found", popupId);
       return;
@@ -2457,92 +2598,315 @@ var DeepdotsPopups = class {
   /** Deriva triggers desde las definiciones de popup */
   configureTriggersFromDefinitions() {
     const derived = [];
-    const validDefs = this.validatePopupDefinitions(this.popupDefinitions);
-    validDefs.forEach((def) => {
-      if (!def.trigger) return;
-      const t = def.trigger;
-      let type;
-      switch (t.type) {
-        case "time_on_page":
-          type = "time";
-          break;
-        case "scroll":
-          type = "scroll";
-          break;
-        case "exit":
-          type = "exit";
-          break;
-        default:
-          this.debug("Unsupported trigger type", t.type);
+    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" ? t.value * 1e3 : t.value;
-      derived.push({ type, value, surveyId: def.surveyId });
+        }
+        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) {
-    const def = this.popupDefinitions.find((p) => p.surveyId === surveyId);
+  triggerSurvey(surveyId, popupId) {
+    const def = this.findPopupDefinition(surveyId, popupId);
     if (!def) {
-      this.debug("No popup definition for surveyId", surveyId);
+      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.show(def);
-    this.lastShown.set(def.id, Date.now());
   }
-  shouldShow(def) {
-    const conditions = def.trigger.condition || [];
-    if (!conditions.length) return true;
-    return conditions.every((c) => this.evaluateCondition(def, c));
+  shouldShow(def, pathUrl, skipPathCheck = false) {
+    if (!skipPathCheck && !this.matchesSegmentsPath(def, pathUrl)) {
+      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));
   }
-  evaluateCondition(def, condition) {
+  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;
     }
-    if (condition.cooldownDays) {
-      const last = this.lastShown.get(def.id);
-      if (last) {
-        const msSince = Date.now() - last;
-        const required = condition.cooldownDays * 24 * 60 * 60 * 1e3;
-        if (msSince < required) return false;
-      }
+    return this.hasCooldownElapsed(this.lastShown.get(def.id), condition.cooldownDays);
+  }
+  hasCooldownElapsed(timestamp, cooldownDays) {
+    if (!timestamp || !cooldownDays) {
+      return true;
     }
-    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);
   }
-  /** Simula fetch al servidor para obtener popups */
+  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() {
-    await new Promise((res) => setTimeout(res, 50));
-    return this.generateFakePopups();
-  }
-  /** Genera datos fake para pruebas en modo server */
-  generateFakePopups() {
-    return [
-      {
-        id: "popup-123",
-        title: "Would you like to help us improve?",
-        message: "<p>Take a quick survey and share your thoughts.</p>",
-        trigger: { type: "time_on_page", value: 1, condition: [{ answered: false, cooldownDays: 7 }] },
-        actions: {
-          accept: { label: "Take Survey", surveyId: "survey-abc" },
-          decline: { label: "Not Now", cooldownDays: 7 }
-        },
-        surveyId: "survey-abc",
-        productId: "product-xyz",
-        style: { theme: "light", position: "bottom-right", imageUrl: null },
-        segments: { lang: ["en"], path: ["/checkout"] }
+    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 [];
+    }
+  }
+  /** 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);
+      }
+    } catch (error) {
+      this.log("Error posting popup event", error);
+    }
   }
   /** Add an event listener */
   on(eventType, listener) {
@@ -2582,11 +2946,26 @@ var DeepdotsPopups = class {
   /** Render the popup UI */
   renderPopup(surveyId, productId, actions) {
     if (this.renderer) {
-      this.renderer.show(surveyId, productId, actions, (type, id, payload) => this.emitEvent(type, id, payload), () => this.hidePopup());
+      this.renderer.show(
+        surveyId,
+        productId,
+        actions,
+        (type, id, payload) => this.emitEvent(type, id, payload),
+        () => this.hidePopup(),
+        this.env
+      );
       return;
     }
     if (!this.popupContainer) return;
-    renderPopup(this.popupContainer, surveyId, productId, actions, (type, id, payload) => this.emitEvent(type, id, payload), () => this.hidePopup());
+    renderPopup(
+      this.popupContainer,
+      surveyId,
+      productId,
+      actions,
+      (type, id, payload) => this.emitEvent(type, id, payload),
+      () => this.hidePopup(),
+      this.env
+    );
   }
   /** Hide the popup */
   hidePopup() {
@@ -2603,9 +2982,22 @@ var DeepdotsPopups = class {
   emitEvent(type, surveyId, data) {
     const event = { type, surveyId, timestamp: Date.now(), data };
     this.log("Event emitted", event);
+    if (type === "popup_clicked" && data?.action === "partial") {
+      this.markSurveyProgress(surveyId, "PARTIAL");
+    }
     if (type === "survey_completed") {
       this.markSurveyAnswered(surveyId);
     }
+    if (type === "popup_shown" || type === "survey_completed") {
+      const popupIdFromData = data?.popupId;
+      const popupId = popupIdFromData || this.surveyToPopupId.get(surveyId);
+      if (popupId) {
+        const userIdFromData = data?.userId;
+        void this.postPopupEvent(type === "popup_shown" ? "opened" : "completed", popupId, userIdFromData || 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) => {
@@ -2634,17 +3026,111 @@ var DeepdotsPopups = class {
       this.renderer.init();
     }
   }
-  // Type guards
+  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 v = value;
-    return typeof v.id === "string" && typeof v.title === "string" && typeof v.message === "string" && typeof v.surveyId === "string" && typeof v.productId === "string" && !!v.trigger;
+    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.filter((d) => this.isPopupDefinition(d));
+    return defs.map((def) => this.normalizePopupDefinition(def)).filter((def) => !!def && this.isPopupDefinition(def));
   }
 };
 export {
-  DeepdotsPopups
+  DeepdotsPopups,
+  POPUP_TRIGGER_CONDITION_STATUSES
 };
 //# sourceMappingURL=index.mjs.map