@sonordev/site-kit 6.5.0 → 7.0.1

package/dist/chunk-HGCK465A.js

@@ -0,0 +1,1071 @@
+'use client';
+import { registerAnalyticsDispatcher } from './chunk-LCDVPAMR.js';
+import { getOrCreateVisitorId, getOrCreateSessionId } from './chunk-24QZEO3Q.js';
+import { onPageLeave } from './chunk-L2V5PUFN.js';
+import { resolveAnalyticsTarget } from './chunk-43OCZ3JA.js';
+import { sonorFetch, sonorBeacon } from './chunk-EGOD74PP.js';
+import { createContext, useRef, useEffect, useState, useMemo, useCallback, useContext } from 'react';
+import { usePathname } from 'next/navigation';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+// src/analytics/page-observation.ts
+function collectPageObservation() {
+  const observedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const observed = (value, source) => ({ state: "observed", value, source });
+  const unknown = { state: "not_checked", value: null, source: null };
+  const nav = performance.getEntriesByType("navigation")[0];
+  const samePage = nav && new URL(nav.name).pathname === location.pathname;
+  const status = samePage && nav.responseStatus >= 100 ? nav.responseStatus : null;
+  const schema = Array.from(document.querySelectorAll('script[type="application/ld+json"]')).map((el) => {
+    try {
+      return { validJson: true, value: JSON.parse(el.textContent || "") };
+    } catch {
+      return { validJson: false, value: null };
+    }
+  });
+  return {
+    version: 1,
+    observedAt,
+    pageUrl: location.origin + location.pathname,
+    source: "site-kit/browser",
+    fields: {
+      httpStatus: status === null ? unknown : observed(status, "navigation.responseStatus"),
+      canonical: observed(document.querySelector('link[rel="canonical"]')?.getAttribute("href") || null, "DOM link[rel=canonical]"),
+      robots: observed(document.querySelector('meta[name="robots"]')?.getAttribute("content") || null, "DOM meta[name=robots]"),
+      xRobotsTag: unknown,
+      schema: observed(schema, "DOM script[type=application/ld+json]")
+    }
+  };
+}
+
+// src/analytics/measurement-context.ts
+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 getMeasurementContext(options = {}) {
+  let visitorId = options.visitorId;
+  let sessionId = options.sessionId;
+  try {
+    visitorId || (visitorId = getOrCreateVisitorId());
+    sessionId || (sessionId = getOrCreateSessionId(options.sessionTimeout));
+  } catch {
+  }
+  const connection = typeof navigator === "undefined" ? void 0 : navigator.connection;
+  return {
+    visitorId: visitorId || void 0,
+    sessionId: sessionId || void 0,
+    deviceType: getDeviceType(),
+    connectionType: connection?.effectiveType || connection?.type || void 0
+  };
+}
+
+// src/analytics/send-gate.ts
+async function analyticsSend(path, body, options = {}) {
+  const target = resolveAnalyticsTarget(options);
+  if (!target) return null;
+  try {
+    return await sonorFetch(
+      `${target.apiUrl}${path}`,
+      {
+        method: options.method || "POST",
+        headers: { "Content-Type": "application/json" },
+        ...options.keepalive ? { keepalive: true } : {},
+        ...body === void 0 ? {} : { body: JSON.stringify(body) }
+      },
+      { apiKey: target.apiKey, retries: options.retries ?? 0 }
+    );
+  } catch {
+    return null;
+  }
+}
+function analyticsBeacon(path, body, options = {}) {
+  const target = resolveAnalyticsTarget(options);
+  if (!target) return;
+  sonorBeacon(`${target.apiUrl}${path}`, body, target.apiKey);
+}
+
+// src/analytics/WebVitals.tsx
+function pathForMetric(metric, fallback) {
+  const url = metric.navigationURL;
+  if (url) {
+    try {
+      return new URL(url, window.location.origin).pathname || fallback;
+    } catch {
+    }
+  }
+  return fallback;
+}
+function summarizeAttribution(metric) {
+  const a = metric.attribution;
+  if (!a) return void 0;
+  const pick = (keys) => {
+    const out = {};
+    for (const key of keys) {
+      const value = a[key];
+      if (value !== void 0 && value !== null && value !== "") out[key] = value;
+    }
+    return Object.keys(out).length ? out : void 0;
+  };
+  switch (metric.name) {
+    case "LCP":
+      return pick([
+        "target",
+        "url",
+        "timeToFirstByte",
+        "resourceLoadDelay",
+        "resourceLoadDuration",
+        "elementRenderDelay"
+      ]);
+    case "INP":
+      return pick([
+        "interactionTarget",
+        "interactionType",
+        "inputDelay",
+        "processingDuration",
+        "presentationDelay",
+        "loadState"
+      ]);
+    case "CLS":
+      return pick(["largestShiftTarget", "largestShiftValue", "largestShiftTime", "loadState"]);
+    case "FCP":
+      return pick(["timeToFirstByte", "firstByteToFCP", "loadState"]);
+    case "TTFB":
+      return pick(["waitingDuration", "dnsDuration", "connectionDuration", "requestDuration"]);
+    default:
+      return void 0;
+  }
+}
+function WebVitals({
+  apiUrl: propApiUrl,
+  apiKey: propApiKey,
+  site: propSite,
+  allowInFrame = false,
+  allowLocalhost = false,
+  debug = false,
+  visitorId,
+  sessionId,
+  sessionTimeout
+}) {
+  const pathname = usePathname();
+  const landingPathRef = useRef(pathname || "/");
+  const propsRef = useRef({ propApiUrl, propApiKey, propSite, allowInFrame, allowLocalhost, debug, visitorId, sessionId, sessionTimeout });
+  propsRef.current = { propApiUrl, propApiKey, propSite, allowInFrame, allowLocalhost, debug, visitorId, sessionId, sessionTimeout };
+  useEffect(() => {
+    let cancelled = false;
+    let teardown;
+    import('./web-vitals.attribution-N2PCCF4Q.js').then(({ onCLS, onLCP, onTTFB, onINP, onFCP }) => {
+      if (cancelled) return;
+      const { propApiUrl: propApiUrl2, propApiKey: propApiKey2, propSite: propSite2, allowInFrame: allowInFrame2, allowLocalhost: allowLocalhost2, debug: debug2, visitorId: visitorId2, sessionId: sessionId2, sessionTimeout: sessionTimeout2 } = propsRef.current;
+      const sent = /* @__PURE__ */ new Map();
+      const report = (metric, viaBeacon = false) => {
+        if (!resolveAnalyticsTarget({ apiUrl: propApiUrl2, apiKey: propApiKey2, allowInFrame: allowInFrame2, allowLocalhost: allowLocalhost2, debug: debug2 })) return;
+        if (sent.get(metric.id) === metric.value) return;
+        sent.set(metric.id, metric.value);
+        const site = propSite2 || (typeof window !== "undefined" ? window.__SITE_KIT_SITE__ || window.location.host : "");
+        const data = {
+          ...getMeasurementContext(propsRef.current),
+          site,
+          pagePath: pathForMetric(metric, landingPathRef.current),
+          metricName: metric.name,
+          metricValue: metric.value,
+          // The library's own rating — no thresholds duplicated here.
+          metricRating: metric.rating,
+          metricDelta: metric.delta,
+          metricId: metric.id,
+          navigationType: metric.navigationType,
+          attribution: summarizeAttribution(metric)
+        };
+        if (debug2) console.log("[Analytics] Web Vital:", data);
+        const endpoint = "/api/public/analytics/web-vitals";
+        const gate = { apiUrl: propApiUrl2, apiKey: propApiKey2, allowInFrame: allowInFrame2, allowLocalhost: allowLocalhost2, debug: debug2, visitorId: visitorId2, sessionId: sessionId2, sessionTimeout: sessionTimeout2 };
+        if (viaBeacon) {
+          analyticsBeacon(endpoint, data, gate);
+          return;
+        }
+        void analyticsSend(endpoint, data, gate);
+      };
+      const opts = { reportSoftNavs: true };
+      const pending = [];
+      const collect = (metric) => {
+        pending.push(metric);
+        report(metric);
+      };
+      onLCP(collect, opts);
+      onCLS(collect, opts);
+      onTTFB(collect, opts);
+      onINP(collect, opts);
+      onFCP(collect, opts);
+      const handleVisibilityChange = () => {
+        if (document.visibilityState !== "hidden") return;
+        for (const metric of pending) report(metric, true);
+      };
+      document.addEventListener("visibilitychange", handleVisibilityChange);
+      teardown = () => {
+        document.removeEventListener("visibilitychange", handleVisibilityChange);
+      };
+    }).catch((err) => {
+      if (propsRef.current.debug) console.warn("[Analytics] Web Vitals import failed:", err);
+    });
+    return () => {
+      cancelled = true;
+      teardown?.();
+    };
+  }, []);
+  return null;
+}
+var AnalyticsContext = createContext(null);
+function scheduleIdleTask(callback, timeout = 2e3) {
+  if (typeof window !== "undefined" && "requestIdleCallback" in window) {
+    window.requestIdleCallback(
+      callback,
+      { timeout }
+    );
+  } else {
+    setTimeout(callback, 300);
+  }
+}
+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 getClickIds() {
+  if (typeof window === "undefined") return {};
+  const params = new URLSearchParams(window.location.search);
+  const ids = {};
+  for (const key of ["gclid", "fbclid", "msclkid"]) {
+    const value = params.get(key);
+    if (value) ids[key] = value.slice(0, 200);
+  }
+  return ids;
+}
+function getLandingContext() {
+  if (typeof window === "undefined") return {};
+  const w = window;
+  if (w.__SITE_KIT_PAGE_KIND__ !== "landing" || !w.__SITE_KIT_CAMPAIGN__) return {};
+  return { pageKind: "landing", landingCampaign: w.__SITE_KIT_CAMPAIGN__ };
+}
+function getLocaleInfo() {
+  if (typeof navigator === "undefined") return {};
+  let timezone;
+  try {
+    timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+    timezone = void 0;
+  }
+  return { language: navigator.language || void 0, timezone };
+}
+function nextIdleSlice(timeout = 1500) {
+  return new Promise((resolve) => scheduleIdleTask(resolve, timeout));
+}
+function getLightPageMetadata() {
+  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;
+  };
+  return {
+    observation: collectPageObservation(),
+    metaDescription: getMeta("description"),
+    canonical: getCanonical(),
+    robots: getRobots(),
+    ogTitle: getMeta("og:title"),
+    ogDescription: getMeta("og:description"),
+    ogImage: getMeta("og:image"),
+    h1: getH1(),
+    h1Count: getH1Count()
+  };
+}
+function getMediaPageMetadata() {
+  if (typeof document === "undefined") return {};
+  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 imageStats = getImageStats();
+  return {
+    imagesCount: imageStats.count,
+    imagesWithoutAlt: imageStats.withoutAlt,
+    images: imageStats.images
+    // Full image details for SEO optimization
+  };
+}
+function getContentPageMetadata() {
+  if (typeof document === "undefined") return {};
+  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 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 linkStats = getLinkStats();
+  const headingStructure = getHeadingStructure();
+  const contentData = getContentText();
+  const contentSections = getContentSections();
+  const faqContent = detectFAQContent();
+  const listContent = detectLists();
+  const wordCount = getWordCount();
+  return {
+    wordCount,
+    internalLinks: linkStats.internal,
+    internalLinkTargets: linkStats.internalLinks,
+    // Full link graph data
+    externalLinks: linkStats.external,
+    // 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)
+    }
+  };
+}
+async function collectPageMetadata(isStale) {
+  const light = getLightPageMetadata();
+  await nextIdleSlice();
+  if (isStale()) return light;
+  const media = getMediaPageMetadata();
+  await nextIdleSlice();
+  if (isStale()) return { ...light, ...media };
+  const content = getContentPageMetadata();
+  return { ...light, ...media, ...content };
+}
+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 = false,
+  debug = false,
+  externalVisitorId,
+  externalSessionId,
+  onPageMetadata,
+  site: propSite,
+  allowInFrame = false,
+  allowLocalhost = false
+}) {
+  const pathname = usePathname();
+  const [queryString, setQueryString] = useState("");
+  const site = propSite || (typeof window !== "undefined" ? window.__SITE_KIT_SITE__ || window.location.host : "");
+  const gate = useMemo(
+    () => ({ apiUrl: propApiUrl, apiKey: propApiKey, allowInFrame, allowLocalhost, debug }),
+    [propApiUrl, propApiKey, allowInFrame, allowLocalhost, debug]
+  );
+  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 = useRef("");
+  const sessionIdRef = useRef("");
+  const lastPathRef = useRef("");
+  const validPathsRef = useRef(null);
+  const sitemapLoadedRef = useRef(false);
+  const journeyStartTimeRef = useRef(0);
+  const pageEnterTimeRef = useRef(0);
+  const currentScrollDepthRef = useRef(0);
+  useEffect(() => {
+    visitorIdRef.current = externalVisitorId || getOrCreateVisitorId();
+    sessionIdRef.current = externalSessionId || getOrCreateSessionId(sessionTimeout);
+  }, [sessionTimeout, externalVisitorId, externalSessionId]);
+  useEffect(() => {
+    if (!validateAgainstSitemap) {
+      if (debug) console.log("[Analytics] Page validation disabled");
+      return;
+    }
+    const fetchValidPages = async () => {
+      try {
+        const response = await analyticsSend(
+          "/api/public/seo/pages",
+          void 0,
+          { ...gate, method: "GET", retries: 2 }
+        );
+        if (!response) {
+          if (debug) console.warn("[Analytics] Page validation skipped (no key, or embedded)");
+          sitemapLoadedRef.current = true;
+          return;
+        }
+        if (response.ok) {
+          const data = await response.json();
+          const pages = data?.pages || [];
+          validPathsRef.current = new Set(
+            pages.map((p) => p.path).filter(Boolean)
+          );
+          sitemapLoadedRef.current = true;
+          if (debug) {
+            console.log("[Analytics] Loaded", validPathsRef.current.size, "valid pages from seo_pages");
+          }
+        } else {
+          sitemapLoadedRef.current = true;
+          if (debug) {
+            console.error("[Analytics] Pages fetch failed:", response.statusText);
+          }
+        }
+      } catch (error) {
+        sitemapLoadedRef.current = true;
+        if (debug) console.error("[Analytics] Error fetching valid pages:", error);
+      }
+    };
+    fetchValidPages();
+  }, [gate, validateAgainstSitemap, debug]);
+  useEffect(() => {
+    if (!trackPageViews) return;
+    if (!pathname) return;
+    const normalizedPath = pathname === "/" ? "/" : pathname.replace(/\/+$/, "");
+    if (excludePaths.some((p) => normalizedPath.startsWith(p))) return;
+    if (normalizedPath === lastPathRef.current) return;
+    lastPathRef.current = normalizedPath;
+    const trackPageView = async () => {
+      if (!resolveAnalyticsTarget(gate)) {
+        if (debug) console.warn("[Analytics] Page view skipped (no key, or embedded)");
+        return;
+      }
+      const utmParams = getUTMParams();
+      const pageTitle = document.title;
+      const pageMetadata = await collectPageMetadata(
+        () => lastPathRef.current !== normalizedPath
+      );
+      if (onPageMetadata) {
+        onPageMetadata(pageMetadata);
+      }
+      const clickIds = getClickIds();
+      const locale = getLocaleInfo();
+      const landing = getLandingContext();
+      const pageView = {
+        sessionId: sessionIdRef.current,
+        visitorId: visitorIdRef.current,
+        site,
+        pageKind: landing.pageKind,
+        landingCampaign: landing.landingCampaign,
+        pagePath: normalizedPath,
+        pageTitle,
+        referrer: document.referrer || null,
+        deviceType: getDeviceType(),
+        browser: getBrowser(),
+        os: getOS(),
+        userAgent: getUserAgent(),
+        language: locale.language,
+        timezone: locale.timezone,
+        utmSource: utmParams.utm_source,
+        utmMedium: utmParams.utm_medium,
+        utmCampaign: utmParams.utm_campaign,
+        utmTerm: utmParams.utm_term,
+        utmContent: utmParams.utm_content,
+        gclid: clickIds.gclid,
+        fbclid: clickIds.fbclid,
+        msclkid: clickIds.msclkid,
+        // SEO enrichment data - updates seo_pages
+        seo: pageMetadata
+      };
+      if (debug) {
+        console.log("[Analytics] Page view:", pageView);
+      }
+      const response = await analyticsSend("/api/public/analytics/page-view", pageView, gate);
+      if (debug && response) {
+        console.log("[Analytics] Page view response:", response.status, response.statusText);
+        if (!response.ok) {
+          const text = await response.text().catch(() => "");
+          console.error("[Analytics] Error tracking page view:", response.status, response.statusText, text);
+        }
+      }
+      if (validateAgainstSitemap && debug) {
+        if (sitemapLoadedRef.current && validPathsRef.current && validPathsRef.current.size > 0) {
+          if (!validPathsRef.current.has(normalizedPath)) {
+            console.log("[Analytics] Note: path not found in sitemap (tracked anyway):", normalizedPath);
+          }
+        } else if (!sitemapLoadedRef.current) {
+          console.log("[Analytics] Sitemap not yet loaded, tracked anyway:", normalizedPath);
+        }
+      }
+    };
+    scheduleIdleTask(() => trackPageView());
+  }, [pathname, queryString, gate, trackPageViews, excludePaths, debug, validateAgainstSitemap]);
+  useEffect(() => {
+    if (!trackJourneys) return;
+    if (!pathname) return;
+    if (typeof window === "undefined") return;
+    if (!resolveAnalyticsTarget(gate)) 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 landing = getLandingContext();
+      const sessionData = {
+        sessionId: sessionIdRef.current,
+        visitorId: visitorIdRef.current,
+        site,
+        action: isNewSession ? "start" : "update",
+        lastPage: pathname,
+        userAgent: getUserAgent(),
+        pageKind: landing.pageKind,
+        landingCampaign: landing.landingCampaign,
+        // 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();
+        const clickIds = getClickIds();
+        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.gclid = clickIds.gclid;
+        sessionData.fbclid = clickIds.fbclid;
+        sessionData.msclkid = clickIds.msclkid;
+        sessionData.screenWidth = window.screen.width;
+        sessionData.screenHeight = window.screen.height;
+      }
+      if (debug) {
+        console.log("[Analytics] Journey step:", sessionData);
+      }
+      await analyticsSend("/api/public/analytics/session", sessionData, gate);
+    };
+    scheduleIdleTask(() => trackJourneyStep());
+    const handleUnload = () => {
+      const duration = Math.round((Date.now() - journeyStartTimeRef.current) / 1e3);
+      analyticsBeacon(
+        "/api/public/analytics/session",
+        {
+          sessionId: sessionIdRef.current,
+          site,
+          action: "end",
+          duration,
+          lastPage: pathname,
+          previousPageDuration: Math.round((Date.now() - pageEnterTimeRef.current) / 1e3),
+          previousPageScrollDepth: currentScrollDepthRef.current
+        },
+        gate
+      );
+    };
+    window.addEventListener("pagehide", handleUnload);
+    return () => {
+      window.removeEventListener("pagehide", handleUnload);
+    };
+  }, [pathname, gate, trackJourneys, debug]);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    if (debug) console.log("[Analytics] Scroll tracking setup:", { trackScrollDepth, hasApiKey: !!propApiKey });
+    if (!trackScrollDepth) return;
+    if (!resolveAnalyticsTarget(gate)) {
+      if (debug) console.warn("[Analytics] Scroll tracking disabled (no key, or embedded)");
+      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 = {
+        sessionId: sessionIdRef.current,
+        visitorId: visitorIdRef.current,
+        site,
+        pagePath: pathname,
+        maxDepthPercent: maxDepth,
+        timeTo25: milestone25,
+        timeTo50: milestone50,
+        timeTo75: milestone75,
+        timeTo100: milestone100,
+        totalTimeSeconds: totalTime,
+        deviceType: getDeviceType()
+      };
+      if (useBeacon) {
+        analyticsBeacon("/api/public/analytics/scroll-depth", payload, gate);
+      } else {
+        await analyticsSend("/api/public/analytics/scroll-depth", payload, {
+          ...gate,
+          keepalive: true
+        });
+      }
+      if (debug) console.log("[Analytics] Scroll depth:", { maxDepth, totalTime, useBeacon });
+    };
+    maxDepth = 0;
+    startTime = Date.now();
+    milestone25 = null;
+    milestone50 = null;
+    milestone75 = null;
+    milestone100 = null;
+    hasTracked = false;
+    window.addEventListener("scroll", handleScroll, { passive: true });
+    handleScroll();
+    const stopLeaveListener = onPageLeave(() => sendScrollData(true));
+    return () => {
+      window.removeEventListener("scroll", handleScroll);
+      stopLeaveListener();
+      sendScrollData(false);
+    };
+  }, [pathname, gate, trackScrollDepth, debug]);
+  useEffect(() => {
+    if (!trackClicks) return;
+    if (typeof window === "undefined") return;
+    if (!resolveAnalyticsTarget(gate)) 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 docWidth = document.documentElement.scrollWidth || viewportWidth;
+      const xPercent = Math.round(e.pageX / docWidth * 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,
+        site,
+        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(() => {
+        void analyticsSend("/api/public/analytics/heatmap-click", clickData, gate);
+      }, 500);
+    };
+    document.addEventListener("click", handleClick, { passive: true });
+    return () => {
+      document.removeEventListener("click", handleClick);
+    };
+  }, [pathname, gate, trackClicks, debug]);
+  const trackEvent = useCallback((options) => {
+    const doTrack = async () => {
+      const event = {
+        sessionId: sessionIdRef.current,
+        visitorId: visitorIdRef.current,
+        site,
+        eventName: options.name,
+        eventCategory: options.category,
+        eventLabel: options.label,
+        eventValue: options.value,
+        properties: options.properties,
+        pagePath: pathname
+      };
+      if (debug) {
+        console.log("[Analytics] Event:", event);
+      }
+      const response = await analyticsSend("/api/public/analytics/event", event, gate);
+      if (response && !response.ok && debug) {
+        console.error("[Analytics] Error tracking event:", response.statusText);
+      }
+    };
+    scheduleIdleTask(doTrack, 1e3);
+  }, [gate, site, pathname, debug]);
+  const trackConversion = useCallback((options) => {
+    const doTrack = async () => {
+      const conversion = {
+        sessionId: sessionIdRef.current,
+        visitorId: visitorIdRef.current,
+        site,
+        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);
+      }
+      const response = await analyticsSend("/api/public/analytics/conversion", conversion, gate);
+      if (response && !response.ok && debug) {
+        console.error("[Analytics] Error tracking conversion:", response.statusText);
+      }
+    };
+    doTrack();
+  }, [gate, site, pathname, debug]);
+  useEffect(() => {
+    registerAnalyticsDispatcher({ trackEvent, trackConversion });
+    return () => registerAnalyticsDispatcher(null);
+  }, [trackEvent, trackConversion]);
+  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,
+        site,
+        visitorId: externalVisitorId,
+        sessionId: externalSessionId,
+        sessionTimeout,
+        allowInFrame,
+        allowLocalhost,
+        debug
+      }
+    ),
+    children
+  ] });
+}
+function useAnalytics() {
+  const context = useContext(AnalyticsContext);
+  if (!context) {
+    throw new Error("useAnalytics must be used within an AnalyticsProvider");
+  }
+  return context;
+}
+function useAnalyticsOptional() {
+  return useContext(AnalyticsContext);
+}
+function useTrackEvent() {
+  const { trackEvent, trackConversion } = useAnalytics();
+  return { trackEvent, trackConversion };
+}
+
+export { AnalyticsProvider, WebVitals, useAnalytics, useAnalyticsOptional, useTrackEvent };