aurea-tracking-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,473 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  getAurea: () => getAurea,
+  identifyUser: () => identifyUser,
+  initAurea: () => initAurea,
+  trackConversion: () => trackConversion,
+  trackEvent: () => trackEvent,
+  trackPage: () => trackPage
+});
+module.exports = __toCommonJS(index_exports);
+var AureaSDK = class {
+  constructor(config) {
+    this.eventQueue = [];
+    this.initialized = false;
+    this.config = {
+      apiUrl: "http://localhost:3000/api",
+      debug: false,
+      autoTrack: {
+        pageViews: true,
+        forms: true,
+        clicks: false,
+        scrollDepth: false
+      },
+      respectDoNotTrack: true,
+      anonymizeIp: true,
+      batchSize: 10,
+      batchInterval: 2e3,
+      ...config
+    };
+    this.sessionId = this.getOrCreateSessionId();
+    this.anonymousId = this.getOrCreateAnonymousId();
+    if (typeof window !== "undefined") {
+      const savedUserId = localStorage.getItem("aurea_user_id");
+      if (savedUserId) {
+        this.userId = savedUserId;
+      }
+    }
+  }
+  /**
+   * Initialize the SDK
+   */
+  init() {
+    if (this.initialized) {
+      console.warn("[Aurea SDK] Already initialized");
+      return;
+    }
+    if (this.config.respectDoNotTrack && typeof navigator !== "undefined" && (navigator.doNotTrack === "1" || navigator.msDoNotTrack === "1")) {
+      if (this.config.debug) {
+        console.log("[Aurea SDK] Do Not Track enabled, skipping initialization");
+      }
+      return;
+    }
+    this.initialized = true;
+    if (this.config.autoTrack?.pageViews) {
+      this.trackPageLoad();
+      this.trackPageChanges();
+    }
+    if (this.config.autoTrack?.forms) {
+      this.trackForms();
+    }
+    if (this.config.autoTrack?.scrollDepth) {
+      this.trackScrollDepth();
+    }
+    this.startBatchTimer();
+    this.startPurchasePolling();
+    if (this.config.debug) {
+      console.log("[Aurea SDK] Initialized", {
+        sessionId: this.sessionId,
+        anonymousId: this.anonymousId,
+        userId: this.userId
+      });
+    }
+  }
+  /**
+   * Track a custom event
+   */
+  track(eventName, properties) {
+    const event = {
+      eventId: this.generateEventId(),
+      eventName,
+      properties: properties || {},
+      context: this.buildContext(),
+      timestamp: Date.now()
+    };
+    this.enqueueEvent(event);
+    if (this.config.debug) {
+      console.log("[Aurea SDK] Event tracked:", eventName, properties);
+    }
+  }
+  /**
+   * Identify a user
+   */
+  identify(userId, traits) {
+    this.userId = userId;
+    if (typeof window !== "undefined") {
+      localStorage.setItem("aurea_user_id", userId);
+      if (traits) {
+        localStorage.setItem("aurea_user_traits", JSON.stringify(traits));
+      }
+    }
+    this.track("user_identified", {
+      userId,
+      traits
+    });
+    if (this.config.debug) {
+      console.log("[Aurea SDK] User identified:", userId);
+    }
+  }
+  /**
+   * Track a page view
+   */
+  page(name, properties) {
+    this.track("page_view", {
+      pageName: name || (typeof document !== "undefined" ? document.title : ""),
+      pageUrl: typeof window !== "undefined" ? window.location.href : "",
+      pagePath: typeof window !== "undefined" ? window.location.pathname : "",
+      pageSearch: typeof window !== "undefined" ? window.location.search : "",
+      referrer: typeof document !== "undefined" ? document.referrer : "",
+      ...properties
+    });
+  }
+  /**
+   * Track a conversion event
+   */
+  conversion(data) {
+    this.track("conversion", {
+      conversionType: data.type,
+      revenue: data.revenue,
+      currency: data.currency || "USD",
+      orderId: data.orderId,
+      ...data.properties
+    });
+    if (typeof sessionStorage !== "undefined") {
+      sessionStorage.setItem("aurea_converted", "true");
+    }
+    if (this.config.debug) {
+      console.log("[Aurea SDK] Conversion tracked:", data);
+    }
+  }
+  /**
+   * Get or create session ID
+   */
+  getOrCreateSessionId() {
+    if (typeof sessionStorage === "undefined") {
+      return this.generateId();
+    }
+    let sessionId = sessionStorage.getItem("aurea_session_id");
+    if (!sessionId) {
+      sessionId = this.generateId();
+      sessionStorage.setItem("aurea_session_id", sessionId);
+    }
+    return sessionId;
+  }
+  /**
+   * Get or create anonymous ID
+   */
+  getOrCreateAnonymousId() {
+    if (typeof localStorage === "undefined") {
+      return this.generateId();
+    }
+    let anonymousId = localStorage.getItem("aurea_anonymous_id");
+    if (!anonymousId) {
+      anonymousId = this.generateId();
+      localStorage.setItem("aurea_anonymous_id", anonymousId);
+    }
+    return anonymousId;
+  }
+  /**
+   * Build event context
+   */
+  buildContext() {
+    const url = typeof window !== "undefined" ? new URL(window.location.href) : new URL("http://localhost");
+    return {
+      page: typeof window !== "undefined" ? {
+        url: window.location.href,
+        path: window.location.pathname,
+        title: document.title,
+        referrer: document.referrer
+      } : void 0,
+      utm: {
+        source: url.searchParams.get("utm_source") || void 0,
+        medium: url.searchParams.get("utm_medium") || void 0,
+        campaign: url.searchParams.get("utm_campaign") || void 0,
+        term: url.searchParams.get("utm_term") || void 0,
+        content: url.searchParams.get("utm_content") || void 0
+      },
+      user: {
+        userId: this.userId,
+        anonymousId: this.anonymousId
+      },
+      session: {
+        sessionId: this.sessionId
+      },
+      device: typeof navigator !== "undefined" ? {
+        userAgent: navigator.userAgent,
+        screenWidth: window.screen?.width,
+        screenHeight: window.screen?.height,
+        language: navigator.language,
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+      } : void 0
+    };
+  }
+  /**
+   * Track initial page load
+   */
+  trackPageLoad() {
+    if (typeof window !== "undefined") {
+      const justPurchased = localStorage.getItem("aurea_just_purchased");
+      const isThankYouPage = window.location.pathname.includes("/thank-you");
+      if (justPurchased === "true" && !isThankYouPage) {
+        console.log("[Aurea SDK] Purchase detected, redirecting to thank-you page...");
+        localStorage.removeItem("aurea_just_purchased");
+        window.location.href = "/thank-you?from_checkout=true";
+        return;
+      }
+      const referrer = document.referrer;
+      const urlParams = new URLSearchParams(window.location.search);
+      const fromCheckout = urlParams.get("from_checkout") === "true";
+      const whopReferrer = referrer.includes("whop.com");
+      if ((fromCheckout || whopReferrer || justPurchased === "true") && isThankYouPage) {
+        localStorage.removeItem("aurea_just_purchased");
+        this.track("checkout_return", {
+          referrer,
+          returnUrl: window.location.href,
+          fromWhop: whopReferrer,
+          landingPage: "/thank-you"
+        });
+      }
+      this.page();
+    }
+  }
+  /**
+   * Track page changes (for SPAs)
+   */
+  trackPageChanges() {
+    if (typeof window === "undefined") return;
+    let lastPath = window.location.pathname;
+    const observer = new MutationObserver(() => {
+      if (window.location.pathname !== lastPath) {
+        lastPath = window.location.pathname;
+        this.page();
+      }
+    });
+    observer.observe(document.body, {
+      childList: true,
+      subtree: true
+    });
+    window.addEventListener("popstate", () => {
+      this.page();
+    });
+  }
+  /**
+   * Track form submissions
+   */
+  trackForms() {
+    if (typeof document === "undefined") return;
+    document.addEventListener("submit", (e) => {
+      const form = e.target;
+      const formId = form.id || form.name || "unknown";
+      this.track("form_submit", {
+        formId,
+        formAction: form.action,
+        formMethod: form.method
+      });
+    });
+  }
+  /**
+   * Track scroll depth
+   */
+  trackScrollDepth() {
+    if (typeof window === "undefined") return;
+    const depths = [25, 50, 75, 100];
+    const tracked = /* @__PURE__ */ new Set();
+    const checkScroll = () => {
+      const scrollPercent = window.scrollY / (document.body.scrollHeight - window.innerHeight) * 100;
+      for (const depth of depths) {
+        if (scrollPercent >= depth && !tracked.has(depth)) {
+          tracked.add(depth);
+          this.track("scroll_depth", { depth });
+        }
+      }
+    };
+    window.addEventListener("scroll", checkScroll, { passive: true });
+  }
+  /**
+   * Enqueue event for batching
+   */
+  enqueueEvent(event) {
+    this.eventQueue.push(event);
+    if (this.eventQueue.length >= (this.config.batchSize || 10)) {
+      this.flushEvents();
+    }
+  }
+  /**
+   * Send events to API
+   */
+  async sendEvents(events) {
+    if (events.length === 0) return;
+    try {
+      const response = await fetch(`${this.config.apiUrl}/track/events`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Aurea-API-Key": this.config.apiKey,
+          "X-Aurea-Funnel-ID": this.config.funnelId
+        },
+        body: JSON.stringify({
+          events,
+          batch: true
+        }),
+        keepalive: true
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      if (this.config.debug) {
+        console.log("[Aurea SDK] Events sent successfully:", events.length);
+      }
+    } catch (error) {
+      console.error("[Aurea SDK] Failed to send events:", error);
+      if (typeof localStorage !== "undefined") {
+        const failedEvents = JSON.parse(localStorage.getItem("aurea_failed_events") || "[]") || [];
+        failedEvents.push(...events);
+        localStorage.setItem("aurea_failed_events", JSON.stringify(failedEvents));
+      }
+    }
+  }
+  /**
+   * Flush queued events
+   */
+  flushEvents() {
+    if (this.eventQueue.length === 0) return;
+    const eventsToSend = [...this.eventQueue];
+    this.eventQueue = [];
+    this.sendEvents(eventsToSend);
+  }
+  /**
+   * Start batch timer
+   */
+  startBatchTimer() {
+    if (typeof window === "undefined") return;
+    this.batchTimer = setInterval(() => {
+      this.flushEvents();
+    }, this.config.batchInterval || 2e3);
+    window.addEventListener("beforeunload", () => {
+      this.flushEvents();
+    });
+    document.addEventListener("visibilitychange", () => {
+      if (document.hidden) {
+        this.flushEvents();
+      }
+    });
+  }
+  /**
+   * Poll for purchase completion
+   * Checks every 3 seconds if user has made a purchase
+   */
+  startPurchasePolling() {
+    if (typeof window === "undefined") return;
+    this.checkForPurchase();
+    setInterval(() => {
+      this.checkForPurchase();
+    }, 3e3);
+  }
+  /**
+   * Check if user has completed a purchase
+   */
+  async checkForPurchase() {
+    try {
+      const response = await fetch(
+        `${this.config.apiUrl?.replace("/api", "")}/api/check-purchase?anonymousId=${this.anonymousId}`
+      );
+      const data = await response.json();
+      if (data.hasPurchased) {
+        console.log("[Aurea SDK] Purchase detected! Redirecting to thank-you page...");
+        localStorage.setItem("aurea_just_purchased", "true");
+        window.location.href = "/thank-you?from_checkout=true";
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.log("[Aurea SDK] Purchase check failed:", error);
+      }
+    }
+  }
+  /**
+   * Generate unique ID
+   */
+  generateId() {
+    return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+  /**
+   * Generate event ID
+   */
+  generateEventId() {
+    return `evt_${this.generateId()}`;
+  }
+};
+var sdkInstance = null;
+function initAurea(config) {
+  if (sdkInstance) {
+    console.warn("[Aurea SDK] SDK already initialized");
+    return sdkInstance;
+  }
+  sdkInstance = new AureaSDK(config);
+  sdkInstance.init();
+  if (typeof window !== "undefined") {
+    window.aurea = sdkInstance;
+  }
+  return sdkInstance;
+}
+function getAurea() {
+  return sdkInstance;
+}
+function trackEvent(name, properties) {
+  const aurea = getAurea();
+  if (aurea) {
+    aurea.track(name, properties);
+  } else {
+    console.warn("[Aurea SDK] SDK not initialized. Call initAurea() first.");
+  }
+}
+function identifyUser(userId, traits) {
+  const aurea = getAurea();
+  if (aurea) {
+    aurea.identify(userId, traits);
+  } else {
+    console.warn("[Aurea SDK] SDK not initialized. Call initAurea() first.");
+  }
+}
+function trackConversion(data) {
+  const aurea = getAurea();
+  if (aurea) {
+    aurea.conversion(data);
+  } else {
+    console.warn("[Aurea SDK] SDK not initialized. Call initAurea() first.");
+  }
+}
+function trackPage(name, properties) {
+  const aurea = getAurea();
+  if (aurea) {
+    aurea.page(name, properties);
+  } else {
+    console.warn("[Aurea SDK] SDK not initialized. Call initAurea() first.");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAurea,
+  identifyUser,
+  initAurea,
+  trackConversion,
+  trackEvent,
+  trackPage
+});