@sonordev/site-kit 1.2.7

package/dist/chunk-WECQ6KOB.js

@@ -0,0 +1,1008 @@
+'use client';
+'use strict';
+
+var react = require('react');
+var navigation = require('next/navigation');
+var jsxRuntime = require('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 = navigation.usePathname();
+  react.useEffect(() => {
+    import('./web-vitals-444RLW3B.js').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);
+      };
+    }).catch((err) => {
+      if (debug) console.warn("[Analytics] Web Vitals import failed:", err);
+    });
+  }, [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 = react.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 getElementPosition = (el) => {
+    let current = el;
+    while (current) {
+      const tag = current.tagName?.toLowerCase();
+      const role = current.getAttribute("role");
+      const className = current.className?.toString?.() || "";
+      if (className.includes("hero") || current.id?.includes("hero")) return "hero";
+      if (tag === "header" || role === "banner") return "header";
+      if (tag === "nav" || role === "navigation") return "header";
+      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";
+  };
+  const getSurroundingText = (el) => {
+    const container = el.closest("figure, p, div, section, article");
+    if (!container) return "";
+    const text = container.textContent?.replace(/\s+/g, " ").trim() || "";
+    return text.slice(0, 300);
+  };
+  const getImageDetails = () => {
+    const images = document.querySelectorAll("img, [data-managed-image]");
+    const seen = /* @__PURE__ */ new Set();
+    const results = [];
+    images.forEach((el) => {
+      const img = el;
+      const src = img.getAttribute("src") || img.getAttribute("data-src") || "";
+      if (!src || src.startsWith("data:") || seen.has(src)) return;
+      seen.add(src);
+      const slotId = img.getAttribute("data-slot-id") || void 0;
+      const isManagedImage = img.hasAttribute("data-managed-image") || !!slotId;
+      results.push({
+        src,
+        alt: img.alt || null,
+        elementType: isManagedImage ? "ManagedImage" : "img",
+        slotId,
+        position: getElementPosition(img),
+        width: img.naturalWidth || parseInt(img.getAttribute("width") || "0") || void 0,
+        height: img.naturalHeight || parseInt(img.getAttribute("height") || "0") || void 0,
+        surroundingText: getSurroundingText(img)
+      });
+    });
+    return results;
+  };
+  const getImageStats = () => {
+    const images = getImageDetails();
+    let withoutAlt = 0;
+    images.forEach((img) => {
+      if (!img.alt || img.alt.trim() === "") withoutAlt++;
+    });
+    return { count: images.length, withoutAlt, images };
+  };
+  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 getHeadingStructure = () => {
+    const headings = [];
+    const elements = document.querySelectorAll("h1, h2, h3, h4, h5, h6");
+    elements.forEach((el) => {
+      const level = parseInt(el.tagName[1]);
+      const text = el.textContent?.trim() || "";
+      if (text) {
+        headings.push({
+          level,
+          text: text.slice(0, 200),
+          // Limit length
+          id: el.id || void 0
+        });
+      }
+    });
+    return headings;
+  };
+  const getContentText = () => {
+    const main = document.querySelector('main, article, [role="main"]') || document.body;
+    const clone = main.cloneNode(true);
+    clone.querySelectorAll('script, style, nav, header, footer, [role="navigation"], [role="banner"], [role="contentinfo"]').forEach((el) => el.remove());
+    let text = clone.textContent || "";
+    text = text.replace(/\s+/g, " ").trim();
+    text = text.slice(0, 1e4);
+    let hash = 0;
+    for (let i = 0; i < text.length; i++) {
+      const chr = text.charCodeAt(i);
+      hash = (hash << 5) - hash + chr;
+      hash |= 0;
+    }
+    return { text, hash: hash.toString(16) };
+  };
+  const getContentSections = () => {
+    const sections = [];
+    const main = document.querySelector('main, article, [role="main"]') || document.body;
+    const headings = main.querySelectorAll("h1, h2, h3");
+    headings.forEach((heading, idx) => {
+      const headingText = heading.textContent?.trim() || "";
+      const level = parseInt(heading.tagName[1]);
+      let content = "";
+      let sibling = heading.nextElementSibling;
+      while (sibling && !["H1", "H2", "H3"].includes(sibling.tagName)) {
+        if (sibling.tagName === "P" || sibling.tagName === "UL" || sibling.tagName === "OL" || sibling.tagName === "DIV") {
+          content += (sibling.textContent || "") + " ";
+        }
+        sibling = sibling.nextElementSibling;
+      }
+      content = content.replace(/\s+/g, " ").trim().slice(0, 1e3);
+      const wordCount2 = content.split(/\s+/).filter((w) => w.length > 0).length;
+      if (content && wordCount2 > 10) {
+        sections.push({
+          heading: headingText.slice(0, 200),
+          headingLevel: level,
+          text: content,
+          wordCount: wordCount2
+        });
+      }
+    });
+    return sections.slice(0, 20);
+  };
+  const detectFAQContent = () => {
+    const faqs = [];
+    const scripts = document.querySelectorAll('script[type="application/ld+json"]');
+    scripts.forEach((script) => {
+      try {
+        const data = JSON.parse(script.textContent || "");
+        if (data["@type"] === "FAQPage" && data.mainEntity) {
+          data.mainEntity.forEach((item) => {
+            if (item["@type"] === "Question") {
+              faqs.push({
+                question: item.name?.slice(0, 200) || "",
+                answer: (item.acceptedAnswer?.text || "").slice(0, 500)
+              });
+            }
+          });
+        }
+      } catch {
+      }
+    });
+    if (faqs.length === 0) {
+      const details = document.querySelectorAll("details");
+      details.forEach((detail) => {
+        const summary = detail.querySelector("summary");
+        if (summary) {
+          const question = summary.textContent?.trim() || "";
+          const answer = detail.textContent?.replace(question, "").trim().slice(0, 500) || "";
+          if (question && answer) {
+            faqs.push({ question: question.slice(0, 200), answer });
+          }
+        }
+      });
+      const accordionItems = document.querySelectorAll('[class*="accordion"], [class*="faq"], [data-faq]');
+      accordionItems.forEach((item) => {
+        const questionEl = item.querySelector('[class*="question"], [class*="title"], button, h3, h4');
+        const answerEl = item.querySelector('[class*="answer"], [class*="content"], [class*="panel"], p');
+        if (questionEl && answerEl) {
+          const question = questionEl.textContent?.trim() || "";
+          const answer = answerEl.textContent?.trim().slice(0, 500) || "";
+          if (question && answer && question.includes("?")) {
+            faqs.push({ question: question.slice(0, 200), answer });
+          }
+        }
+      });
+    }
+    return faqs.slice(0, 20);
+  };
+  const detectLists = () => {
+    const lists = [];
+    const main = document.querySelector('main, article, [role="main"]') || document.body;
+    main.querySelectorAll("ul, ol").forEach((list) => {
+      const type = list.tagName.toLowerCase();
+      const items = [];
+      list.querySelectorAll(":scope > li").forEach((li) => {
+        const text = li.textContent?.trim().slice(0, 200) || "";
+        if (text) items.push(text);
+      });
+      if (items.length >= 3) {
+        lists.push({ type, items: items.slice(0, 10) });
+      }
+    });
+    return lists.slice(0, 10);
+  };
+  const estimateReadingTime = (wordCount2) => {
+    return Math.ceil(wordCount2 / 225);
+  };
+  const imageStats = getImageStats();
+  const linkStats = getLinkStats();
+  const headingStructure = getHeadingStructure();
+  const contentData = getContentText();
+  const contentSections = getContentSections();
+  const faqContent = detectFAQContent();
+  const listContent = detectLists();
+  const wordCount = getWordCount();
+  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,
+    imagesCount: imageStats.count,
+    imagesWithoutAlt: imageStats.withoutAlt,
+    images: imageStats.images,
+    // Full image details for SEO optimization
+    internalLinks: linkStats.internal,
+    internalLinkTargets: linkStats.internalLinks,
+    // Full link graph data
+    externalLinks: linkStats.external,
+    // NEW: Content analysis data
+    content: {
+      text: contentData.text,
+      hash: contentData.hash,
+      headings: headingStructure,
+      sections: contentSections,
+      faqs: faqContent.length > 0 ? faqContent : void 0,
+      lists: listContent.length > 0 ? listContent : void 0,
+      readingTime: estimateReadingTime(wordCount)
+    }
+  };
+}
+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,
+  externalVisitorId,
+  externalSessionId,
+  onPageMetadata
+}) {
+  const pathname = navigation.usePathname();
+  const [queryString, setQueryString] = react.useState("");
+  react.useEffect(() => {
+    if (typeof window === "undefined") return;
+    setQueryString(window.location.search);
+    const handlePopState = () => {
+      setQueryString(window.location.search);
+    };
+    window.addEventListener("popstate", handlePopState);
+    return () => window.removeEventListener("popstate", handlePopState);
+  }, [pathname]);
+  const visitorIdRef = react.useRef("");
+  const sessionIdRef = react.useRef("");
+  const lastPathRef = react.useRef("");
+  const validPathsRef = react.useRef(null);
+  const journeyStartTimeRef = react.useRef(0);
+  const pageEnterTimeRef = react.useRef(0);
+  const currentScrollDepthRef = react.useRef(0);
+  react.useEffect(() => {
+    visitorIdRef.current = externalVisitorId || getOrCreateVisitorId();
+    sessionIdRef.current = externalSessionId || getSessionId(sessionTimeout);
+  }, [sessionTimeout, externalVisitorId, externalSessionId]);
+  react.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]);
+  react.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();
+      if (onPageMetadata) {
+        onPageMetadata(pageMetadata);
+      }
+      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, queryString, propApiUrl, propApiKey, trackPageViews, excludePaths, debug, validateAgainstSitemap]);
+  react.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]);
+  react.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]);
+  react.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 = react.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 = react.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 = react.useMemo(() => ({
+    trackEvent,
+    trackConversion,
+    sessionId: sessionIdRef.current,
+    visitorId: visitorIdRef.current
+  }), [trackEvent, trackConversion]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(AnalyticsContext.Provider, { value: contextValue, children: [
+    trackWebVitals && /* @__PURE__ */ jsxRuntime.jsx(
+      WebVitals,
+      {
+        apiUrl: propApiUrl,
+        apiKey: propApiKey,
+        debug
+      }
+    ),
+    children
+  ] });
+}
+function useAnalytics() {
+  const context = react.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 };
+}
+
+exports.AnalyticsProvider = AnalyticsProvider;
+exports.WebVitals = WebVitals;
+exports.useAnalytics = useAnalytics;
+exports.useTrackEvent = useTrackEvent;
+//# sourceMappingURL=chunk-WECQ6KOB.js.map
+//# sourceMappingURL=chunk-WECQ6KOB.js.map