@uptrademedia/site-kit 1.0.8 → 1.0.10

package/dist/index.mjs

@@ -3,24 +3,451 @@ export { AEOBlock, AEOCitedContent, AEOClaim, AEOComparison, AEODefinition, AEOE
 export { CalendarView, CheckoutForm, EventCalendar, EventEmbed, EventModal, EventTile, OfferingCard, OfferingList, ProductEmbed, RegistrationForm, UpcomingEvents, createCheckoutSession, fetchNextEvent, fetchOffering, fetchOfferings, fetchProducts, fetchServices, fetchUpcomingEvents, formatDate, formatDateTime, formatPrice, getOfferingUrl, registerForEvent, useEventModal } from './chunk-DOHML47I.mjs';
 export { SetupWizard } from './chunk-XFRPT5ZX.mjs';
 export { clearRedirectCache, fetchRedirectRules, generateNextRedirects, handleManagedRedirects } from './chunk-VDMZZL2O.mjs';
-import { useSignalExperiment, useSignalEvent } from './chunk-MB3WR5KJ.mjs';
-export { ManagedImage, SignalBridge, SiteKitProvider, assignImageToSlot, clearImageSlot, fetchManagedImage, fetchManagedImages, listImageFiles, uploadImage, useSignal, useSignalConfig, useSignalEvent, useSignalExperiment, useSignalOutcome, useSiteKit } from './chunk-MB3WR5KJ.mjs';
-import './chunk-WPSRS352.mjs';
-import './chunk-42EXHJTC.mjs';
-import './chunk-DYM5ML2V.mjs';
-import './chunk-SMUFNQLM.mjs';
+export { ManagedImage, assignImageToSlot, clearImageSlot, fetchManagedImage, fetchManagedImages, listImageFiles, uploadImage } from './chunk-CDJL2YGL.mjs';
+import { SitemapSync } from './chunk-WPSRS352.mjs';
+import { AnalyticsProvider } from './chunk-42EXHJTC.mjs';
+import { EngageWidget } from './chunk-DYM5ML2V.mjs';
+import { configureFormsApi } from './chunk-SMUFNQLM.mjs';
 import './chunk-4XPGGLVP.mjs';
-import React, { useState, useEffect, useRef, useCallback, useMemo } from 'react';
+import React3, { createContext, useContext, useState, useRef, useCallback, useEffect, useMemo, Suspense } from 'react';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 
-// src/affiliates/api.ts
+var SignalContext = createContext(null);
+function useSignal() {
+  const context = useContext(SignalContext);
+  if (!context) {
+    throw new Error("useSignal must be used within a SignalBridge");
+  }
+  return context;
+}
 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 getVisitorId() {
+  if (typeof window === "undefined") return "";
+  const key = "_uptrade_vid";
+  let visitorId = localStorage.getItem(key);
+  if (!visitorId) {
+    visitorId = crypto.randomUUID();
+    localStorage.setItem(key, visitorId);
+  }
+  return visitorId;
+}
+function getSessionId() {
+  if (typeof window === "undefined") return "";
+  const key = "_uptrade_sid";
+  let sessionId = sessionStorage.getItem(key);
+  if (!sessionId) {
+    sessionId = crypto.randomUUID();
+    sessionStorage.setItem(key, sessionId);
+  }
+  return sessionId;
+}
+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";
+  return "Other";
+}
+function getOS() {
+  if (typeof window === "undefined") return "unknown";
+  const ua = navigator.userAgent;
+  if (ua.includes("Windows")) return "Windows";
+  if (ua.includes("Mac")) return "macOS";
+  if (ua.includes("iPhone") || ua.includes("iPad")) return "iOS";
+  if (ua.includes("Android")) return "Android";
+  if (ua.includes("Linux")) return "Linux";
+  return "Other";
+}
+function SignalBridge({
+  enabled = true,
+  realtime = true,
+  experiments = true,
+  behaviorTracking = true,
+  children
+}) {
+  const [config, setConfig] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const eventSourceRef = useRef(null);
+  const eventQueueRef = useRef([]);
+  const flushTimeoutRef = useRef(null);
+  const assignmentsRef = useRef(/* @__PURE__ */ new Map());
+  const pageLoadTimeRef = useRef(Date.now());
+  const scrollDepthRef = useRef(0);
+  const clickCountRef = useRef(0);
+  const { apiUrl, apiKey } = getApiConfig();
+  const fetchConfig = useCallback(async () => {
+    if (!apiKey || !enabled) {
+      setLoading(false);
+      return;
+    }
+    try {
+      const response = await fetch(`${apiUrl}/api/public/signal/config`, {
+        headers: {
+          "x-api-key": apiKey,
+          "x-visitor-id": getVisitorId()
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch Signal config: ${response.statusText}`);
+      }
+      const data = await response.json();
+      setConfig(data.config);
+      setError(null);
+      if (experiments && data.config?.experiments) {
+        for (const exp of data.config.experiments) {
+          if (exp.status === "running") {
+            await loadExperimentAssignment(exp.id);
+          }
+        }
+      }
+    } catch (err) {
+      console.error("[Signal] Config fetch error:", err);
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [apiUrl, apiKey, enabled, experiments]);
+  const connectSSE = useCallback(() => {
+    if (!apiKey || !enabled || !realtime) return;
+    if (eventSourceRef.current) {
+      eventSourceRef.current.close();
+    }
+    const url = `${apiUrl}/api/public/signal/stream?key=${apiKey}`;
+    const eventSource = new EventSource(url);
+    eventSource.addEventListener("config_update", (e) => {
+      try {
+        const { config: newConfig, version } = JSON.parse(e.data);
+        setConfig((prev) => {
+          if (prev?.version !== version) {
+            console.log("[Signal] Config updated to version:", version);
+            return newConfig;
+          }
+          return prev;
+        });
+      } catch (err) {
+        console.error("[Signal] SSE parse error:", err);
+      }
+    });
+    eventSource.addEventListener("experiment_update", (e) => {
+      try {
+        const { experiment_id, action } = JSON.parse(e.data);
+        if (action === "started" || action === "updated") {
+          loadExperimentAssignment(experiment_id);
+        } else if (action === "stopped") {
+          assignmentsRef.current.delete(experiment_id);
+        }
+      } catch (err) {
+        console.error("[Signal] Experiment update error:", err);
+      }
+    });
+    eventSource.onerror = () => {
+      console.warn("[Signal] SSE connection error, reconnecting...");
+      eventSource.close();
+      setTimeout(connectSSE, 5e3);
+    };
+    eventSourceRef.current = eventSource;
+  }, [apiUrl, apiKey, enabled, realtime]);
+  const loadExperimentAssignment = useCallback(async (experimentId) => {
+    const storageKey = `_signal_exp_${experimentId}`;
+    const stored = localStorage.getItem(storageKey);
+    if (stored) {
+      try {
+        const assignment = JSON.parse(stored);
+        if (assignment.expires > Date.now()) {
+          assignmentsRef.current.set(experimentId, assignment);
+          return assignment;
+        }
+      } catch {
+      }
+    }
+    try {
+      const response = await fetch(`${apiUrl}/api/public/signal/experiment/${experimentId}`, {
+        headers: {
+          "x-api-key": apiKey,
+          "x-visitor-id": getVisitorId()
+        }
+      });
+      if (!response.ok) return null;
+      const assignment = await response.json();
+      localStorage.setItem(storageKey, JSON.stringify(assignment));
+      assignmentsRef.current.set(experimentId, assignment);
+      return assignment;
+    } catch (err) {
+      console.error("[Signal] Experiment assignment error:", err);
+      return null;
+    }
+  }, [apiUrl, apiKey]);
+  const getExperiment = useCallback((experimentId) => {
+    return assignmentsRef.current.get(experimentId) || null;
+  }, []);
+  const flushEvents = useCallback(async () => {
+    if (eventQueueRef.current.length === 0) return;
+    const events = [...eventQueueRef.current];
+    eventQueueRef.current = [];
+    try {
+      await fetch(`${apiUrl}/api/public/signal/events`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey
+        },
+        body: JSON.stringify({
+          visitor_id: getVisitorId(),
+          session_id: getSessionId(),
+          events
+        })
+      });
+    } catch (err) {
+      eventQueueRef.current = [...events, ...eventQueueRef.current];
+      console.error("[Signal] Event flush error:", err);
+    }
+  }, [apiUrl, apiKey]);
+  const trackEvent = useCallback((event) => {
+    if (!enabled || !apiKey) return;
+    const enrichedEvent = {
+      ...event,
+      page_url: window.location.href,
+      page_path: window.location.pathname,
+      referrer: document.referrer,
+      device_type: getDeviceType(),
+      browser: getBrowser(),
+      os: getOS(),
+      viewport_width: window.innerWidth,
+      viewport_height: window.innerHeight,
+      time_on_page: Date.now() - pageLoadTimeRef.current,
+      scroll_depth: scrollDepthRef.current,
+      click_count: clickCountRef.current,
+      experiments: Array.from(assignmentsRef.current.values()).map((a) => ({
+        experiment_id: a.experiment_id,
+        variant_key: a.variant_key
+      })),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    eventQueueRef.current.push(enrichedEvent);
+    if (flushTimeoutRef.current) {
+      clearTimeout(flushTimeoutRef.current);
+    }
+    flushTimeoutRef.current = setTimeout(flushEvents, 1e3);
+  }, [enabled, apiKey, flushEvents]);
+  const trackOutcome = useCallback(async (outcome) => {
+    if (!enabled || !apiKey) return;
+    try {
+      await fetch(`${apiUrl}/api/public/signal/outcome`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey
+        },
+        body: JSON.stringify({
+          ...outcome,
+          visitor_id: getVisitorId(),
+          session_id: getSessionId(),
+          experiments: Array.from(assignmentsRef.current.keys()),
+          page_url: window.location.href,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      });
+    } catch (err) {
+      console.error("[Signal] Outcome tracking error:", err);
+    }
+  }, [apiUrl, apiKey, enabled]);
+  useEffect(() => {
+    if (!behaviorTracking || typeof window === "undefined") return;
+    const handleScroll = () => {
+      const scrollTop = window.scrollY;
+      const docHeight = document.documentElement.scrollHeight - window.innerHeight;
+      const depth = docHeight > 0 ? Math.round(scrollTop / docHeight * 100) : 0;
+      scrollDepthRef.current = Math.max(scrollDepthRef.current, depth);
+    };
+    const handleClick = () => {
+      clickCountRef.current++;
+    };
+    window.addEventListener("scroll", handleScroll, { passive: true });
+    window.addEventListener("click", handleClick);
+    const handleVisibilityChange = () => {
+      if (document.visibilityState === "hidden") {
+        flushEvents();
+      }
+    };
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+    window.addEventListener("beforeunload", flushEvents);
+    return () => {
+      window.removeEventListener("scroll", handleScroll);
+      window.removeEventListener("click", handleClick);
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+      window.removeEventListener("beforeunload", flushEvents);
+    };
+  }, [behaviorTracking, flushEvents]);
+  useEffect(() => {
+    fetchConfig();
+  }, [fetchConfig]);
+  useEffect(() => {
+    if (config && realtime) {
+      connectSSE();
+    }
+    return () => {
+      if (eventSourceRef.current) {
+        eventSourceRef.current.close();
+      }
+    };
+  }, [config, realtime, connectSSE]);
+  const contextValue = useMemo(() => ({
+    config,
+    loading,
+    error,
+    trackEvent,
+    trackOutcome,
+    getExperiment,
+    refreshConfig: fetchConfig
+  }), [config, loading, error, trackEvent, trackOutcome, getExperiment, fetchConfig]);
+  return /* @__PURE__ */ jsx(SignalContext.Provider, { value: contextValue, children });
+}
+function useSignalConfig() {
+  const { config } = useSignal();
+  return config;
+}
+function useSignalEvent() {
+  const { trackEvent } = useSignal();
+  return trackEvent;
+}
+function useSignalOutcome() {
+  const { trackOutcome } = useSignal();
+  return { trackOutcome };
+}
+function useSignalExperiment(experimentId) {
+  const { getExperiment, config } = useSignal();
+  const assignment = getExperiment(experimentId);
+  const experiment = config?.experiments?.find((e) => e.id === experimentId);
+  const isRunning = experiment?.status === "running";
+  return {
+    assignment: isRunning ? assignment : null,
+    variant: isRunning && assignment ? assignment.variant_key : null,
+    isControl: !assignment || assignment.variant_key === "control"
+  };
+}
+var SiteKitContext = createContext(null);
+function useSiteKit() {
+  const context = useContext(SiteKitContext);
+  if (!context) {
+    throw new Error("useSiteKit must be used within a SiteKitProvider");
+  }
+  return context;
+}
+function SiteKitProvider({
+  children,
+  apiKey,
+  apiUrl,
+  signalUrl,
+  analytics,
+  engage,
+  forms,
+  signal,
+  debug = false
+}) {
+  const finalApiUrl = apiUrl || "https://api.uptrademedia.com";
+  const finalSignalUrl = signalUrl || "https://signal.uptrademedia.com";
+  if (!apiKey) {
+    console.error("@uptrade/site-kit: No API key provided. Set NEXT_PUBLIC_UPTRADE_API_KEY environment variable.");
+  }
+  useEffect(() => {
+    if (typeof window !== "undefined") {
+      window.__SITE_KIT_API_URL__ = finalApiUrl;
+      window.__SITE_KIT_SIGNAL_URL__ = finalSignalUrl;
+      window.__SITE_KIT_API_KEY__ = apiKey;
+      window.__SITE_KIT_DEBUG__ = debug;
+    }
+    if (apiKey) {
+      configureFormsApi({
+        baseUrl: finalApiUrl,
+        apiKey
+      });
+    }
+  }, [finalApiUrl, finalSignalUrl, apiKey, debug]);
+  const contextValue = useMemo(
+    () => ({
+      apiUrl: finalApiUrl,
+      signalUrl: finalSignalUrl,
+      apiKey,
+      analytics,
+      engage,
+      forms,
+      signal,
+      debug,
+      isReady: true
+    }),
+    [finalApiUrl, finalSignalUrl, apiKey, analytics, engage, forms, signal, debug]
+  );
+  let content = /* @__PURE__ */ jsx(Fragment, { children });
+  if (signal?.enabled) {
+    content = /* @__PURE__ */ jsx(
+      SignalBridge,
+      {
+        enabled: signal.enabled,
+        realtime: signal.realtime !== false,
+        experiments: signal.experiments !== false,
+        behaviorTracking: signal.behaviorTracking !== false,
+        children: content
+      }
+    );
+  }
+  if (analytics?.enabled) {
+    content = /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(
+      AnalyticsProvider,
+      {
+        apiUrl: finalApiUrl,
+        apiKey,
+        trackPageViews: analytics.trackPageViews !== false,
+        trackWebVitals: analytics.trackWebVitals !== false,
+        trackScrollDepth: analytics.trackScrollDepth !== false,
+        trackClicks: analytics.trackClicks !== false,
+        debug,
+        children: content
+      }
+    ) });
+  }
+  if (engage?.enabled) {
+    content = /* @__PURE__ */ jsxs(Fragment, { children: [
+      content,
+      /* @__PURE__ */ jsx(
+        EngageWidget,
+        {
+          apiUrl: finalApiUrl,
+          apiKey,
+          position: engage.position || "bottom-right",
+          chatEnabled: engage.chatEnabled !== false
+        }
+      )
+    ] });
+  }
+  content = /* @__PURE__ */ jsxs(Fragment, { children: [
+    content,
+    /* @__PURE__ */ jsx(SitemapSync, { debug })
+  ] });
+  return /* @__PURE__ */ jsx(SiteKitContext.Provider, { value: contextValue, children: content });
+}
+
+// src/affiliates/api.ts
+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__ || "" : "";
   return { apiUrl, apiKey };
 }
 async function apiGet(endpoint) {
-  const { apiUrl, apiKey } = getApiConfig();
+  const { apiUrl, apiKey } = getApiConfig2();
   if (!apiKey) {
     console.error("[Affiliates] No API key configured");
     return null;
@@ -49,7 +476,7 @@ async function fetchAffiliates(options = {}) {
   return result?.affiliates || [];
 }
 function getTrackingUrl(affiliateId, offerId) {
-  const { apiUrl } = getApiConfig();
+  const { apiUrl } = getApiConfig2();
   return `${apiUrl}/a/${affiliateId}/${offerId}`;
 }
 function useAffiliates() {
@@ -210,7 +637,7 @@ function ExperimentConversion({
       }
     });
   };
-  return React.cloneElement(children, {
+  return React3.cloneElement(children, {
     onClick: (e) => {
       handleInteraction();
       if (children.props.onClick) {
@@ -1227,7 +1654,7 @@ Let me help you with that. What would you like to do?`,
                     ...styles.bubble,
                     ...message.role === "assistant" ? styles.bubbleAssistant : styles.bubbleUser
                   },
-                  children: message.content.split("\n").map((line, i) => /* @__PURE__ */ jsxs(React.Fragment, { children: [
+                  children: message.content.split("\n").map((line, i) => /* @__PURE__ */ jsxs(React3.Fragment, { children: [
                     line,
                     i < message.content.split("\n").length - 1 && /* @__PURE__ */ jsx("br", {})
                   ] }, i))
@@ -2196,6 +2623,6 @@ function BookingWidget({
   );
 }
 
-export { AffiliateCard, AffiliatesWidget, BookingWidget, ExperimentConversion, SetupAssistant, SignalExperiment, createBooking, createSlotHold, detectTimezone, fetchAffiliates, fetchAvailability, fetchAvailableDates, fetchBookingTypeDetails, fetchBookingTypes, formatDate2 as formatBookingDate, formatTime as formatBookingTime, formatDuration, getTrackingUrl, releaseSlotHold, useAffiliates, useExperimentVariant };
+export { AffiliateCard, AffiliatesWidget, BookingWidget, ExperimentConversion, SetupAssistant, SignalBridge, SignalExperiment, SiteKitProvider, createBooking, createSlotHold, detectTimezone, fetchAffiliates, fetchAvailability, fetchAvailableDates, fetchBookingTypeDetails, fetchBookingTypes, formatDate2 as formatBookingDate, formatTime as formatBookingTime, formatDuration, getTrackingUrl, releaseSlotHold, useAffiliates, useExperimentVariant, useSignal, useSignalConfig, useSignalEvent, useSignalExperiment, useSignalOutcome, useSiteKit };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map