@uptrademedia/site-kit 1.0.0

package/dist/chunk-FKVJOT2F.mjs

@@ -0,0 +1,796 @@
+import { createContext, useEffect, useRef, useCallback, useMemo, useContext } from 'react';
+import { usePathname, useSearchParams } from 'next/navigation';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+// src/analytics/WebVitals.tsx
+function getApiConfig() {
+  const apiUrl = typeof window !== "undefined" ? window.__SITE_KIT_API_URL__ || "https://api.uptrademedia.com" : "https://api.uptrademedia.com";
+  const apiKey = typeof window !== "undefined" ? window.__SITE_KIT_API_KEY__ : void 0;
+  return { apiUrl, apiKey };
+}
+function WebVitals({ apiUrl: propApiUrl, apiKey: propApiKey, debug = false }) {
+  const pathname = usePathname();
+  useEffect(() => {
+    import('./web-vitals-RJYPWAR3.mjs').then(({ onCLS, onLCP, onTTFB, onINP, onFCP }) => {
+      const vitals = {};
+      let reported = false;
+      const reportVitals = async () => {
+        if (reported) return;
+        if (Object.keys(vitals).length === 0) return;
+        reported = true;
+        const { apiUrl: globalApiUrl, apiKey: globalApiKey } = getApiConfig();
+        const apiUrl = propApiUrl || globalApiUrl;
+        const apiKey = propApiKey || globalApiKey;
+        if (!apiKey) {
+          if (debug) console.warn("[Analytics] No API key configured for Web Vitals");
+          return;
+        }
+        for (const [name, value] of Object.entries(vitals)) {
+          const data = {
+            pagePath: pathname,
+            metricName: name,
+            metricValue: value,
+            metricRating: getRating(name, value)
+          };
+          if (debug) {
+            console.log("[Analytics] Web Vital:", data);
+          }
+          try {
+            await fetch(`${apiUrl}/api/public/analytics/web-vitals`, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                "x-api-key": apiKey
+              },
+              body: JSON.stringify(data)
+            });
+          } catch (error) {
+            if (debug) console.error("[Analytics] Error reporting Web Vital:", error);
+          }
+        }
+      };
+      onLCP((metric) => {
+        vitals.LCP = metric.value;
+        if (debug) console.log("[Analytics] LCP:", metric.value);
+      });
+      onCLS((metric) => {
+        vitals.CLS = metric.value;
+        if (debug) console.log("[Analytics] CLS:", metric.value);
+      });
+      onTTFB((metric) => {
+        vitals.TTFB = metric.value;
+        if (debug) console.log("[Analytics] TTFB:", metric.value);
+      });
+      onINP((metric) => {
+        vitals.INP = metric.value;
+        if (debug) console.log("[Analytics] INP:", metric.value);
+      });
+      onFCP((metric) => {
+        vitals.FCP = metric.value;
+        if (debug) console.log("[Analytics] FCP:", metric.value);
+      });
+      const handleVisibilityChange = () => {
+        if (document.visibilityState === "hidden") {
+          reportVitals();
+        }
+      };
+      document.addEventListener("visibilitychange", handleVisibilityChange);
+      const timeout = setTimeout(reportVitals, 1e4);
+      return () => {
+        document.removeEventListener("visibilitychange", handleVisibilityChange);
+        clearTimeout(timeout);
+      };
+    });
+  }, [pathname, propApiUrl, propApiKey, debug]);
+  return null;
+}
+function getRating(name, value) {
+  const thresholds = {
+    LCP: [2500, 4e3],
+    CLS: [0.1, 0.25],
+    TTFB: [800, 1800],
+    INP: [200, 500],
+    FCP: [1800, 3e3]
+  };
+  const [good, poor] = thresholds[name] || [0, 0];
+  if (value <= good) return "good";
+  if (value <= poor) return "needs-improvement";
+  return "poor";
+}
+var AnalyticsContext = createContext(null);
+function generateId() {
+  return crypto.randomUUID();
+}
+function scheduleIdleTask(callback, timeout = 2e3) {
+  if (typeof window !== "undefined" && "requestIdleCallback" in window) {
+    window.requestIdleCallback(
+      callback,
+      { timeout }
+    );
+  } else {
+    setTimeout(callback, 0);
+  }
+}
+function getOrCreateVisitorId() {
+  if (typeof window === "undefined") return "";
+  const key = "_uptrade_vid";
+  let visitorId = localStorage.getItem(key);
+  if (!visitorId) {
+    visitorId = generateId();
+    localStorage.setItem(key, visitorId);
+  }
+  return visitorId;
+}
+function getSessionId(timeout) {
+  if (typeof window === "undefined") return "";
+  const key = "_uptrade_sid";
+  const timeKey = "_uptrade_stime";
+  const now = Date.now();
+  const timeoutMs = timeout * 60 * 1e3;
+  const existingSession = sessionStorage.getItem(key);
+  const lastActivity = sessionStorage.getItem(timeKey);
+  if (existingSession && lastActivity) {
+    const elapsed = now - parseInt(lastActivity, 10);
+    if (elapsed < timeoutMs) {
+      sessionStorage.setItem(timeKey, now.toString());
+      return existingSession;
+    }
+  }
+  const newSession = generateId();
+  sessionStorage.setItem(key, newSession);
+  sessionStorage.setItem(timeKey, now.toString());
+  return newSession;
+}
+function getDeviceType() {
+  if (typeof window === "undefined") return "desktop";
+  const ua = navigator.userAgent;
+  if (/tablet|ipad|playbook|silk/i.test(ua)) return "tablet";
+  if (/mobile|iphone|ipod|android|blackberry|opera mini|iemobile/i.test(ua)) return "mobile";
+  return "desktop";
+}
+function getBrowser() {
+  if (typeof window === "undefined") return "unknown";
+  const ua = navigator.userAgent;
+  if (ua.includes("Firefox")) return "Firefox";
+  if (ua.includes("Edg")) return "Edge";
+  if (ua.includes("Chrome")) return "Chrome";
+  if (ua.includes("Safari")) return "Safari";
+  if (ua.includes("Opera") || ua.includes("OPR")) return "Opera";
+  return "Other";
+}
+function getOS() {
+  if (typeof window === "undefined") return "unknown";
+  const ua = navigator.userAgent;
+  if (ua.includes("Windows")) return "Windows";
+  if (ua.includes("Mac OS X") || ua.includes("Macintosh")) return "macOS";
+  if (ua.includes("iPhone") || ua.includes("iPad")) return "iOS";
+  if (ua.includes("Android")) return "Android";
+  if (ua.includes("Linux")) return "Linux";
+  if (ua.includes("CrOS")) return "ChromeOS";
+  return "Other";
+}
+function getUserAgent() {
+  if (typeof window === "undefined") return "";
+  return navigator.userAgent;
+}
+function getUTMParams() {
+  if (typeof window === "undefined") return {};
+  const params = new URLSearchParams(window.location.search);
+  const utmParams = {};
+  for (const key of ["utm_source", "utm_medium", "utm_campaign", "utm_term", "utm_content"]) {
+    const value = params.get(key);
+    if (value) utmParams[key] = value;
+  }
+  return utmParams;
+}
+function getPageMetadata() {
+  if (typeof document === "undefined") return {};
+  const getMeta = (name) => {
+    const el = document.querySelector(`meta[name="${name}"], meta[property="${name}"]`);
+    return el?.getAttribute("content") || null;
+  };
+  const getCanonical = () => {
+    const el = document.querySelector('link[rel="canonical"]');
+    return el?.getAttribute("href") || null;
+  };
+  const getRobots = () => {
+    return getMeta("robots");
+  };
+  const getH1 = () => {
+    const h1 = document.querySelector("h1");
+    return h1?.textContent?.trim() || null;
+  };
+  const getH1Count = () => {
+    return document.querySelectorAll("h1").length;
+  };
+  const getWordCount = () => {
+    const main = document.querySelector('main, article, [role="main"]') || document.body;
+    const text = main.textContent || "";
+    return text.split(/\s+/).filter((w) => w.length > 0).length;
+  };
+  const getImageStats = () => {
+    const images = document.querySelectorAll("img");
+    let withoutAlt = 0;
+    images.forEach((img) => {
+      if (!img.alt || img.alt.trim() === "") withoutAlt++;
+    });
+    return { count: images.length, withoutAlt };
+  };
+  const getLinkStats = () => {
+    const links = document.querySelectorAll("a[href]");
+    const currentHost = window.location.host;
+    let internal = 0;
+    let external = 0;
+    const internalLinks = [];
+    const getLinkPosition = (el) => {
+      let current = el;
+      while (current) {
+        const tag = current.tagName?.toLowerCase();
+        const role = current.getAttribute("role");
+        if (tag === "header" || role === "banner") return "header";
+        if (tag === "nav" || role === "navigation") return "nav";
+        if (tag === "footer" || role === "contentinfo") return "footer";
+        if (tag === "aside" || role === "complementary") return "sidebar";
+        if (tag === "main" || tag === "article" || role === "main") return "content";
+        current = current.parentElement;
+      }
+      return "unknown";
+    };
+    links.forEach((link) => {
+      const href = link.getAttribute("href") || "";
+      const rel = link.getAttribute("rel") || "";
+      const isNofollow = rel.includes("nofollow");
+      let isInternal = false;
+      let targetPath = "";
+      if (href.startsWith("/") && !href.startsWith("//")) {
+        isInternal = true;
+        targetPath = href.split("?")[0].split("#")[0];
+      } else if (href.startsWith("#")) {
+        internal++;
+        return;
+      } else if (href.startsWith("http")) {
+        try {
+          const url = new URL(href);
+          if (url.host === currentHost) {
+            isInternal = true;
+            targetPath = url.pathname;
+          } else {
+            external++;
+          }
+        } catch {
+        }
+      }
+      if (isInternal && targetPath) {
+        internal++;
+        if (!targetPath.startsWith("/")) targetPath = "/" + targetPath;
+        if (targetPath !== "/" && targetPath.endsWith("/")) {
+          targetPath = targetPath.slice(0, -1);
+        }
+        internalLinks.push({
+          targetPath,
+          anchorText: (link.textContent || "").trim().slice(0, 200),
+          position: getLinkPosition(link),
+          isNofollow
+        });
+      }
+    });
+    return { internal, external, internalLinks };
+  };
+  const imageStats = getImageStats();
+  const linkStats = getLinkStats();
+  return {
+    metaDescription: getMeta("description"),
+    canonical: getCanonical(),
+    robots: getRobots(),
+    ogTitle: getMeta("og:title"),
+    ogDescription: getMeta("og:description"),
+    ogImage: getMeta("og:image"),
+    h1: getH1(),
+    h1Count: getH1Count(),
+    wordCount: getWordCount(),
+    imagesCount: imageStats.count,
+    imagesWithoutAlt: imageStats.withoutAlt,
+    internalLinks: linkStats.internal,
+    internalLinkTargets: linkStats.internalLinks,
+    // Full link graph data
+    externalLinks: linkStats.external
+  };
+}
+function getApiConfig2() {
+  const apiUrl = typeof window !== "undefined" ? window.__SITE_KIT_API_URL__ || "https://api.uptrademedia.com" : "https://api.uptrademedia.com";
+  const apiKey = typeof window !== "undefined" ? window.__SITE_KIT_API_KEY__ : void 0;
+  return { apiUrl, apiKey };
+}
+function AnalyticsProvider({
+  children,
+  apiUrl: propApiUrl,
+  apiKey: propApiKey,
+  trackPageViews = true,
+  trackWebVitals = true,
+  trackScrollDepth = true,
+  trackClicks = true,
+  trackJourneys = true,
+  // NEW: Enable journey tracking by default
+  sessionTimeout = 30,
+  excludePaths = [],
+  validateAgainstSitemap = true,
+  debug = false
+}) {
+  const pathname = usePathname();
+  const searchParams = useSearchParams();
+  const visitorIdRef = useRef("");
+  const sessionIdRef = useRef("");
+  const lastPathRef = useRef("");
+  const validPathsRef = useRef(null);
+  const journeyStartTimeRef = useRef(0);
+  const pageEnterTimeRef = useRef(0);
+  const currentScrollDepthRef = useRef(0);
+  useEffect(() => {
+    visitorIdRef.current = getOrCreateVisitorId();
+    sessionIdRef.current = getSessionId(sessionTimeout);
+  }, [sessionTimeout]);
+  useEffect(() => {
+    if (!validateAgainstSitemap) {
+      if (debug) console.log("[Analytics] Page validation disabled");
+      return;
+    }
+    const fetchValidPages = async () => {
+      const { apiUrl: globalApiUrl, apiKey: globalApiKey } = getApiConfig2();
+      const apiUrl = propApiUrl || globalApiUrl;
+      const apiKey = propApiKey || globalApiKey;
+      if (!apiKey) {
+        if (debug) console.warn("[Analytics] No API key for page validation");
+        return;
+      }
+      try {
+        const response = await fetch(`${apiUrl}/api/public/seo/pages`, {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json",
+            "x-api-key": apiKey
+          }
+        });
+        if (response.ok) {
+          const data = await response.json();
+          const pages = data?.pages || [];
+          validPathsRef.current = new Set(
+            pages.map((p) => p.path).filter(Boolean)
+          );
+          if (debug) {
+            console.log("[Analytics] Loaded", validPathsRef.current.size, "valid pages from seo_pages");
+          }
+        } else if (debug) {
+          console.error("[Analytics] Pages fetch failed:", response.statusText);
+        }
+      } catch (error) {
+        if (debug) console.error("[Analytics] Error fetching valid pages:", error);
+      }
+    };
+    fetchValidPages();
+  }, [propApiUrl, propApiKey, validateAgainstSitemap, debug]);
+  useEffect(() => {
+    if (!trackPageViews) return;
+    if (!pathname) return;
+    if (excludePaths.some((p) => pathname.startsWith(p))) return;
+    if (pathname === lastPathRef.current) return;
+    if (validateAgainstSitemap) {
+      if (validPathsRef.current && validPathsRef.current.size > 0) {
+        if (!validPathsRef.current.has(pathname)) {
+          if (debug) {
+            console.log("[Analytics] Skipping unregistered path:", pathname);
+          }
+          return;
+        }
+      } else if (debug) {
+        console.log("[Analytics] Sitemap not yet loaded, tracking anyway:", pathname);
+      }
+    }
+    lastPathRef.current = pathname;
+    const trackPageView = async () => {
+      const { apiUrl: globalApiUrl, apiKey: globalApiKey } = getApiConfig2();
+      const apiUrl = propApiUrl || globalApiUrl;
+      const apiKey = propApiKey || globalApiKey;
+      if (!apiKey) {
+        if (debug) console.warn("[Analytics] No API key configured");
+        return;
+      }
+      const utmParams = getUTMParams();
+      const pageMetadata = getPageMetadata();
+      const pageView = {
+        sessionId: sessionIdRef.current,
+        visitorId: visitorIdRef.current,
+        pagePath: pathname,
+        pageTitle: document.title,
+        referrer: document.referrer || null,
+        deviceType: getDeviceType(),
+        browser: getBrowser(),
+        os: getOS(),
+        userAgent: getUserAgent(),
+        utmSource: utmParams.utm_source,
+        utmMedium: utmParams.utm_medium,
+        utmCampaign: utmParams.utm_campaign,
+        utmTerm: utmParams.utm_term,
+        utmContent: utmParams.utm_content,
+        // SEO enrichment data - updates seo_pages
+        seo: pageMetadata
+      };
+      if (debug) {
+        console.log("[Analytics] Page view:", pageView);
+      }
+      try {
+        const response = await fetch(`${apiUrl}/api/public/analytics/page-view`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-api-key": apiKey
+          },
+          body: JSON.stringify(pageView)
+        });
+        if (!response.ok && debug) {
+          console.error("[Analytics] Error tracking page view:", response.statusText);
+        }
+      } catch (error) {
+        if (debug) console.error("[Analytics] Error tracking page view:", error);
+      }
+    };
+    scheduleIdleTask(() => trackPageView());
+  }, [pathname, searchParams, propApiUrl, propApiKey, trackPageViews, excludePaths, debug]);
+  useEffect(() => {
+    if (!trackJourneys) return;
+    if (!pathname) return;
+    if (typeof window === "undefined") return;
+    const { apiUrl: globalApiUrl, apiKey: globalApiKey } = getApiConfig2();
+    const apiUrl = propApiUrl || globalApiUrl;
+    const apiKey = propApiKey || globalApiKey;
+    if (!apiKey) return;
+    const now = Date.now();
+    const previousPath = lastPathRef.current;
+    const previousDuration = pageEnterTimeRef.current > 0 ? Math.round((now - pageEnterTimeRef.current) / 1e3) : 0;
+    const previousScrollDepth = currentScrollDepthRef.current;
+    pageEnterTimeRef.current = now;
+    currentScrollDepthRef.current = 0;
+    const isNewSession = !previousPath || journeyStartTimeRef.current === 0;
+    if (isNewSession) {
+      journeyStartTimeRef.current = now;
+    }
+    const trackJourneyStep = async () => {
+      const sessionData = {
+        sessionId: sessionIdRef.current,
+        visitorId: visitorIdRef.current,
+        action: isNewSession ? "start" : "update",
+        lastPage: pathname,
+        userAgent: getUserAgent(),
+        // Journey step data
+        journeyStep: {
+          page: pathname,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+      if (!isNewSession && previousDuration > 0) {
+        sessionData.previousPageDuration = previousDuration;
+        sessionData.previousPageScrollDepth = previousScrollDepth;
+      }
+      if (isNewSession) {
+        sessionData.firstPage = pathname;
+        const utmParams = getUTMParams();
+        sessionData.referrer = document.referrer || null;
+        sessionData.utmSource = utmParams.utm_source;
+        sessionData.utmMedium = utmParams.utm_medium;
+        sessionData.utmCampaign = utmParams.utm_campaign;
+        sessionData.utmTerm = utmParams.utm_term;
+        sessionData.utmContent = utmParams.utm_content;
+        sessionData.screenWidth = window.screen.width;
+        sessionData.screenHeight = window.screen.height;
+      }
+      if (debug) {
+        console.log("[Analytics] Journey step:", sessionData);
+      }
+      try {
+        await fetch(`${apiUrl}/api/public/analytics/session`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-api-key": apiKey
+          },
+          body: JSON.stringify(sessionData)
+        });
+      } catch (error) {
+        if (debug) console.error("[Analytics] Error tracking journey:", error);
+      }
+    };
+    scheduleIdleTask(() => trackJourneyStep());
+    const handleUnload = () => {
+      const duration = Math.round((Date.now() - journeyStartTimeRef.current) / 1e3);
+      const payload = JSON.stringify({
+        sessionId: sessionIdRef.current,
+        action: "end",
+        duration,
+        lastPage: pathname,
+        previousPageDuration: Math.round((Date.now() - pageEnterTimeRef.current) / 1e3),
+        previousPageScrollDepth: currentScrollDepthRef.current
+      });
+      if (navigator.sendBeacon) {
+        const blob = new Blob([payload], { type: "application/json" });
+        navigator.sendBeacon(
+          `${apiUrl}/api/public/analytics/session?key=${encodeURIComponent(apiKey)}`,
+          blob
+        );
+      }
+    };
+    window.addEventListener("beforeunload", handleUnload);
+    return () => {
+      window.removeEventListener("beforeunload", handleUnload);
+    };
+  }, [pathname, propApiUrl, propApiKey, trackJourneys, debug]);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    if (debug) console.log("[Analytics] Scroll tracking setup:", { trackScrollDepth, hasApiKey: !!propApiKey });
+    if (!trackScrollDepth) return;
+    const { apiUrl: globalApiUrl, apiKey: globalApiKey } = getApiConfig2();
+    const apiUrl = propApiUrl || globalApiUrl;
+    const apiKey = propApiKey || globalApiKey;
+    if (!apiKey) {
+      if (debug) console.warn("[Analytics] Scroll tracking disabled - no API key");
+      return;
+    }
+    if (debug) console.log("[Analytics] Scroll tracking enabled for:", pathname);
+    let maxDepth = 0;
+    let startTime = Date.now();
+    let milestone25 = null;
+    let milestone50 = null;
+    let milestone75 = null;
+    let milestone100 = null;
+    let hasTracked = false;
+    const calculateScrollDepth = () => {
+      const scrollTop = window.scrollY;
+      const docHeight = document.documentElement.scrollHeight;
+      const winHeight = window.innerHeight;
+      const scrollableHeight = docHeight - winHeight;
+      if (scrollableHeight <= 0) return 100;
+      return Math.min(100, Math.round(scrollTop / scrollableHeight * 100));
+    };
+    const handleScroll = () => {
+      const depth = calculateScrollDepth();
+      const elapsed = (Date.now() - startTime) / 1e3;
+      if (depth > maxDepth) {
+        maxDepth = depth;
+        currentScrollDepthRef.current = depth;
+        if (debug && depth % 25 === 0) console.log("[Analytics] Scroll milestone:", depth + "%");
+        if (depth >= 25 && milestone25 === null) milestone25 = elapsed;
+        if (depth >= 50 && milestone50 === null) milestone50 = elapsed;
+        if (depth >= 75 && milestone75 === null) milestone75 = elapsed;
+        if (depth >= 100 && milestone100 === null) milestone100 = elapsed;
+      }
+    };
+    const sendScrollData = async (useBeacon = false) => {
+      if (hasTracked || maxDepth === 0) return;
+      hasTracked = true;
+      const totalTime = (Date.now() - startTime) / 1e3;
+      const payload = JSON.stringify({
+        sessionId: sessionIdRef.current,
+        visitorId: visitorIdRef.current,
+        pagePath: pathname,
+        maxDepthPercent: maxDepth,
+        timeTo25: milestone25,
+        timeTo50: milestone50,
+        timeTo75: milestone75,
+        timeTo100: milestone100,
+        totalTimeSeconds: totalTime,
+        deviceType: getDeviceType()
+      });
+      if (useBeacon && navigator.sendBeacon) {
+        const blob = new Blob([payload], { type: "application/json" });
+        new Headers({ "x-api-key": apiKey });
+        navigator.sendBeacon(
+          `${apiUrl}/api/public/analytics/scroll-depth?key=${encodeURIComponent(apiKey)}`,
+          blob
+        );
+        if (debug) console.log("[Analytics] Scroll depth (beacon):", { maxDepth, totalTime });
+      } else {
+        try {
+          await fetch(`${apiUrl}/api/public/analytics/scroll-depth`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "x-api-key": apiKey
+            },
+            body: payload,
+            keepalive: true
+            // Allows request to outlive the page
+          });
+          if (debug) console.log("[Analytics] Scroll depth:", { maxDepth, totalTime });
+        } catch (error) {
+          if (debug) console.error("[Analytics] Error tracking scroll depth:", error);
+        }
+      }
+    };
+    maxDepth = 0;
+    startTime = Date.now();
+    milestone25 = null;
+    milestone50 = null;
+    milestone75 = null;
+    milestone100 = null;
+    hasTracked = false;
+    window.addEventListener("scroll", handleScroll, { passive: true });
+    const handleBeforeUnload = () => sendScrollData(true);
+    const handleVisibilityChange = () => {
+      if (document.visibilityState === "hidden") sendScrollData(true);
+    };
+    window.addEventListener("beforeunload", handleBeforeUnload);
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+    return () => {
+      window.removeEventListener("scroll", handleScroll);
+      window.removeEventListener("beforeunload", handleBeforeUnload);
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+      sendScrollData(false);
+    };
+  }, [pathname, propApiUrl, propApiKey, trackScrollDepth, debug]);
+  useEffect(() => {
+    if (!trackClicks) return;
+    if (typeof window === "undefined") return;
+    const { apiUrl: globalApiUrl, apiKey: globalApiKey } = getApiConfig2();
+    const apiUrl = propApiUrl || globalApiUrl;
+    const apiKey = propApiKey || globalApiKey;
+    if (!apiKey) return;
+    const handleClick = async (e) => {
+      const target = e.target;
+      if (!target) return;
+      const docHeight = document.documentElement.scrollHeight;
+      const viewportWidth = window.innerWidth;
+      const viewportHeight = window.innerHeight;
+      const xPercent = Math.round(e.pageX / viewportWidth * 100);
+      const yPercent = Math.round(e.pageY / docHeight * 100);
+      const elementTag = target.tagName.toLowerCase();
+      const elementId = target.id || null;
+      const elementClass = target.className && typeof target.className === "string" ? target.className.split(" ").slice(0, 3).join(" ") : null;
+      const elementText = target.textContent?.slice(0, 50) || null;
+      const clickData = {
+        sessionId: sessionIdRef.current,
+        pagePath: pathname,
+        xPercent,
+        yPercent,
+        xAbsolute: e.pageX,
+        yAbsolute: e.pageY,
+        viewportWidth,
+        viewportHeight,
+        pageHeight: docHeight,
+        elementTag,
+        elementId,
+        elementClass,
+        elementText
+      };
+      if (debug) console.log("[Analytics] Click:", clickData);
+      scheduleIdleTask(async () => {
+        try {
+          await fetch(`${apiUrl}/api/public/analytics/heatmap-click`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "x-api-key": apiKey
+            },
+            body: JSON.stringify(clickData)
+          });
+        } catch (error) {
+          if (debug) console.error("[Analytics] Error tracking click:", error);
+        }
+      }, 500);
+    };
+    document.addEventListener("click", handleClick, { passive: true });
+    return () => {
+      document.removeEventListener("click", handleClick);
+    };
+  }, [pathname, propApiUrl, propApiKey, trackClicks, debug]);
+  const trackEvent = useCallback((options) => {
+    const doTrack = async () => {
+      const { apiUrl: globalApiUrl, apiKey: globalApiKey } = getApiConfig2();
+      const apiUrl = propApiUrl || globalApiUrl;
+      const apiKey = propApiKey || globalApiKey;
+      if (!apiKey) {
+        if (debug) console.warn("[Analytics] No API key configured");
+        return;
+      }
+      const event = {
+        sessionId: sessionIdRef.current,
+        visitorId: visitorIdRef.current,
+        eventName: options.name,
+        eventCategory: options.category,
+        eventLabel: options.label,
+        eventValue: options.value,
+        properties: options.properties,
+        pagePath: pathname
+      };
+      if (debug) {
+        console.log("[Analytics] Event:", event);
+      }
+      try {
+        const response = await fetch(`${apiUrl}/api/public/analytics/event`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-api-key": apiKey
+          },
+          body: JSON.stringify(event)
+        });
+        if (!response.ok && debug) {
+          console.error("[Analytics] Error tracking event:", response.statusText);
+        }
+      } catch (error) {
+        if (debug) console.error("[Analytics] Error tracking event:", error);
+      }
+    };
+    scheduleIdleTask(doTrack, 1e3);
+  }, [propApiUrl, propApiKey, pathname, debug]);
+  const trackConversion = useCallback((options) => {
+    const doTrack = async () => {
+      const { apiUrl: globalApiUrl, apiKey: globalApiKey } = getApiConfig2();
+      const apiUrl = propApiUrl || globalApiUrl;
+      const apiKey = propApiKey || globalApiKey;
+      if (!apiKey) {
+        if (debug) console.warn("[Analytics] No API key configured");
+        return;
+      }
+      const conversion = {
+        sessionId: sessionIdRef.current,
+        visitorId: visitorIdRef.current,
+        conversionType: options.type,
+        value: options.value,
+        currency: options.currency,
+        metadata: options.metadata,
+        pagePath: pathname,
+        referrer: document.referrer || null,
+        deviceType: getDeviceType()
+      };
+      if (debug) {
+        console.log("[Analytics] Conversion:", conversion);
+      }
+      try {
+        const response = await fetch(`${apiUrl}/api/public/analytics/conversion`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-api-key": apiKey
+          },
+          body: JSON.stringify(conversion)
+        });
+        if (!response.ok && debug) {
+          console.error("[Analytics] Error tracking conversion:", response.statusText);
+        }
+      } catch (error) {
+        if (debug) console.error("[Analytics] Error tracking conversion:", error);
+      }
+    };
+    doTrack();
+  }, [propApiUrl, propApiKey, pathname, debug]);
+  const contextValue = useMemo(() => ({
+    trackEvent,
+    trackConversion,
+    sessionId: sessionIdRef.current,
+    visitorId: visitorIdRef.current
+  }), [trackEvent, trackConversion]);
+  return /* @__PURE__ */ jsxs(AnalyticsContext.Provider, { value: contextValue, children: [
+    trackWebVitals && /* @__PURE__ */ jsx(
+      WebVitals,
+      {
+        apiUrl: propApiUrl,
+        apiKey: propApiKey,
+        debug
+      }
+    ),
+    children
+  ] });
+}
+function useAnalytics() {
+  const context = useContext(AnalyticsContext);
+  if (!context) {
+    throw new Error("useAnalytics must be used within an AnalyticsProvider");
+  }
+  return context;
+}
+function useTrackEvent() {
+  const { trackEvent, trackConversion } = useAnalytics();
+  return { trackEvent, trackConversion };
+}
+
+export { AnalyticsProvider, WebVitals, useAnalytics, useTrackEvent };
+//# sourceMappingURL=chunk-FKVJOT2F.mjs.map
+//# sourceMappingURL=chunk-FKVJOT2F.mjs.map