@metodokorexmk/tracking 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1779 @@
+'use strict';
+
+var ReactGA = require('react-ga4');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var ReactGA__default = /*#__PURE__*/_interopDefault(ReactGA);
+
+// src/core/analytics.ts
+var isInitialized = false;
+var currentConfig = {};
+var resolvedTrackingId = "";
+var cachedUserId = null;
+var cachedUserName = null;
+var getGATrackingId = () => {
+  if (typeof window === "undefined") return resolvedTrackingId || "";
+  if (currentConfig.resolveTrackingId) {
+    try {
+      const path = window.location.pathname;
+      return currentConfig.resolveTrackingId(path);
+    } catch {
+    }
+  }
+  return resolvedTrackingId;
+};
+var initGA = (config = {}) => {
+  if (typeof window === "undefined") return;
+  if (isInitialized) return;
+  currentConfig = config;
+  resolvedTrackingId = config.trackingId || "";
+  const trackingId = getGATrackingId();
+  if (!trackingId) {
+    if (config.debug) {
+      console.warn("[KorexTracking] No tracking ID provided. GA4 will not initialize.");
+    }
+    return;
+  }
+  try {
+    ReactGA__default.default.initialize(trackingId);
+    isInitialized = true;
+    if (config.anonymizeIp) {
+      window.gtag?.("config", trackingId, { anonymize_ip: true });
+    }
+    if (config.debug) {
+      console.log(`[KorexTracking] GA4 initialized with ID: ${trackingId}`);
+    }
+  } catch (error) {
+    if (config.debug) {
+      console.error("[KorexTracking] Failed to initialize GA4:", error);
+    }
+  }
+};
+var reinitGA = (newTrackingId) => {
+  isInitialized = false;
+  resolvedTrackingId = newTrackingId;
+  initGA({ ...currentConfig, trackingId: newTrackingId });
+};
+var isGAInitialized = () => isInitialized;
+var captureUTMParams = () => {
+  if (typeof window === "undefined") return null;
+  const params = new URLSearchParams(window.location.search);
+  const utmParams = {};
+  let hasParams = false;
+  const utmKeys = ["utm_source", "utm_medium", "utm_campaign", "utm_term", "utm_content"];
+  for (const key of utmKeys) {
+    const value = params.get(key);
+    if (value) {
+      utmParams[key] = value;
+      hasParams = true;
+    }
+  }
+  return hasParams ? utmParams : null;
+};
+var captureUserIdFromURL = () => {
+  if (typeof window === "undefined") return null;
+  const params = new URLSearchParams(window.location.search);
+  const userId = params.get("user_id") || params.get("userId");
+  if (userId) {
+    cachedUserId = userId;
+    try {
+      localStorage.setItem("tracking_user_id", userId);
+    } catch {
+    }
+  }
+  return userId;
+};
+var getUserName = () => {
+  if (typeof window === "undefined") return null;
+  const params = new URLSearchParams(window.location.search);
+  const fromUrl = params.get("user_name") || params.get("userName");
+  if (fromUrl) {
+    cachedUserName = fromUrl;
+    return fromUrl;
+  }
+  if (cachedUserName) return cachedUserName;
+  try {
+    const fromStorage = localStorage.getItem("tracking_user_name");
+    if (fromStorage) {
+      cachedUserName = fromStorage;
+      return fromStorage;
+    }
+    const userInfo = localStorage.getItem("userInfo");
+    if (userInfo) {
+      const parsed = JSON.parse(userInfo);
+      const name = parsed?.name || parsed?.userName || parsed?.fullName;
+      if (name) {
+        cachedUserName = name;
+        return name;
+      }
+    }
+  } catch {
+  }
+  return null;
+};
+var getUserId = () => {
+  if (cachedUserId) return cachedUserId;
+  if (typeof window === "undefined") return null;
+  try {
+    return localStorage.getItem("tracking_user_id");
+  } catch {
+    return null;
+  }
+};
+var setUserId = (userId) => {
+  cachedUserId = userId;
+  try {
+    localStorage.setItem("tracking_user_id", userId);
+  } catch {
+  }
+  window.gtag?.("set", { user_id: userId });
+};
+var setUserName = (userName) => {
+  cachedUserName = userName;
+  try {
+    localStorage.setItem("tracking_user_name", userName);
+  } catch {
+  }
+};
+var trackPageView = (path) => {
+  if (typeof window === "undefined") return;
+  const userId = getUserId();
+  const utmParams = captureUTMParams();
+  let pageWithParams = path;
+  if (utmParams) {
+    const searchParams = new URLSearchParams();
+    Object.entries(utmParams).forEach(([key, value]) => {
+      if (value) searchParams.set(key, value);
+    });
+    const paramString = searchParams.toString();
+    if (paramString) {
+      pageWithParams = `${path}${path.includes("?") ? "&" : "?"}${paramString}`;
+    }
+  }
+  try {
+    ReactGA__default.default.send({
+      hitType: "pageview",
+      page: pageWithParams,
+      ...userId && { user_id: userId }
+    });
+  } catch {
+  }
+  try {
+    window.gtag?.("event", "page_view", {
+      page_path: pageWithParams,
+      page_title: document.title,
+      ...userId && { user_id: userId }
+    });
+  } catch {
+  }
+  if (currentConfig.debug) {
+    console.log(`[KorexTracking] PageView: ${pageWithParams}`, { userId });
+  }
+};
+var trackEvent = (category, action, label, value, additionalData) => {
+  if (typeof window === "undefined") return;
+  const userId = getUserId();
+  const userName = getUserName();
+  const eventData = {
+    event_category: category,
+    event_label: label || "",
+    ...value !== void 0 && { value },
+    ...userId && { user_id: userId },
+    ...userName && { user_name: userName },
+    timestamp: Date.now(),
+    ...additionalData
+  };
+  try {
+    window.gtag?.("event", action, eventData);
+  } catch {
+  }
+  try {
+    ReactGA__default.default.event({
+      category,
+      action,
+      label: label || void 0,
+      value: value || void 0,
+      ...userId && { user_id: userId }
+    });
+  } catch {
+  }
+  if (currentConfig.debug) {
+    console.log(`[KorexTracking] Event: ${category}/${action}`, eventData);
+  }
+};
+var resetAnalytics = () => {
+  isInitialized = false;
+  currentConfig = {};
+  resolvedTrackingId = "";
+  cachedUserId = null;
+  cachedUserName = null;
+};
+
+// src/core/gtm.ts
+var injectGTMScript = (gtmId) => {
+  if (typeof window === "undefined") return;
+  if (!gtmId) return;
+  const existingScript = document.querySelector(`script[data-gtm-id="${gtmId}"]`);
+  if (existingScript) return;
+  window.dataLayer = window.dataLayer || [];
+  window.dataLayer.push({
+    "gtm.start": (/* @__PURE__ */ new Date()).getTime(),
+    event: "gtm.js"
+  });
+  const script = document.createElement("script");
+  script.async = true;
+  script.src = `https://www.googletagmanager.com/gtm.js?id=${gtmId}`;
+  script.setAttribute("data-gtm-id", gtmId);
+  const firstScript = document.getElementsByTagName("script")[0];
+  if (firstScript?.parentNode) {
+    firstScript.parentNode.insertBefore(script, firstScript);
+  } else {
+    document.head.appendChild(script);
+  }
+  if (document.body) {
+    const noscript = document.createElement("noscript");
+    const iframe = document.createElement("iframe");
+    iframe.src = `https://www.googletagmanager.com/ns.html?id=${gtmId}`;
+    iframe.height = "0";
+    iframe.width = "0";
+    iframe.style.display = "none";
+    iframe.style.visibility = "hidden";
+    noscript.appendChild(iframe);
+    document.body.insertBefore(noscript, document.body.firstChild);
+  }
+};
+var pushToDataLayer = (eventName, data) => {
+  if (typeof window === "undefined") return;
+  window.dataLayer = window.dataLayer || [];
+  window.dataLayer.push({
+    event: eventName,
+    ...data
+  });
+};
+
+// src/trackers/video-tracker.ts
+var VideoTracker = class {
+  constructor() {
+    this.videos = /* @__PURE__ */ new Map();
+    this.watchTimeIntervals = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Inicializa el tracking para un video.
+   */
+  initVideo(videoId) {
+    if (this.videos.has(videoId)) return;
+    const state = {
+      videoId,
+      startTime: Date.now(),
+      totalWatchTime: 0,
+      playCount: 0,
+      pauseCount: 0,
+      seekCount: 0,
+      completionPercentage: 0,
+      lastPlayTimestamp: 0,
+      isPlaying: false,
+      currentTime: 0,
+      duration: 0,
+      pauseTimes: [],
+      seekEvents: [],
+      progressMilestones: /* @__PURE__ */ new Set(),
+      playbackSpeed: 1
+    };
+    this.videos.set(videoId, state);
+    trackEvent("Video", "init", videoId, void 0, {
+      video_id: videoId,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Tracking de evento play.
+   */
+  trackPlay(videoId, currentTime = 0) {
+    const state = this.getOrCreateState(videoId);
+    state.playCount++;
+    state.isPlaying = true;
+    state.lastPlayTimestamp = Date.now();
+    state.currentTime = currentTime;
+    this.startWatchTimeTracking(videoId);
+    trackEvent("Video", "play", videoId, void 0, {
+      video_id: videoId,
+      play_count: state.playCount,
+      current_time: Math.round(currentTime)
+    });
+  }
+  /**
+   * Tracking de evento pause.
+   */
+  trackPause(videoId, currentTime, duration) {
+    const state = this.getOrCreateState(videoId);
+    state.pauseCount++;
+    state.isPlaying = false;
+    state.currentTime = currentTime;
+    state.pauseTimes.push(currentTime);
+    if (duration) {
+      state.duration = duration;
+      state.completionPercentage = Math.round(currentTime / duration * 100);
+    }
+    this.stopWatchTimeTracking(videoId);
+    trackEvent("Video", "pause", videoId, void 0, {
+      video_id: videoId,
+      pause_count: state.pauseCount,
+      current_time: Math.round(currentTime),
+      completion_percentage: state.completionPercentage,
+      total_watch_time: Math.round(state.totalWatchTime)
+    });
+  }
+  /**
+   * Tracking de evento seek (saltar en el timeline).
+   */
+  trackSeek(videoId, fromTime, toTime) {
+    const state = this.getOrCreateState(videoId);
+    state.seekCount++;
+    state.seekEvents.push({ from: fromTime, to: toTime });
+    trackEvent("Video", "seek", videoId, void 0, {
+      video_id: videoId,
+      seek_count: state.seekCount,
+      from_time: Math.round(fromTime),
+      to_time: Math.round(toTime),
+      skip_duration: Math.round(toTime - fromTime)
+    });
+  }
+  /**
+   * Tracking de progreso (milestones: 25%, 50%, 75%).
+   */
+  trackProgress(videoId, percentage, currentTime) {
+    const state = this.getOrCreateState(videoId);
+    const milestone = Math.floor(percentage / 25) * 25;
+    if (milestone > 0 && milestone < 100 && !state.progressMilestones.has(milestone)) {
+      state.progressMilestones.add(milestone);
+      trackEvent("Video", "progress", videoId, milestone, {
+        video_id: videoId,
+        progress_percentage: milestone,
+        current_time: Math.round(currentTime),
+        total_watch_time: Math.round(state.totalWatchTime)
+      });
+    }
+  }
+  /**
+   * Tracking de completación del video (≥95%).
+   */
+  trackComplete(videoId, totalDuration) {
+    const state = this.getOrCreateState(videoId);
+    state.completionPercentage = 100;
+    state.duration = totalDuration;
+    this.stopWatchTimeTracking(videoId);
+    trackEvent("Video", "complete", videoId, void 0, {
+      video_id: videoId,
+      total_duration: Math.round(totalDuration),
+      total_watch_time: Math.round(state.totalWatchTime),
+      play_count: state.playCount,
+      pause_count: state.pauseCount,
+      seek_count: state.seekCount
+    });
+  }
+  /**
+   * Tracking de fin del video (evento ended nativo).
+   */
+  trackEnd(videoId) {
+    const state = this.getOrCreateState(videoId);
+    state.isPlaying = false;
+    this.stopWatchTimeTracking(videoId);
+    trackEvent("Video", "end", videoId, void 0, {
+      video_id: videoId,
+      total_watch_time: Math.round(state.totalWatchTime),
+      play_count: state.playCount
+    });
+  }
+  /**
+   * Tracking de cambio de velocidad de reproducción.
+   */
+  trackSpeedChange(videoId, speed) {
+    const state = this.getOrCreateState(videoId);
+    state.playbackSpeed = speed;
+    trackEvent("Video", "speed_change", videoId, void 0, {
+      video_id: videoId,
+      playback_speed: speed
+    });
+  }
+  /**
+   * Tracking de pantalla completa.
+   */
+  trackFullscreen(videoId, isFullscreen) {
+    trackEvent("Video", isFullscreen ? "fullscreen_enter" : "fullscreen_exit", videoId, void 0, {
+      video_id: videoId,
+      is_fullscreen: isFullscreen
+    });
+  }
+  /**
+   * Tracking de no interacción (el usuario está en la página pero no interactúa con el video).
+   */
+  trackNoInteraction(videoId, timeOnPage) {
+    trackEvent("Video", "no_interaction", videoId, void 0, {
+      video_id: videoId,
+      time_on_page: Math.round(timeOnPage)
+    });
+  }
+  /**
+   * Obtiene el estado actual de un video.
+   */
+  getState(videoId) {
+    return this.videos.get(videoId);
+  }
+  /**
+   * Limpia el tracking de un video específico.
+   */
+  cleanup(videoId) {
+    this.stopWatchTimeTracking(videoId);
+    this.videos.delete(videoId);
+  }
+  /**
+   * Limpia todo el tracking.
+   */
+  cleanupAll() {
+    for (const videoId of this.videos.keys()) {
+      this.stopWatchTimeTracking(videoId);
+    }
+    this.videos.clear();
+  }
+  // --- Métodos privados ---
+  getOrCreateState(videoId) {
+    if (!this.videos.has(videoId)) {
+      this.initVideo(videoId);
+    }
+    return this.videos.get(videoId);
+  }
+  startWatchTimeTracking(videoId) {
+    this.stopWatchTimeTracking(videoId);
+    const interval = setInterval(() => {
+      const state = this.videos.get(videoId);
+      if (state?.isPlaying) {
+        state.totalWatchTime += 1;
+      }
+    }, 1e3);
+    this.watchTimeIntervals.set(videoId, interval);
+  }
+  stopWatchTimeTracking(videoId) {
+    const interval = this.watchTimeIntervals.get(videoId);
+    if (interval) {
+      clearInterval(interval);
+      this.watchTimeIntervals.delete(videoId);
+    }
+  }
+};
+var videoTracker = new VideoTracker();
+
+// src/trackers/events.ts
+var trackCTAClick = (buttonName, section, additionalData) => {
+  trackEvent("CTA", "click", buttonName, void 0, {
+    button_name: buttonName,
+    section,
+    ...additionalData
+  });
+};
+var trackFormStart = (formName) => {
+  trackEvent("Form", "started", formName, void 0, {
+    form_name: formName,
+    timestamp: Date.now()
+  });
+};
+var trackFormFieldComplete = (formName, fieldName) => {
+  trackEvent("Form", "field_completed", formName, void 0, {
+    form_name: formName,
+    field_name: fieldName
+  });
+};
+var trackFormSubmit = (formName, success, additionalData) => {
+  trackEvent("Form", success ? "submit_success" : "submit_error", formName, void 0, {
+    form_name: formName,
+    success,
+    ...additionalData
+  });
+};
+var trackFormValidationError = (formName, fieldName, errorMessage) => {
+  trackEvent("Error", "validation", formName, void 0, {
+    form_name: formName,
+    field_name: fieldName,
+    error_message: errorMessage
+  });
+};
+var trackConversion = (conversionType, value, additionalData) => {
+  trackEvent("Conversion", conversionType, void 0, value, {
+    conversion_type: conversionType,
+    ...additionalData
+  });
+};
+var trackSocialClick = (platform, action, additionalData) => {
+  trackEvent("Social", "click", platform, void 0, {
+    social_platform: platform,
+    social_action: action,
+    ...additionalData
+  });
+};
+var trackFAQExpand = (question, index) => {
+  trackEvent("FAQ", "expand", question, index, {
+    question,
+    question_index: index
+  });
+};
+var trackImageClick = (imageName, section) => {
+  trackEvent("Engagement", "image_click", imageName, void 0, {
+    image_name: imageName,
+    section
+  });
+};
+var trackTimeInSection = (sectionName, seconds) => {
+  if (seconds < 3) return;
+  trackEvent("Engagement", "time_in_section", sectionName, Math.round(seconds), {
+    section_name: sectionName,
+    time_seconds: Math.round(seconds)
+  });
+};
+var trackSectionClick = (section) => {
+  trackEvent("Navigation", "section_click", section);
+};
+var trackScrollTo = (section) => {
+  trackEvent("Navigation", "scroll_to", section);
+};
+var trackPricingCardClick = (productName, price, additionalData) => {
+  trackEvent("Pricing", "card_click", productName, void 0, {
+    product_name: productName,
+    price: String(price),
+    ...additionalData
+  });
+};
+var trackContactClick = (method) => {
+  trackEvent("Contact", "click", method, void 0, {
+    contact_method: method
+  });
+};
+var trackShare = (platform, content) => {
+  trackEvent("Share", "click", platform, void 0, {
+    share_platform: platform,
+    share_content: content
+  });
+};
+var trackDownload = (fileName, fileType) => {
+  trackEvent("Download", "click", fileName, void 0, {
+    file_name: fileName,
+    file_type: fileType
+  });
+};
+
+// src/trackers/wistia-adapter.ts
+var createStats = (timeWatched, completed) => ({
+  timeWatched: Math.max(0, Math.round(timeWatched)),
+  completed,
+  lastUpdate: Date.now()
+});
+var trackWistiaByMediaId = async (mediaId) => {
+  if (typeof window === "undefined") return null;
+  let stats = createStats(0, false);
+  let updateCallbacks = [];
+  let stopped = false;
+  const callUpdate = () => {
+    updateCallbacks.forEach((cb) => cb(stats));
+  };
+  const bindWistiaSDK = () => {
+    if (!window._wq) return false;
+    window._wq.push({
+      id: mediaId,
+      onReady: (rawVideo) => {
+        if (stopped) return;
+        const video = rawVideo;
+        const updateFromWistia = () => {
+          const t = video.time();
+          const d = video.duration();
+          const pct = d > 0 ? Math.round(t / d * 100) : 0;
+          const isCompleted = stats.completed || pct >= 95;
+          const newTime = Math.max(stats.timeWatched, Math.round(t));
+          if (newTime !== stats.timeWatched || isCompleted !== stats.completed) {
+            stats = createStats(newTime, isCompleted);
+            callUpdate();
+          }
+        };
+        video.bind("play", updateFromWistia);
+        video.bind("pause", updateFromWistia);
+        video.bind("secondchange", updateFromWistia);
+        video.bind("end", () => {
+          stats = createStats(Math.round(video.duration()), true);
+          callUpdate();
+        });
+      }
+    });
+    return true;
+  };
+  const bindHTML5Fallback = () => {
+    const selector = `[data-wistia-id="${mediaId}"], .wistia_embed[data-media-id="${mediaId}"]`;
+    const container = document.querySelector(selector);
+    if (!container) return;
+    const video = container.querySelector("video");
+    if (!video) return;
+    const onTimeUpdate = () => {
+      if (stopped) return;
+      const ct = Math.round(video.currentTime || 0);
+      const dur = video.duration || 0;
+      const pct = dur > 0 ? Math.round(ct / dur * 100) : 0;
+      const isCompleted = stats.completed || pct >= 95 || video.ended;
+      const newTime = Math.max(stats.timeWatched, ct);
+      if (newTime !== stats.timeWatched || isCompleted !== stats.completed) {
+        stats = createStats(newTime, isCompleted);
+        callUpdate();
+      }
+    };
+    const onEnded = () => {
+      if (stopped) return;
+      stats = createStats(Math.max(stats.timeWatched, Math.round(video.duration || 0)), true);
+      callUpdate();
+    };
+    video.addEventListener("timeupdate", onTimeUpdate);
+    video.addEventListener("ended", onEnded);
+  };
+  const wistiaReady = bindWistiaSDK();
+  if (!wistiaReady) {
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+    bindHTML5Fallback();
+  }
+  return {
+    getStats: () => stats,
+    onUpdate: (cb) => {
+      updateCallbacks.push(cb);
+      return () => {
+        updateCallbacks = updateCallbacks.filter((x) => x !== cb);
+      };
+    },
+    stop: () => {
+      stopped = true;
+      updateCallbacks = [];
+    }
+  };
+};
+
+// src/trackers/voomly-adapter.ts
+var createStats2 = (timeWatched, completed) => ({
+  timeWatched: Math.max(0, Math.round(timeWatched)),
+  completed,
+  lastUpdate: Date.now()
+});
+var findAllVideosInElement = (root) => {
+  const results = [];
+  const videos = Array.from(root.querySelectorAll("video"));
+  results.push(...videos);
+  const allElements = root.querySelectorAll("*");
+  for (const el of Array.from(allElements)) {
+    if (el.shadowRoot) {
+      results.push(...findAllVideosInElement(el.shadowRoot));
+    }
+  }
+  const iframes = root.querySelectorAll("iframe");
+  for (const iframe of Array.from(iframes)) {
+    try {
+      const doc = iframe.contentDocument || iframe.contentWindow?.document;
+      if (doc) {
+        results.push(...findAllVideosInElement(doc));
+      }
+    } catch {
+    }
+  }
+  return results;
+};
+var trackVoomlyByEmbedId = async (embedId) => {
+  if (typeof window === "undefined") return null;
+  let stats = createStats2(0, false);
+  let updateCallbacks = [];
+  const trackedVideos = /* @__PURE__ */ new Set();
+  const callUpdate = () => {
+    updateCallbacks.forEach((cb) => cb(stats));
+  };
+  const updateStatsFromVideo = (video) => {
+    const ct = Math.round(video.currentTime || 0);
+    const dur = video.duration || 0;
+    const pct = dur ? Math.round(ct / dur * 100) : 0;
+    const isCompleted = stats.completed || pct >= 90 || video.ended;
+    const newTimeWatched = Math.max(stats.timeWatched, ct);
+    if (newTimeWatched !== stats.timeWatched || isCompleted !== stats.completed) {
+      stats = createStats2(newTimeWatched, isCompleted);
+      callUpdate();
+    }
+  };
+  const onPlay = (e) => updateStatsFromVideo(e.target);
+  const onPause = (e) => updateStatsFromVideo(e.target);
+  const onTime = (e) => updateStatsFromVideo(e.target);
+  const onEnd = (e) => updateStatsFromVideo(e.target);
+  const bindVideo = (video) => {
+    if (trackedVideos.has(video)) return;
+    trackedVideos.add(video);
+    video.addEventListener("play", onPlay);
+    video.addEventListener("pause", onPause);
+    video.addEventListener("timeupdate", onTime);
+    video.addEventListener("ended", onEnd);
+  };
+  const scanForVideos = () => {
+    const selector = `.voomly-embed[data-id="${embedId}"]`;
+    const container = document.querySelector(selector);
+    let foundVideos = [];
+    if (container) {
+      foundVideos = findAllVideosInElement(container);
+    }
+    if (foundVideos.length === 0) {
+      foundVideos = findAllVideosInElement(document);
+    }
+    foundVideos.forEach((v) => bindVideo(v));
+  };
+  scanForVideos();
+  const scanInterval = setInterval(scanForVideos, 2e3);
+  const pollingInterval = setInterval(() => {
+    trackedVideos.forEach((video) => {
+      const ct = Math.round(video.currentTime || 0);
+      if (!video.paused || ct > 0) {
+        updateStatsFromVideo(video);
+      }
+    });
+  }, 1e3);
+  const handleVoomlyWindowEvents = (e) => {
+    try {
+      const customEvent = e;
+      const payload = customEvent.detail || customEvent.payload;
+      const playerInfo = payload?.playerInfo || payload;
+      const id = playerInfo?.id || playerInfo?.videoId;
+      if (id && id !== embedId) return;
+      const currentTime = payload?.currentTime || payload?.time || 0;
+      const duration = payload?.duration || payload?.totalTime || 0;
+      let completed = false;
+      if (e.type === "voomly:video:ended" || e.type === "voomly:video:complete") {
+        completed = true;
+      }
+      if (currentTime > 0 || completed) {
+        const pct = duration ? Math.round(currentTime / duration * 100) : 0;
+        const isCompleted = stats.completed || completed || pct >= 90;
+        const newTimeWatched = Math.max(stats.timeWatched, Math.round(currentTime));
+        if (newTimeWatched !== stats.timeWatched || isCompleted !== stats.completed) {
+          stats = createStats2(newTimeWatched, isCompleted);
+          callUpdate();
+        }
+      }
+    } catch {
+    }
+  };
+  const windowEvents = ["voomly:video:play", "voomly:video:timeupdate", "voomly:video:ended", "voomly:video:progress"];
+  windowEvents.forEach((evt) => window.addEventListener(evt, handleVoomlyWindowEvents));
+  const stop = () => {
+    clearInterval(scanInterval);
+    clearInterval(pollingInterval);
+    trackedVideos.forEach((video) => {
+      video.removeEventListener("play", onPlay);
+      video.removeEventListener("pause", onPause);
+      video.removeEventListener("timeupdate", onTime);
+      video.removeEventListener("ended", onEnd);
+    });
+    windowEvents.forEach((evt) => window.removeEventListener(evt, handleVoomlyWindowEvents));
+    updateCallbacks = [];
+  };
+  return {
+    getStats: () => stats,
+    onUpdate: (cb) => {
+      updateCallbacks.push(cb);
+      return () => {
+        updateCallbacks = updateCallbacks.filter((x) => x !== cb);
+      };
+    },
+    stop
+  };
+};
+
+// src/trackers/html5-adapter.ts
+var createStats3 = (timeWatched, completed) => ({
+  timeWatched: Math.max(0, Math.round(timeWatched)),
+  completed,
+  lastUpdate: Date.now()
+});
+var trackHTML5Video = (videoId, videoElement) => {
+  let stats = createStats3(0, false);
+  let updateCallbacks = [];
+  const trackedMilestones = /* @__PURE__ */ new Set();
+  const callUpdate = () => {
+    updateCallbacks.forEach((cb) => cb(stats));
+  };
+  const onTimeUpdate = () => {
+    const ct = Math.round(videoElement.currentTime || 0);
+    const dur = videoElement.duration || 0;
+    const pct = dur > 0 ? Math.round(ct / dur * 100) : 0;
+    const newTime = Math.max(stats.timeWatched, ct);
+    const isCompleted = stats.completed || pct >= 95 || videoElement.ended;
+    if (newTime !== stats.timeWatched || isCompleted !== stats.completed) {
+      stats = createStats3(newTime, isCompleted);
+      callUpdate();
+    }
+    for (const milestone of [25, 50, 75]) {
+      if (pct >= milestone && !trackedMilestones.has(milestone)) {
+        trackedMilestones.add(milestone);
+      }
+    }
+  };
+  const onEnded = () => {
+    const dur = Math.round(videoElement.duration || 0);
+    stats = createStats3(Math.max(stats.timeWatched, dur), true);
+    callUpdate();
+  };
+  const onPlay = () => {
+    onTimeUpdate();
+  };
+  const onPause = () => {
+    onTimeUpdate();
+  };
+  videoElement.addEventListener("timeupdate", onTimeUpdate);
+  videoElement.addEventListener("ended", onEnded);
+  videoElement.addEventListener("play", onPlay);
+  videoElement.addEventListener("pause", onPause);
+  return {
+    getStats: () => stats,
+    onUpdate: (cb) => {
+      updateCallbacks.push(cb);
+      return () => {
+        updateCallbacks = updateCallbacks.filter((x) => x !== cb);
+      };
+    },
+    stop: () => {
+      videoElement.removeEventListener("timeupdate", onTimeUpdate);
+      videoElement.removeEventListener("ended", onEnded);
+      videoElement.removeEventListener("play", onPlay);
+      videoElement.removeEventListener("pause", onPause);
+      updateCallbacks = [];
+    }
+  };
+};
+
+// src/orchestrator/landing-tracker.ts
+var LandingTracker = class {
+  constructor() {
+    this.config = null;
+    this.isInitialized = false;
+    this.sessionStartTime = 0;
+    this.scrollMilestonesReached = /* @__PURE__ */ new Set();
+    this.clicks = [];
+    this.sectionTimers = /* @__PURE__ */ new Map();
+    this.observers = [];
+    this.listeners = [];
+  }
+  /**
+   * Inicializa el tracking de la landing con la configuración dada.
+   */
+  init(config) {
+    if (typeof window === "undefined") return;
+    if (this.isInitialized) return;
+    this.config = {
+      enableScrollTracking: true,
+      enableCTATracking: true,
+      enableTimeTracking: true,
+      enableSectionTracking: true,
+      enableFormTracking: true,
+      enableHeatmap: false,
+      eventSuffix: "",
+      ...config
+    };
+    this.isInitialized = true;
+    this.sessionStartTime = Date.now();
+    this.captureInitialData();
+    trackPageView(this.config.pagePath);
+    if (this.config.gtmId) {
+      injectGTMScript(this.config.gtmId);
+      pushToDataLayer(this.getEventName("page_load"), {
+        page_path: this.config.pagePath,
+        page_title: this.config.pageName,
+        timestamp: Date.now()
+      });
+    }
+    if (this.config.enableScrollTracking) this.initScrollTracking();
+    if (this.config.enableCTATracking) this.initCTATracking();
+    if (this.config.enableTimeTracking) this.initTimeTracking();
+    if (this.config.enableSectionTracking) this.initSectionTracking();
+    if (this.config.enableFormTracking) this.initFormTracking();
+    if (this.config.enableHeatmap) this.initClickHeatmap();
+    this.trackSessionStart();
+  }
+  /**
+   * Destruye el tracker y limpia todos los observers y listeners.
+   */
+  destroy() {
+    this.observers.forEach((obs) => obs.disconnect());
+    this.observers = [];
+    this.listeners.forEach(({ target, event, handler }) => {
+      target.removeEventListener(event, handler);
+    });
+    this.listeners = [];
+    this.isInitialized = false;
+    this.config = null;
+    this.scrollMilestonesReached.clear();
+    this.clicks = [];
+    this.sectionTimers.clear();
+  }
+  // ====================================
+  // MÉTODOS PÚBLICOS DE TRACKING
+  // ====================================
+  /** Trackear click en un CTA */
+  trackCTAClick(buttonName, section, additionalData) {
+    trackCTAClick(buttonName, section, additionalData);
+    this.pushGTMEvent("cta_click", { button_text: buttonName, section });
+  }
+  /** Trackear conversión */
+  trackConversion(type, value, additionalData) {
+    trackEvent("Conversion", type, void 0, value, additionalData);
+    this.pushGTMEvent("conversion", { conversion_type: type, value });
+  }
+  /** Trackear click en FAQs */
+  trackFAQExpand(question, index) {
+    trackEvent("FAQ", "expand", question, index);
+  }
+  /** Trackear click social */
+  trackSocialClick(platform, action) {
+    trackEvent("Social", "click", platform, void 0, { social_action: action });
+  }
+  /** Trackear click en imagen */
+  trackImageClick(imageName, section) {
+    trackEvent("Engagement", "image_click", imageName, void 0, { section });
+  }
+  /** Trackear scroll a sección */
+  trackScrollTo(section) {
+    trackEvent("Navigation", "scroll_to", section);
+  }
+  /** Trackear share */
+  trackShare(platform, content) {
+    trackEvent("Share", "click", platform, void 0, { share_content: content });
+  }
+  /** Trackear descarga */
+  trackDownload(fileName, fileType) {
+    trackEvent("Download", "click", fileName, void 0, { file_type: fileType });
+  }
+  /** Obtener datos de la sesión actual */
+  getSessionData() {
+    return {
+      duration: Math.round((Date.now() - this.sessionStartTime) / 1e3),
+      clicks: this.clicks.length,
+      scrollMilestones: Array.from(this.scrollMilestonesReached)
+    };
+  }
+  // ====================================
+  // MÉTODOS PRIVADOS
+  // ====================================
+  captureInitialData() {
+    const utmParams = captureUTMParams();
+    const userId = captureUserIdFromURL();
+    const userName = getUserName();
+    const prefix = this.config.pagePath.replace("/", "");
+    try {
+      localStorage.setItem(`${prefix}_entry_time`, (/* @__PURE__ */ new Date()).toISOString());
+      if (utmParams) {
+        localStorage.setItem(`${prefix}_utm_params`, JSON.stringify(utmParams));
+      }
+      if (userId) {
+        localStorage.setItem(`${prefix}_user_id`, userId);
+      }
+    } catch {
+    }
+    trackEvent("Landing", "page_load", this.config.pageName, void 0, {
+      page_path: this.config.pagePath,
+      user_id: userId,
+      user_name: userName,
+      utm_params: utmParams,
+      timestamp: Date.now()
+    });
+  }
+  trackSessionStart() {
+    trackEvent("Session", "start", this.config.pageName, void 0, {
+      page_path: this.config.pagePath,
+      timestamp: Date.now()
+    });
+  }
+  getEventName(baseName) {
+    const suffix = this.config?.eventSuffix || "";
+    return suffix ? `${baseName}${suffix}` : baseName;
+  }
+  pushGTMEvent(eventName, data) {
+    if (this.config?.gtmId) {
+      pushToDataLayer(this.getEventName(eventName), {
+        page_path: this.config.pagePath,
+        ...data
+      });
+    }
+  }
+  addListener(target, event, handler) {
+    target.addEventListener(event, handler);
+    this.listeners.push({ target, event, handler });
+  }
+  // --- Scroll Tracking ---
+  initScrollTracking() {
+    let scrollTimeout;
+    const handler = () => {
+      clearTimeout(scrollTimeout);
+      scrollTimeout = setTimeout(() => {
+        const scrollHeight = document.documentElement.scrollHeight - window.innerHeight;
+        if (scrollHeight <= 0) return;
+        const pct = Math.round(window.scrollY / scrollHeight * 100);
+        for (const milestone of [25, 50, 75, 100]) {
+          if (pct >= milestone && !this.scrollMilestonesReached.has(milestone)) {
+            this.scrollMilestonesReached.add(milestone);
+            trackEvent("Scroll", "milestone", `${milestone}%`, milestone, {
+              page_path: this.config.pagePath,
+              scroll_percentage: milestone
+            });
+            this.pushGTMEvent("scroll_milestone", { scroll_percentage: milestone });
+          }
+        }
+      }, 100);
+    };
+    this.addListener(window, "scroll", handler);
+  }
+  // --- CTA Tracking ---
+  initCTATracking() {
+    setTimeout(() => {
+      const ctaButtons = document.querySelectorAll('button, a[href*="#"], [data-cta]');
+      ctaButtons.forEach((button) => {
+        const handler = () => {
+          const el = button;
+          const text = el.textContent?.trim() || el.getAttribute("data-cta") || "Unknown CTA";
+          const section = el.closest("section")?.id || el.closest("[data-section]")?.getAttribute("data-section") || "unknown";
+          this.trackCTAClick(text, section);
+        };
+        this.addListener(button, "click", handler);
+      });
+    }, 2e3);
+  }
+  // --- Time Tracking (page exit) ---
+  initTimeTracking() {
+    const handler = () => {
+      const duration = Math.round((Date.now() - this.sessionStartTime) / 1e3);
+      trackEvent("Session", "end", this.config.pageName, duration, {
+        session_duration: duration,
+        page_path: this.config.pagePath,
+        exit_timestamp: Date.now()
+      });
+      this.pushGTMEvent("page_exit", {
+        session_duration: duration,
+        exit_timestamp: Date.now()
+      });
+    };
+    this.addListener(window, "beforeunload", handler);
+  }
+  // --- Section Dwell Time (IntersectionObserver) ---
+  initSectionTracking() {
+    const sectionEntryTimes = /* @__PURE__ */ new Map();
+    const observer = new IntersectionObserver(
+      (entries) => {
+        entries.forEach((entry) => {
+          const sectionId = entry.target.id || entry.target.getAttribute("data-section") || "unknown";
+          if (entry.isIntersecting) {
+            sectionEntryTimes.set(sectionId, Date.now());
+          } else {
+            const entryTime = sectionEntryTimes.get(sectionId);
+            if (entryTime) {
+              const seconds = (Date.now() - entryTime) / 1e3;
+              trackTimeInSection(sectionId, seconds);
+              sectionEntryTimes.delete(sectionId);
+            }
+          }
+        });
+      },
+      { threshold: 0.5 }
+    );
+    setTimeout(() => {
+      const sections = document.querySelectorAll("section, [data-section]");
+      sections.forEach((section) => observer.observe(section));
+    }, 1e3);
+    this.observers.push(observer);
+  }
+  // --- Form Auto-Tracking ---
+  initFormTracking() {
+    setTimeout(() => {
+      const forms = document.querySelectorAll("form");
+      forms.forEach((form) => {
+        const formName = form.getAttribute("name") || form.id || "unknown-form";
+        let started = false;
+        const inputs = form.querySelectorAll("input, textarea, select");
+        inputs.forEach((input) => {
+          this.addListener(input, "focus", (() => {
+            if (!started) {
+              started = true;
+              trackFormStart(formName);
+            }
+          }));
+        });
+        this.addListener(form, "submit", ((_e) => {
+          trackFormSubmit(formName, true, {
+            page_path: this.config.pagePath
+          });
+          this.pushGTMEvent("form_submit", { form_name: formName });
+        }));
+      });
+    }, 2e3);
+  }
+  // --- Click Heatmap ---
+  initClickHeatmap() {
+    const handler = (e) => {
+      const mouseEvent = e;
+      const target = mouseEvent.target;
+      const clickData = {
+        x: mouseEvent.clientX,
+        y: mouseEvent.clientY,
+        element: target.tagName.toLowerCase(),
+        section: target.closest("section")?.id || "unknown",
+        timestamp: Date.now(),
+        viewportWidth: window.innerWidth,
+        viewportHeight: window.innerHeight
+      };
+      this.clicks.push(clickData);
+    };
+    this.addListener(document, "click", handler);
+  }
+};
+var createLandingTracker = (config) => {
+  const tracker = new LandingTracker();
+  tracker.init(config);
+  return tracker;
+};
+
+// src/persistence/api-client.ts
+var apiConfig = null;
+var initTrackingAPI = (config) => {
+  apiConfig = {
+    ...config,
+    baseUrl: config.baseUrl.replace(/\/+$/, "")
+  };
+};
+var getAPIConfig = () => {
+  if (!apiConfig) {
+    throw new Error("[@metodokorexmk/tracking] initTrackingAPI() debe llamarse antes de usar funciones de persistencia.");
+  }
+  return apiConfig;
+};
+var isTrackingAPIInitialized = () => apiConfig !== null;
+var buildHeaders = () => {
+  const config = getAPIConfig();
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (config.getAuthToken) {
+    const token = config.getAuthToken();
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+  }
+  if (config.getCustomHeaders) {
+    Object.assign(headers, config.getCustomHeaders());
+  }
+  return headers;
+};
+var apiGet = async (path) => {
+  const config = getAPIConfig();
+  const url = `${config.baseUrl}${path}`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: buildHeaders(),
+    credentials: "include"
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "");
+    throw new Error(`API GET ${path} failed (${response.status}): ${errorText}`);
+  }
+  return response.json();
+};
+var apiPost = async (path, body) => {
+  const config = getAPIConfig();
+  const url = `${config.baseUrl}${path}`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: buildHeaders(),
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "");
+    throw new Error(`API POST ${path} failed (${response.status}): ${errorText}`);
+  }
+  return response.json();
+};
+
+// src/persistence/lead-submission.ts
+var extractUrlParams = (url) => {
+  if (typeof window === "undefined" && !url) {
+    return {
+      userId: "",
+      idCampana: "",
+      utmContent: "",
+      fbclid: "",
+      nombreNetworker: "",
+      whatsapp: "",
+      pipelineId: "",
+      leadCampaing: "Funnel Organico",
+      isOrganico: true
+    };
+  }
+  let searchParams;
+  if (url) {
+    try {
+      const urlObj = new URL(url);
+      searchParams = new URLSearchParams(urlObj.search);
+    } catch {
+      searchParams = new URLSearchParams();
+    }
+  } else {
+    searchParams = new URLSearchParams(window.location.search);
+  }
+  const userId = searchParams.get("user_id") || "";
+  const idCampana = searchParams.get("campaign_id") || searchParams.get("utm_id") || "";
+  const utmContent = searchParams.get("utm_content") || "";
+  const fbclid = searchParams.get("fbclid") || "";
+  const whatsapp = searchParams.get("whatsapp") || "";
+  const nombreNetworker = searchParams.get("user_name") || searchParams.get("networker") || searchParams.get("name") || "";
+  const pipelineId = searchParams.get("pipeline_id") || "";
+  const funnelId = searchParams.get("funnel_id") || "";
+  const metricId = searchParams.get("metric_id") || "";
+  const utmSource = searchParams.get("utm_source") || "";
+  const utmMedium = searchParams.get("utm_medium") || "";
+  const utmCampaign = searchParams.get("utm_campaign") || "";
+  const isOrganico = !!(whatsapp && !idCampana && !fbclid);
+  const leadCampaing = fbclid ? "Funnel FB" : "Funnel Organico";
+  return {
+    userId,
+    idCampana,
+    utmContent,
+    fbclid,
+    nombreNetworker,
+    whatsapp,
+    pipelineId,
+    funnelId,
+    metricId,
+    utmSource,
+    utmMedium,
+    utmCampaign,
+    leadCampaing,
+    isOrganico
+  };
+};
+var detectLeadOrigin = (url) => {
+  const params = extractUrlParams(url);
+  const hasCampaign = Boolean(params.idCampana || params.fbclid);
+  const type = hasCampaign ? "facebook" : "organic";
+  const endpoint = hasCampaign ? "/tracking/create-with-lead-and-distribution" : "/tracking/create-organic-lead";
+  return { type, endpoint, params, hasCampaign };
+};
+var buildTrackingRequestBody = (params, formData, origin, options) => {
+  const collaboratorId = params.userId ? parseInt(params.userId, 10) : null;
+  const telefonoLimpio = formData.telefono.replace(/\s+/g, "");
+  const body = {
+    userName: formData.nombre.trim(),
+    userEmail: formData.correo.trim(),
+    entryDate: (/* @__PURE__ */ new Date()).toISOString(),
+    accessUrl: typeof window !== "undefined" ? window.location.href : "",
+    leadName: formData.nombre.trim(),
+    leadEmail: formData.correo.trim(),
+    leadPhone: formData.countryLada ? `${formData.countryLada}${telefonoLimpio}` : telefonoLimpio
+  };
+  if (options?.nameForm) body.nameForm = options.nameForm;
+  if (options?.msgForm) body.msgForm = options.msgForm;
+  if (options?.status) body.status = options.status;
+  if (options?.whatsappSent !== void 0) body.whatsapp_sent = options.whatsappSent;
+  if (options?.dwellTime !== void 0) body.dwellTime = options.dwellTime;
+  if (options?.videoTimeWatched !== void 0) body.videoTimeWatched = options.videoTimeWatched;
+  if (options?.videoCompleted !== void 0) {
+    body.videoCompleted = options.videoCompleted;
+    body.video_completed = options.videoCompleted;
+  }
+  if (origin.hasCampaign) {
+    if (collaboratorId) body.userId = collaboratorId;
+    if (params.idCampana) body.idCampana = params.idCampana;
+    if (params.utmContent) body.utmContent = params.utmContent;
+    if (params.fbclid) body.fbclid = params.fbclid;
+  } else if (collaboratorId) {
+    body.referringUserId = collaboratorId;
+    body.referring_user_id = collaboratorId;
+  }
+  if (params.pipelineId) {
+    const parsed = parseInt(params.pipelineId, 10);
+    if (!isNaN(parsed)) body.pipeline_id = parsed;
+  }
+  if (params.funnelId) {
+    const parsed = parseInt(params.funnelId, 10);
+    if (!isNaN(parsed)) body.funnel_id = parsed;
+  }
+  if (params.metricId) {
+    const parsed = parseInt(params.metricId, 10);
+    if (!isNaN(parsed)) body.metric_id = parsed;
+  }
+  if (options?.additionalFields) {
+    Object.assign(body, options.additionalFields);
+  }
+  return body;
+};
+var submitTrackingLead = async (body, origin) => {
+  const config = getAPIConfig();
+  const fullUrl = `${config.baseUrl}${origin.endpoint}`;
+  try {
+    const response = await fetch(fullUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    let data = null;
+    try {
+      const text = await response.text();
+      if (text) {
+        const parsed = JSON.parse(text);
+        if (parsed && typeof parsed === "object") {
+          data = parsed;
+        }
+      }
+    } catch {
+    }
+    return { ok: response.ok, status: response.status, data };
+  } catch {
+    return { ok: false, status: 0, data: null };
+  }
+};
+var submitLead = async (formData, options, url) => {
+  const origin = detectLeadOrigin(url);
+  const body = buildTrackingRequestBody(origin.params, formData, origin, options);
+  return submitTrackingLead(body, origin);
+};
+var updateTrackingLead = async (trackingId, updates) => {
+  const config = getAPIConfig();
+  const url = `${config.baseUrl}/tracking/${trackingId}`;
+  try {
+    const response = await fetch(url, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(updates)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+};
+var markWhatsAppSent = async (leadId) => {
+  const config = getAPIConfig();
+  const url = `${config.baseUrl}/tracking/lead/${leadId}/whatsapp-sent`;
+  try {
+    const response = await fetch(url, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ whatsapp_sent: true })
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+};
+var buildMsgFormJSON = (mensaje, datosAdicionales) => {
+  return JSON.stringify({ mensaje: mensaje || "", ...datosAdicionales });
+};
+
+// src/persistence/dwell-time-tracker.ts
+var DwellTimeTracker = class {
+  constructor() {
+    this.startTime = null;
+    this.trackingDataId = null;
+    this.enabled = false;
+    this.intervalId = null;
+    this.isSending = false;
+    this.videoTimeWatched = 0;
+    this.videoCompleted = false;
+    this.videoTrackingStopped = false;
+    this.lastDwellTimeSent = 0;
+    this.lastVideoTimeSent = 0;
+    this.pausedTime = 0;
+    this.pauseStartTime = null;
+    this.boundBeforeUnload = this.handleBeforeUnload.bind(this);
+    this.boundVisibilityChange = this.handleVisibilityChange.bind(this);
+  }
+  /**
+   * Inicia el tracking del tiempo de permanencia.
+   */
+  start(config) {
+    if (typeof window === "undefined") return;
+    const wasAlreadyTracking = this.enabled;
+    this.enabled = config.enabled !== false;
+    this.trackingDataId = config.trackingDataId;
+    this.onSuccess = config.onSuccess;
+    this.onError = config.onError;
+    if (!this.enabled) return;
+    this.cleanupListeners();
+    window.addEventListener("beforeunload", this.boundBeforeUnload);
+    document.addEventListener("visibilitychange", this.boundVisibilityChange);
+    if (!wasAlreadyTracking) {
+      this.startTime = Date.now();
+    }
+    if (!this.intervalId) {
+      this.intervalId = setInterval(() => {
+        if (this.videoCompleted && this.videoTrackingStopped) {
+          if (document.visibilityState === "visible" && this.startTime) {
+            this.sendDwellTime(false);
+          }
+          return;
+        }
+        if (this.videoCompleted && !this.videoTrackingStopped) {
+          this.sendDwellTime(false);
+          this.videoTrackingStopped = true;
+          return;
+        }
+        if (document.visibilityState === "visible" && this.startTime) {
+          this.sendDwellTime(false);
+        }
+      }, 3e4);
+    }
+    this.retryPendingUpdates();
+  }
+  /**
+   * Detiene el tracking y envía el tiempo acumulado.
+   */
+  stop() {
+    if (this.startTime) {
+      this.sendDwellTime(true);
+    }
+    this.startTime = null;
+    this.lastVideoTimeSent = 0;
+    this.lastDwellTimeSent = 0;
+    this.videoTrackingStopped = false;
+    this.pausedTime = 0;
+    this.pauseStartTime = null;
+    this.cleanup();
+  }
+  /**
+   * Obtiene el tiempo transcurrido en segundos (restando tiempo pausado).
+   */
+  getElapsedTime() {
+    if (!this.startTime) return 0;
+    const totalTime = Math.floor((Date.now() - this.startTime) / 1e3);
+    let currentPauseTime = this.pausedTime;
+    if (this.pauseStartTime !== null) {
+      currentPauseTime += Math.floor((Date.now() - this.pauseStartTime) / 1e3);
+    }
+    return Math.max(0, totalTime - currentPauseTime);
+  }
+  /**
+   * Actualiza manualmente el tiempo del video.
+   * Llamar desde el VideoTracker u otros adaptadores.
+   */
+  updateVideoTime(videoTimeWatched, videoCompleted = false) {
+    const hasNewTime = videoTimeWatched > this.videoTimeWatched;
+    const hasNewCompletion = videoCompleted && !this.videoCompleted;
+    if (hasNewTime || hasNewCompletion) {
+      this.videoTimeWatched = Math.max(this.videoTimeWatched, videoTimeWatched);
+      this.videoCompleted = videoCompleted || this.videoCompleted;
+      if (this.trackingDataId && this.trackingDataId !== "pending" && this.startTime && hasNewCompletion) {
+        this.sendDwellTime(false);
+      }
+    }
+  }
+  /**
+   * Actualiza el trackingDataId (útil cuando se obtiene después del registro).
+   */
+  updateTrackingId(trackingDataId) {
+    if (!trackingDataId || typeof trackingDataId === "string" && trackingDataId.trim() === "") return;
+    const oldTrackingId = this.trackingDataId;
+    this.trackingDataId = trackingDataId;
+    if (oldTrackingId === "pending" && this.trackingDataId !== "pending") {
+      this.lastDwellTimeSent = 0;
+      this.lastVideoTimeSent = 0;
+      this.videoTrackingStopped = false;
+    }
+    if (this.startTime && oldTrackingId === "pending") {
+      this.sendDwellTime(false);
+    }
+    if (!this.intervalId && this.enabled && this.startTime) {
+      this.intervalId = setInterval(() => {
+        if (document.visibilityState === "visible" && this.startTime) {
+          this.sendDwellTime(false);
+        }
+      }, 3e4);
+    }
+  }
+  /**
+   * Limpia todos los listeners y timers.
+   */
+  destroy() {
+    this.stop();
+  }
+  // ====================================
+  // PRIVATE
+  // ====================================
+  checkLocalStorageForId() {
+    if (typeof window === "undefined") return;
+    if (!this.trackingDataId || this.trackingDataId === "pending") {
+      const tid = localStorage.getItem("tracking_id") || localStorage.getItem("landing_tracking_id");
+      if (tid) this.updateTrackingId(tid);
+    }
+  }
+  async sendDwellTime(isFinal = false) {
+    if (!isTrackingAPIInitialized()) return;
+    this.checkLocalStorageForId();
+    if (!this.startTime || this.isSending) return;
+    if (!this.trackingDataId || this.trackingDataId === "pending") return;
+    const trackingIdNum = typeof this.trackingDataId === "string" ? parseInt(this.trackingDataId, 10) : this.trackingDataId;
+    if (isNaN(trackingIdNum) || trackingIdNum <= 0) return;
+    const elapsedTime = this.getElapsedTime();
+    if (elapsedTime < 1 && !isFinal) return;
+    this.isSending = true;
+    const config = getAPIConfig();
+    const token = config.getAuthToken?.() ?? null;
+    try {
+      const url = `${config.baseUrl}/tracking/${trackingIdNum}`;
+      const headers = { "Content-Type": "application/json" };
+      if (token) headers.Authorization = `Bearer ${token}`;
+      const body = { dwellTime: elapsedTime };
+      if (this.videoTimeWatched > 0 && !this.videoTrackingStopped) {
+        body.videoTimeWatched = this.videoTimeWatched;
+        body.videoCompleted = this.videoCompleted;
+      }
+      this.lastDwellTimeSent = elapsedTime;
+      if (this.videoTimeWatched > 0 && !this.videoTrackingStopped) {
+        this.lastVideoTimeSent = this.videoTimeWatched;
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 1e4);
+      const response = await fetch(url, {
+        method: "PATCH",
+        headers,
+        body: JSON.stringify(body),
+        keepalive: isFinal,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`Error ${response.status}: ${response.statusText}`);
+      }
+      this.onSuccess?.();
+      this.clearPendingUpdate();
+    } catch (error) {
+      const err = error;
+      const isNetworkError = err.name === "AbortError" || err.name === "TimeoutError" || err.name === "TypeError" && err.message?.includes("Failed to fetch");
+      if (token) this.savePendingUpdate(elapsedTime);
+      if (this.onError && !isNetworkError) {
+        this.onError(error instanceof Error ? error : new Error("Error desconocido"));
+      }
+    } finally {
+      this.isSending = false;
+    }
+  }
+  handleBeforeUnload(_event) {
+    this.sendDwellTimeWithBeacon();
+  }
+  handleVisibilityChange() {
+    if (document.visibilityState === "hidden") {
+      if (this.pauseStartTime === null && this.startTime) {
+        this.pauseStartTime = Date.now();
+        this.sendDwellTime(false);
+      }
+    } else if (document.visibilityState === "visible") {
+      if (this.pauseStartTime !== null) {
+        this.pausedTime += Math.floor((Date.now() - this.pauseStartTime) / 1e3);
+        this.pauseStartTime = null;
+      } else if (!this.startTime) {
+        this.startTime = Date.now();
+        this.pausedTime = 0;
+        this.pauseStartTime = null;
+      }
+    }
+  }
+  sendDwellTimeWithBeacon() {
+    if (!isTrackingAPIInitialized()) return;
+    this.checkLocalStorageForId();
+    if (!this.startTime || !this.trackingDataId || this.trackingDataId === "pending") return;
+    const trackingIdNum = typeof this.trackingDataId === "string" ? parseInt(this.trackingDataId, 10) : this.trackingDataId;
+    if (isNaN(trackingIdNum) || trackingIdNum <= 0) return;
+    const config = getAPIConfig();
+    const elapsedTime = this.getElapsedTime();
+    const token = config.getAuthToken?.() ?? null;
+    const body = { dwellTime: elapsedTime };
+    if (this.videoTimeWatched > 0 && !this.videoTrackingStopped) {
+      body.videoTimeWatched = this.videoTimeWatched;
+      body.videoCompleted = this.videoCompleted;
+    }
+    if (token) this.savePendingUpdate(elapsedTime);
+    const url = `${config.baseUrl}/tracking/${trackingIdNum}`;
+    const headers = { "Content-Type": "application/json" };
+    if (token) headers.Authorization = `Bearer ${token}`;
+    fetch(url, {
+      method: "PATCH",
+      headers,
+      body: JSON.stringify(body),
+      keepalive: true
+    }).then((response) => {
+      if (response.ok) this.clearPendingUpdate();
+    }).catch(() => {
+    });
+  }
+  savePendingUpdate(time) {
+    if (typeof window === "undefined" || !this.trackingDataId) return;
+    try {
+      sessionStorage.setItem("dwellTime_pending", JSON.stringify({ trackingDataId: this.trackingDataId, time, timestamp: Date.now() }));
+    } catch {
+    }
+  }
+  async retryPendingUpdates() {
+    if (typeof window === "undefined" || !isTrackingAPIInitialized()) return;
+    try {
+      const pendingData = sessionStorage.getItem("dwellTime_pending");
+      if (!pendingData) return;
+      const { trackingDataId, time } = JSON.parse(pendingData);
+      if (trackingDataId !== this.trackingDataId) {
+        this.clearPendingUpdate();
+        return;
+      }
+      const config = getAPIConfig();
+      const token = config.getAuthToken?.() ?? null;
+      if (!token) {
+        this.clearPendingUpdate();
+        return;
+      }
+      const url = `${config.baseUrl}/tracking/${trackingDataId}`;
+      const response = await fetch(url, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+        body: JSON.stringify({ dwellTime: time })
+      });
+      if (response.ok) this.clearPendingUpdate();
+    } catch {
+    }
+  }
+  clearPendingUpdate() {
+    if (typeof window === "undefined") return;
+    try {
+      sessionStorage.removeItem("dwellTime_pending");
+    } catch {
+    }
+  }
+  cleanupListeners() {
+    if (typeof window === "undefined") return;
+    window.removeEventListener("beforeunload", this.boundBeforeUnload);
+    document.removeEventListener("visibilitychange", this.boundVisibilityChange);
+  }
+  cleanup() {
+    if (typeof window === "undefined") return;
+    this.cleanupListeners();
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+};
+var dwellTimeTracker = new DwellTimeTracker();
+var startDwellTimeTracking = (config) => {
+  dwellTimeTracker.start(config);
+};
+var stopDwellTimeTracking = () => {
+  dwellTimeTracker.stop();
+};
+
+// src/persistence/tracking-queries.ts
+var getTrackingById = async (trackingId) => {
+  return apiGet(`/tracking/${trackingId}`);
+};
+var getLeadWithTracking = async (leadId) => {
+  const defaultData = {
+    videoVisto: false,
+    tiempoReproducido: "00:00",
+    envioWhatsapp: false,
+    videoTimeWatched: 0,
+    dwellTime: 0
+  };
+  try {
+    const data = await apiGet(`/leads/${leadId}/with-tracking`);
+    const trackingDataArray = data.trackingData;
+    const trackingInfo = trackingDataArray && trackingDataArray.length > 0 ? trackingDataArray[0] : null;
+    const leadData = data;
+    if (!trackingInfo) {
+      return {
+        ...defaultData,
+        accessUrl: leadData.accessUrl,
+        nameForm: leadData.nameForm,
+        msgForm: leadData.msgForm,
+        platform: leadData.plataforma || leadData.platform,
+        aliasName: leadData.aliasName || leadData.campaignName
+      };
+    }
+    const formatTime = (seconds) => {
+      const minutes = Math.floor(seconds / 60);
+      const remainingSeconds = seconds % 60;
+      return `${minutes.toString().padStart(2, "0")}:${remainingSeconds.toString().padStart(2, "0")}`;
+    };
+    const videoTimeWatched = trackingInfo.videoTimeWatched || 0;
+    const dwellTime = trackingInfo.dwellTime || trackingInfo.dwell_time || 0;
+    return {
+      videoVisto: trackingInfo.videoCompleted || false,
+      tiempoReproducido: videoTimeWatched ? formatTime(videoTimeWatched) : "00:00",
+      envioWhatsapp: trackingInfo.whatsappSent || false,
+      accessUrl: trackingInfo.accessUrl || leadData.accessUrl,
+      nameForm: trackingInfo.nameForm || leadData.nameForm,
+      msgForm: trackingInfo.msgForm || leadData.msgForm,
+      platform: leadData.plataforma || leadData.platform || trackingInfo.platform,
+      aliasName: leadData.aliasName || leadData.campaignName || trackingInfo.aliasName,
+      trackingId: trackingInfo.id,
+      videoTimeWatched,
+      dwellTime
+    };
+  } catch {
+    return defaultData;
+  }
+};
+var generateTrackingLink = async (funnelId, customDomain) => {
+  return apiPost("/tracking/generate-link", {
+    funnel_id: funnelId,
+    custom_domain: customDomain
+  });
+};
+
+exports.DwellTimeTracker = DwellTimeTracker;
+exports.LandingTracker = LandingTracker;
+exports.VideoTracker = VideoTracker;
+exports.buildMsgFormJSON = buildMsgFormJSON;
+exports.buildTrackingRequestBody = buildTrackingRequestBody;
+exports.captureUTMParams = captureUTMParams;
+exports.captureUserIdFromURL = captureUserIdFromURL;
+exports.createLandingTracker = createLandingTracker;
+exports.detectLeadOrigin = detectLeadOrigin;
+exports.dwellTimeTracker = dwellTimeTracker;
+exports.extractUrlParams = extractUrlParams;
+exports.generateTrackingLink = generateTrackingLink;
+exports.getGATrackingId = getGATrackingId;
+exports.getLeadWithTracking = getLeadWithTracking;
+exports.getTrackingById = getTrackingById;
+exports.getUserId = getUserId;
+exports.getUserName = getUserName;
+exports.initGA = initGA;
+exports.initTrackingAPI = initTrackingAPI;
+exports.injectGTMScript = injectGTMScript;
+exports.isGAInitialized = isGAInitialized;
+exports.isTrackingAPIInitialized = isTrackingAPIInitialized;
+exports.markWhatsAppSent = markWhatsAppSent;
+exports.pushToDataLayer = pushToDataLayer;
+exports.reinitGA = reinitGA;
+exports.resetAnalytics = resetAnalytics;
+exports.setUserId = setUserId;
+exports.setUserName = setUserName;
+exports.startDwellTimeTracking = startDwellTimeTracking;
+exports.stopDwellTimeTracking = stopDwellTimeTracking;
+exports.submitLead = submitLead;
+exports.submitTrackingLead = submitTrackingLead;
+exports.trackCTAClick = trackCTAClick;
+exports.trackContactClick = trackContactClick;
+exports.trackConversion = trackConversion;
+exports.trackDownload = trackDownload;
+exports.trackEvent = trackEvent;
+exports.trackFAQExpand = trackFAQExpand;
+exports.trackFormFieldComplete = trackFormFieldComplete;
+exports.trackFormStart = trackFormStart;
+exports.trackFormSubmit = trackFormSubmit;
+exports.trackFormValidationError = trackFormValidationError;
+exports.trackHTML5Video = trackHTML5Video;
+exports.trackImageClick = trackImageClick;
+exports.trackPageView = trackPageView;
+exports.trackPricingCardClick = trackPricingCardClick;
+exports.trackScrollTo = trackScrollTo;
+exports.trackSectionClick = trackSectionClick;
+exports.trackShare = trackShare;
+exports.trackSocialClick = trackSocialClick;
+exports.trackTimeInSection = trackTimeInSection;
+exports.trackVoomlyByEmbedId = trackVoomlyByEmbedId;
+exports.trackWistiaByMediaId = trackWistiaByMediaId;
+exports.updateTrackingLead = updateTrackingLead;
+exports.videoTracker = videoTracker;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map