@outlit/browser 1.1.0 → 1.2.0

package/dist/vue/index.mjs

@@ -0,0 +1,1149 @@
+// src/vue/plugin.ts
+import { readonly, ref, shallowRef, watch } from "vue";
+
+// src/tracker.ts
+import {
+  DEFAULT_API_HOST,
+  buildBillingEvent,
+  buildCalendarEvent,
+  buildCustomEvent,
+  buildFormEvent,
+  buildIdentifyEvent,
+  buildIngestPayload,
+  buildPageviewEvent,
+  buildStageEvent
+} from "@outlit/core";
+
+// src/autocapture.ts
+import { extractIdentityFromForm, sanitizeFormFields } from "@outlit/core";
+var pageviewCallback = null;
+var lastUrl = null;
+function initPageviewTracking(callback) {
+  pageviewCallback = callback;
+  capturePageview();
+  setupSpaListeners();
+}
+function capturePageview() {
+  if (!pageviewCallback) return;
+  const url = window.location.href;
+  const referrer = document.referrer;
+  const title = document.title;
+  if (url === lastUrl) return;
+  lastUrl = url;
+  pageviewCallback(url, referrer, title);
+}
+function capturePageviewDelayed() {
+  setTimeout(capturePageview, 10);
+}
+function setupSpaListeners() {
+  window.addEventListener("popstate", () => {
+    capturePageviewDelayed();
+  });
+  const originalPushState = history.pushState;
+  const originalReplaceState = history.replaceState;
+  history.pushState = function(...args) {
+    originalPushState.apply(this, args);
+    capturePageviewDelayed();
+  };
+  history.replaceState = function(...args) {
+    originalReplaceState.apply(this, args);
+    capturePageviewDelayed();
+  };
+}
+var formCallback = null;
+var formDenylist;
+var identityCallback = null;
+function initFormTracking(callback, denylist, onIdentity) {
+  formCallback = callback;
+  formDenylist = denylist;
+  identityCallback = onIdentity ?? null;
+  document.addEventListener("submit", handleFormSubmit, true);
+}
+function handleFormSubmit(event) {
+  if (!formCallback) return;
+  const form = event.target;
+  if (!(form instanceof HTMLFormElement)) return;
+  const url = window.location.href;
+  const formId = form.id || form.name || void 0;
+  const formData = new FormData(form);
+  const fields = {};
+  const inputTypes = /* @__PURE__ */ new Map();
+  const inputs = form.querySelectorAll("input, select, textarea");
+  for (const input of inputs) {
+    const name = input.getAttribute("name");
+    if (name && input instanceof HTMLInputElement) {
+      inputTypes.set(name, input.type);
+    }
+  }
+  formData.forEach((value, key) => {
+    if (typeof value === "string") {
+      fields[key] = value;
+    }
+  });
+  const sanitizedFields = sanitizeFormFields(fields, formDenylist);
+  if (identityCallback) {
+    const identity = extractIdentityFromForm(fields, inputTypes);
+    if (identity) {
+      identityCallback(identity);
+    }
+  }
+  if (sanitizedFields && Object.keys(sanitizedFields).length > 0) {
+    formCallback(url, formId, sanitizedFields);
+  }
+}
+function stopAutocapture() {
+  pageviewCallback = null;
+  formCallback = null;
+  identityCallback = null;
+  document.removeEventListener("submit", handleFormSubmit, true);
+}
+
+// src/embed-integrations.ts
+var callbacks = null;
+var isListening = false;
+var calSetupAttempts = 0;
+var calCallbackRegistered = false;
+var lastBookingUid = null;
+var CAL_MAX_RETRY_ATTEMPTS = 10;
+var CAL_INITIAL_DELAY_MS = 200;
+var CAL_MAX_DELAY_MS = 2e3;
+function parseCalComBooking(data) {
+  const event = {
+    provider: "cal.com"
+  };
+  if (data.title) {
+    event.eventType = data.title;
+    const nameMatch = data.title.match(/between .+ and (.+)$/i);
+    if (nameMatch?.[1]) {
+      event.inviteeName = nameMatch[1].trim();
+    }
+  }
+  if (data.startTime) event.startTime = data.startTime;
+  if (data.endTime) event.endTime = data.endTime;
+  if (data.startTime && data.endTime) {
+    const start = new Date(data.startTime);
+    const end = new Date(data.endTime);
+    event.duration = Math.round((end.getTime() - start.getTime()) / 6e4);
+  }
+  if (data.isRecurring !== void 0) {
+    event.isRecurring = data.isRecurring;
+  }
+  return event;
+}
+function setupCalComListener() {
+  if (typeof window === "undefined") return;
+  if (calCallbackRegistered) return;
+  calSetupAttempts++;
+  if ("Cal" in window) {
+    const Cal = window.Cal;
+    if (typeof Cal === "function") {
+      try {
+        Cal("on", {
+          action: "bookingSuccessfulV2",
+          callback: handleCalComBooking
+        });
+        calCallbackRegistered = true;
+        return;
+      } catch (_e) {
+      }
+    }
+  }
+  if (calSetupAttempts < CAL_MAX_RETRY_ATTEMPTS) {
+    const delay = Math.min(CAL_INITIAL_DELAY_MS * calSetupAttempts, CAL_MAX_DELAY_MS);
+    setTimeout(setupCalComListener, delay);
+  }
+}
+function handleCalComBooking(e) {
+  if (!callbacks) return;
+  const data = e.detail?.data;
+  if (!data) return;
+  if (data.uid && data.uid === lastBookingUid) return;
+  lastBookingUid = data.uid || null;
+  const bookingEvent = parseCalComBooking(data);
+  callbacks.onCalendarBooked(bookingEvent);
+}
+function handlePostMessage(event) {
+  if (!callbacks) return;
+  if (isCalendlyEvent(event)) {
+    if (event.data.event === "calendly.event_scheduled") {
+      const bookingEvent = parseCalendlyBooking(event.data.payload);
+      callbacks.onCalendarBooked(bookingEvent);
+    }
+    return;
+  }
+  if (isCalComRawMessage(event)) {
+    const bookingData = extractCalComBookingFromMessage(event.data);
+    if (bookingData) {
+      if (bookingData.uid && bookingData.uid === lastBookingUid) return;
+      lastBookingUid = bookingData.uid || null;
+      const bookingEvent = parseCalComBooking(bookingData);
+      callbacks.onCalendarBooked(bookingEvent);
+    }
+  }
+}
+function isCalComRawMessage(event) {
+  if (!event.origin.includes("cal.com")) return false;
+  const data = event.data;
+  if (!data || typeof data !== "object") return false;
+  const messageType = data.type || data.action;
+  return messageType === "bookingSuccessfulV2" || messageType === "bookingSuccessful" || messageType === "booking_successful";
+}
+function extractCalComBookingFromMessage(data) {
+  if (!data || typeof data !== "object") return null;
+  const messageData = data;
+  if (messageData.data && typeof messageData.data === "object") {
+    return messageData.data;
+  }
+  if (messageData.booking && typeof messageData.booking === "object") {
+    return messageData.booking;
+  }
+  return null;
+}
+function isCalendlyEvent(e) {
+  return e.origin === "https://calendly.com" && e.data && typeof e.data.event === "string" && e.data.event.startsWith("calendly.");
+}
+function parseCalendlyBooking(_payload) {
+  return {
+    provider: "calendly"
+  };
+}
+function initCalendarTracking(cbs) {
+  if (isListening) return;
+  callbacks = cbs;
+  isListening = true;
+  calSetupAttempts = 0;
+  window.addEventListener("message", handlePostMessage);
+  setupCalComListener();
+}
+function stopCalendarTracking() {
+  if (!isListening) return;
+  window.removeEventListener("message", handlePostMessage);
+  callbacks = null;
+  isListening = false;
+  calCallbackRegistered = false;
+  calSetupAttempts = 0;
+  lastBookingUid = null;
+}
+
+// src/session-tracker.ts
+import { buildEngagementEvent } from "@outlit/core";
+var DEFAULT_IDLE_TIMEOUT = 3e4;
+var SESSION_TIMEOUT = 30 * 60 * 1e3;
+var TIME_UPDATE_INTERVAL = 1e3;
+var MIN_SPURIOUS_THRESHOLD = 50;
+var MIN_PAGE_TIME_FOR_ENGAGEMENT = 500;
+var SESSION_ID_KEY = "outlit_session_id";
+var SESSION_LAST_ACTIVITY_KEY = "outlit_session_last_activity";
+var SessionTracker = class {
+  state;
+  options;
+  idleTimeout;
+  timeUpdateInterval = null;
+  boundHandleActivity;
+  boundHandleVisibilityChange;
+  constructor(options) {
+    this.options = options;
+    this.idleTimeout = options.idleTimeout ?? DEFAULT_IDLE_TIMEOUT;
+    this.state = this.createInitialState();
+    this.boundHandleActivity = this.handleActivity.bind(this);
+    this.boundHandleVisibilityChange = this.handleVisibilityChange.bind(this);
+    this.setupEventListeners();
+    this.startTimeUpdateInterval();
+  }
+  /**
+   * Get the current session ID.
+   */
+  getSessionId() {
+    return this.state.sessionId;
+  }
+  // ============================================
+  // PUBLIC METHODS
+  // ============================================
+  /**
+   * Emit an engagement event for the current page session.
+   * Called by Tracker on exit events and SPA navigation.
+   *
+   * This method:
+   * 1. Finalizes any pending active time
+   * 2. Creates and emits the engagement event (if meaningful)
+   * 3. Resets state for the next session
+   */
+  emitEngagement() {
+    if (this.state.hasEmittedEngagement) {
+      return;
+    }
+    this.state.hasEmittedEngagement = true;
+    this.updateActiveTime();
+    const totalTimeMs = Date.now() - this.state.pageEntryTime;
+    const isSpuriousEvent = this.state.activeTimeMs < MIN_SPURIOUS_THRESHOLD && totalTimeMs < MIN_SPURIOUS_THRESHOLD;
+    const isTooSoonAfterNavigation = totalTimeMs < MIN_PAGE_TIME_FOR_ENGAGEMENT;
+    if (!isSpuriousEvent && !isTooSoonAfterNavigation) {
+      const event = buildEngagementEvent({
+        url: this.state.currentUrl,
+        referrer: document.referrer,
+        activeTimeMs: this.state.activeTimeMs,
+        totalTimeMs,
+        sessionId: this.state.sessionId
+      });
+      this.options.onEngagement(event);
+    }
+    this.resetState();
+  }
+  /**
+   * Handle SPA navigation.
+   * Called by Tracker when a new pageview is detected.
+   *
+   * This method:
+   * 1. Emits engagement for the OLD page (using stored state)
+   * 2. Updates state for the NEW page
+   */
+  onNavigation(newUrl) {
+    this.emitEngagement();
+    this.state.currentUrl = newUrl;
+    this.state.currentPath = this.extractPath(newUrl);
+    this.state.pageEntryTime = Date.now();
+    this.state.activeTimeMs = 0;
+    this.state.lastActiveTime = Date.now();
+    this.state.isUserActive = true;
+    this.state.hasEmittedEngagement = false;
+    this.resetIdleTimer();
+  }
+  /**
+   * Stop session tracking and clean up.
+   */
+  stop() {
+    this.removeEventListeners();
+    if (this.timeUpdateInterval) {
+      clearInterval(this.timeUpdateInterval);
+      this.timeUpdateInterval = null;
+    }
+    if (this.state.idleTimeoutId) {
+      clearTimeout(this.state.idleTimeoutId);
+      this.state.idleTimeoutId = null;
+    }
+  }
+  // ============================================
+  // PRIVATE METHODS
+  // ============================================
+  createInitialState() {
+    const now = Date.now();
+    return {
+      currentUrl: typeof window !== "undefined" ? window.location.href : "",
+      currentPath: typeof window !== "undefined" ? window.location.pathname : "/",
+      pageEntryTime: now,
+      lastActiveTime: now,
+      activeTimeMs: 0,
+      isPageVisible: typeof document !== "undefined" ? document.visibilityState === "visible" : true,
+      isUserActive: true,
+      // Assume active on page load
+      idleTimeoutId: null,
+      sessionId: this.getOrCreateSessionId(),
+      hasEmittedEngagement: false
+    };
+  }
+  resetState() {
+    const now = Date.now();
+    this.state.pageEntryTime = now;
+    this.state.lastActiveTime = now;
+    this.state.activeTimeMs = 0;
+    this.state.isUserActive = true;
+    this.resetIdleTimer();
+  }
+  /**
+   * Get existing session ID from storage or create a new one.
+   * Session ID is reset if:
+   * - No existing session ID in storage
+   * - Last activity was more than 30 minutes ago
+   */
+  getOrCreateSessionId() {
+    if (typeof sessionStorage === "undefined") {
+      return this.generateSessionId();
+    }
+    try {
+      const existingSessionId = sessionStorage.getItem(SESSION_ID_KEY);
+      const lastActivityStr = sessionStorage.getItem(SESSION_LAST_ACTIVITY_KEY);
+      const lastActivity = lastActivityStr ? Number.parseInt(lastActivityStr, 10) : 0;
+      const now = Date.now();
+      if (existingSessionId && lastActivity && now - lastActivity < SESSION_TIMEOUT) {
+        this.updateSessionActivity();
+        return existingSessionId;
+      }
+      const newSessionId = this.generateSessionId();
+      sessionStorage.setItem(SESSION_ID_KEY, newSessionId);
+      sessionStorage.setItem(SESSION_LAST_ACTIVITY_KEY, now.toString());
+      return newSessionId;
+    } catch {
+      return this.generateSessionId();
+    }
+  }
+  /**
+   * Generate a new session ID (UUID v4).
+   */
+  generateSessionId() {
+    if (typeof crypto !== "undefined" && crypto.randomUUID) {
+      return crypto.randomUUID();
+    }
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+  /**
+   * Update the session's last activity timestamp.
+   */
+  updateSessionActivity() {
+    if (typeof sessionStorage === "undefined") return;
+    try {
+      sessionStorage.setItem(SESSION_LAST_ACTIVITY_KEY, Date.now().toString());
+    } catch {
+    }
+  }
+  /**
+   * Check if the current session has expired and create a new one if needed.
+   * Called when user returns to the page after being away.
+   */
+  checkSessionExpiry() {
+    if (typeof sessionStorage === "undefined") return;
+    try {
+      const lastActivityStr = sessionStorage.getItem(SESSION_LAST_ACTIVITY_KEY);
+      const lastActivity = lastActivityStr ? Number.parseInt(lastActivityStr, 10) : 0;
+      const now = Date.now();
+      if (now - lastActivity >= SESSION_TIMEOUT) {
+        const newSessionId = this.generateSessionId();
+        sessionStorage.setItem(SESSION_ID_KEY, newSessionId);
+        this.state.sessionId = newSessionId;
+      }
+      sessionStorage.setItem(SESSION_LAST_ACTIVITY_KEY, now.toString());
+    } catch {
+    }
+  }
+  setupEventListeners() {
+    if (typeof window === "undefined" || typeof document === "undefined") return;
+    const activityEvents = ["mousemove", "keydown", "click", "scroll", "touchstart"];
+    for (const event of activityEvents) {
+      document.addEventListener(event, this.boundHandleActivity, { passive: true });
+    }
+    document.addEventListener("visibilitychange", this.boundHandleVisibilityChange);
+    this.resetIdleTimer();
+  }
+  removeEventListeners() {
+    if (typeof window === "undefined" || typeof document === "undefined") return;
+    const activityEvents = ["mousemove", "keydown", "click", "scroll", "touchstart"];
+    for (const event of activityEvents) {
+      document.removeEventListener(event, this.boundHandleActivity);
+    }
+    document.removeEventListener("visibilitychange", this.boundHandleVisibilityChange);
+  }
+  /**
+   * Handle user activity events.
+   * Marks user as active and resets idle timer.
+   */
+  handleActivity() {
+    if (!this.state.isUserActive) {
+      this.checkSessionExpiry();
+      this.state.lastActiveTime = Date.now();
+    }
+    this.state.isUserActive = true;
+    this.resetIdleTimer();
+    this.updateSessionActivity();
+  }
+  /**
+   * Handle visibility change events.
+   * Pauses time accumulation when tab is hidden.
+   */
+  handleVisibilityChange() {
+    const wasVisible = this.state.isPageVisible;
+    const isNowVisible = document.visibilityState === "visible";
+    if (wasVisible && !isNowVisible) {
+      this.updateActiveTime();
+    }
+    this.state.isPageVisible = isNowVisible;
+    if (!wasVisible && isNowVisible) {
+      this.checkSessionExpiry();
+      this.state.lastActiveTime = Date.now();
+      this.state.hasEmittedEngagement = false;
+      this.updateSessionActivity();
+    }
+  }
+  /**
+   * Reset the idle timer.
+   * Called on activity and initialization.
+   */
+  resetIdleTimer() {
+    if (this.state.idleTimeoutId) {
+      clearTimeout(this.state.idleTimeoutId);
+    }
+    this.state.idleTimeoutId = setTimeout(() => {
+      this.updateActiveTime();
+      this.state.isUserActive = false;
+    }, this.idleTimeout);
+  }
+  /**
+   * Start the interval for updating active time.
+   */
+  startTimeUpdateInterval() {
+    if (this.timeUpdateInterval) return;
+    this.timeUpdateInterval = setInterval(() => {
+      this.updateActiveTime();
+    }, TIME_UPDATE_INTERVAL);
+  }
+  /**
+   * Update accumulated active time.
+   * Only accumulates when page is visible AND user is active.
+   */
+  updateActiveTime() {
+    if (this.state.isPageVisible && this.state.isUserActive) {
+      const now = Date.now();
+      this.state.activeTimeMs += now - this.state.lastActiveTime;
+      this.state.lastActiveTime = now;
+    }
+  }
+  /**
+   * Extract path from URL.
+   */
+  extractPath(url) {
+    try {
+      return new URL(url).pathname;
+    } catch {
+      return "/";
+    }
+  }
+};
+var sessionTrackerInstance = null;
+function initSessionTracking(options) {
+  if (sessionTrackerInstance) {
+    console.warn("[Outlit] Session tracking already initialized");
+    return sessionTrackerInstance;
+  }
+  sessionTrackerInstance = new SessionTracker(options);
+  return sessionTrackerInstance;
+}
+function stopSessionTracking() {
+  if (sessionTrackerInstance) {
+    sessionTrackerInstance.stop();
+    sessionTrackerInstance = null;
+  }
+}
+
+// src/storage.ts
+var VISITOR_ID_KEY = "outlit_visitor_id";
+function generateVisitorId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function getOrCreateVisitorId() {
+  try {
+    const stored = localStorage.getItem(VISITOR_ID_KEY);
+    if (stored && isValidUuid(stored)) {
+      return stored;
+    }
+  } catch {
+  }
+  const cookieValue = getCookie(VISITOR_ID_KEY);
+  if (cookieValue && isValidUuid(cookieValue)) {
+    try {
+      localStorage.setItem(VISITOR_ID_KEY, cookieValue);
+    } catch {
+    }
+    return cookieValue;
+  }
+  const visitorId = generateVisitorId();
+  persistVisitorId(visitorId);
+  return visitorId;
+}
+function persistVisitorId(visitorId) {
+  try {
+    localStorage.setItem(VISITOR_ID_KEY, visitorId);
+  } catch {
+  }
+  setCookie(VISITOR_ID_KEY, visitorId, 365);
+}
+function isValidUuid(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+function getCookie(name) {
+  if (typeof document === "undefined") return null;
+  const value = `; ${document.cookie}`;
+  const parts = value.split(`; ${name}=`);
+  if (parts.length === 2) {
+    return parts.pop()?.split(";").shift() ?? null;
+  }
+  return null;
+}
+function getRootDomain() {
+  if (typeof window === "undefined") return null;
+  const hostname = window.location.hostname;
+  if (hostname === "localhost" || /^(\d{1,3}\.){3}\d{1,3}$/.test(hostname)) {
+    return null;
+  }
+  const parts = hostname.split(".");
+  if (parts.length >= 2) {
+    const twoPartTlds = ["co.uk", "com.au", "co.nz", "org.uk", "net.au", "com.br"];
+    const lastTwo = parts.slice(-2).join(".");
+    if (twoPartTlds.includes(lastTwo) && parts.length >= 3) {
+      return parts.slice(-3).join(".");
+    }
+    return parts.slice(-2).join(".");
+  }
+  return null;
+}
+function setCookie(name, value, days) {
+  if (typeof document === "undefined") return;
+  const expires = /* @__PURE__ */ new Date();
+  expires.setTime(expires.getTime() + days * 24 * 60 * 60 * 1e3);
+  let cookie = `${name}=${value};expires=${expires.toUTCString()};path=/;SameSite=Lax`;
+  const rootDomain = getRootDomain();
+  if (rootDomain) {
+    cookie += `;domain=${rootDomain}`;
+  }
+  document.cookie = cookie;
+}
+
+// src/tracker.ts
+var MAX_PENDING_STAGE_EVENTS = 10;
+var Outlit = class {
+  publicKey;
+  apiHost;
+  visitorId = null;
+  eventQueue = [];
+  flushTimer = null;
+  flushInterval;
+  isInitialized = false;
+  isTrackingEnabled = false;
+  options;
+  hasHandledExit = false;
+  sessionTracker = null;
+  // User identity state for stage events
+  currentUser = null;
+  pendingUser = null;
+  pendingStageEvents = [];
+  constructor(options) {
+    this.publicKey = options.publicKey;
+    this.apiHost = options.apiHost ?? DEFAULT_API_HOST;
+    this.flushInterval = options.flushInterval ?? 5e3;
+    this.options = options;
+    if (typeof window !== "undefined") {
+      const handleExit = () => {
+        if (this.hasHandledExit) return;
+        this.hasHandledExit = true;
+        this.sessionTracker?.emitEngagement();
+        this.flush();
+      };
+      document.addEventListener("visibilitychange", () => {
+        if (document.visibilityState === "hidden") {
+          handleExit();
+        } else {
+          this.hasHandledExit = false;
+        }
+      });
+      window.addEventListener("pagehide", handleExit);
+      window.addEventListener("beforeunload", handleExit);
+    }
+    this.isInitialized = true;
+    if (options.autoTrack !== false) {
+      this.enableTracking();
+    }
+  }
+  // ============================================
+  // PUBLIC API
+  // ============================================
+  /**
+   * Enable tracking. Call this after obtaining user consent.
+   * This will:
+   * - Generate/retrieve the visitor ID
+   * - Start automatic pageview and form tracking (if configured)
+   * - Begin sending events to the server
+   *
+   * If autoTrack is true (default), this is called automatically on init.
+   */
+  enableTracking() {
+    if (this.isTrackingEnabled) {
+      return;
+    }
+    this.visitorId = getOrCreateVisitorId();
+    this.startFlushTimer();
+    this.initSessionTracking();
+    if (this.options.trackPageviews !== false) {
+      this.initPageviewTracking();
+    }
+    if (this.options.trackForms !== false) {
+      this.initFormTracking(this.options.formFieldDenylist);
+    }
+    if (this.options.trackCalendarEmbeds !== false) {
+      this.initCalendarTracking();
+    }
+    this.isTrackingEnabled = true;
+    if (this.pendingUser) {
+      this.applyUser(this.pendingUser);
+      this.pendingUser = null;
+    }
+  }
+  /**
+   * Check if tracking is currently enabled.
+   */
+  isEnabled() {
+    return this.isTrackingEnabled;
+  }
+  /**
+   * Track a custom event.
+   */
+  track(eventName, properties) {
+    if (!this.isTrackingEnabled) {
+      console.warn("[Outlit] Tracking not enabled. Call enableTracking() first.");
+      return;
+    }
+    const event = buildCustomEvent({
+      url: window.location.href,
+      referrer: document.referrer,
+      eventName,
+      properties
+    });
+    this.enqueue(event);
+  }
+  /**
+   * Identify the current visitor.
+   * Links the anonymous visitor to a known user.
+   *
+   * When email or userId is provided, also sets the current user identity
+   * for stage events (activate, engaged, inactive).
+   */
+  identify(options) {
+    if (!this.isTrackingEnabled) {
+      console.warn("[Outlit] Tracking not enabled. Call enableTracking() first.");
+      return;
+    }
+    if (options.email || options.userId) {
+      const hadNoUser = !this.currentUser;
+      this.currentUser = {
+        email: options.email,
+        userId: options.userId
+      };
+      if (hadNoUser) {
+        this.flushPendingStageEvents();
+      }
+    }
+    const event = buildIdentifyEvent({
+      url: window.location.href,
+      referrer: document.referrer,
+      email: options.email,
+      userId: options.userId,
+      traits: options.traits
+    });
+    this.enqueue(event);
+  }
+  /**
+   * Set the current user identity.
+   * This is useful for SPA applications where you know the user's identity
+   * after authentication. Calls identify() under the hood.
+   *
+   * If called before tracking is enabled, the identity is stored as pending
+   * and applied automatically when enableTracking() is called.
+   *
+   * Note: Both setUser() and identify() enable stage events. The difference is
+   * setUser() can be called before tracking is enabled (identity is queued),
+   * while identify() requires tracking to be enabled first.
+   */
+  setUser(identity) {
+    if (!identity.email && !identity.userId) {
+      console.warn("[Outlit] setUser requires at least email or userId");
+      return;
+    }
+    if (!this.isTrackingEnabled) {
+      this.pendingUser = identity;
+      return;
+    }
+    this.applyUser(identity);
+  }
+  /**
+   * Clear the current user identity.
+   * Call this when the user logs out.
+   */
+  clearUser() {
+    this.currentUser = null;
+    this.pendingUser = null;
+    this.pendingStageEvents = [];
+  }
+  /**
+   * Apply user identity and send identify event.
+   */
+  applyUser(identity) {
+    this.currentUser = identity;
+    this.identify({ email: identity.email, userId: identity.userId, traits: identity.traits });
+    this.flushPendingStageEvents();
+  }
+  /**
+   * Flush any pending stage events that were queued before user identity was set.
+   */
+  flushPendingStageEvents() {
+    if (this.pendingStageEvents.length === 0) return;
+    const events = [...this.pendingStageEvents];
+    this.pendingStageEvents = [];
+    for (const { stage, properties } of events) {
+      const event = buildStageEvent({
+        url: window.location.href,
+        referrer: document.referrer,
+        stage,
+        properties
+      });
+      this.enqueue(event);
+    }
+  }
+  /**
+   * User namespace methods for contact journey stages.
+   */
+  user = {
+    identify: (options) => this.identify(options),
+    activate: (properties) => this.sendStageEvent("activated", properties),
+    engaged: (properties) => this.sendStageEvent("engaged", properties),
+    inactive: (properties) => this.sendStageEvent("inactive", properties)
+  };
+  /**
+   * Customer namespace methods for billing status.
+   */
+  customer = {
+    trialing: (options) => this.sendBillingEvent("trialing", options),
+    paid: (options) => this.sendBillingEvent("paid", options),
+    churned: (options) => this.sendBillingEvent("churned", options)
+  };
+  /**
+   * Internal method to send a stage event.
+   */
+  sendStageEvent(stage, properties) {
+    if (!this.isTrackingEnabled) {
+      console.warn("[Outlit] Tracking not enabled. Call enableTracking() first.");
+      return;
+    }
+    if (!this.currentUser) {
+      if (this.pendingStageEvents.length >= MAX_PENDING_STAGE_EVENTS) {
+        console.warn(
+          `[Outlit] Pending stage event queue full (${MAX_PENDING_STAGE_EVENTS}). Call setUser() or identify() to flush queued events.`
+        );
+        return;
+      }
+      this.pendingStageEvents.push({ stage, properties });
+      return;
+    }
+    const event = buildStageEvent({
+      url: window.location.href,
+      referrer: document.referrer,
+      stage,
+      properties
+    });
+    this.enqueue(event);
+  }
+  sendBillingEvent(status, options) {
+    if (!this.isTrackingEnabled) {
+      console.warn("[Outlit] Tracking not enabled. Call enableTracking() first.");
+      return;
+    }
+    const event = buildBillingEvent({
+      url: window.location.href,
+      referrer: document.referrer,
+      status,
+      customerId: options.customerId,
+      stripeCustomerId: options.stripeCustomerId,
+      domain: options.domain,
+      properties: options.properties
+    });
+    this.enqueue(event);
+  }
+  /**
+   * Get the current visitor ID.
+   * Returns null if tracking is not enabled.
+   */
+  getVisitorId() {
+    return this.visitorId;
+  }
+  /**
+   * Manually flush the event queue.
+   */
+  async flush() {
+    if (this.eventQueue.length === 0) return;
+    const events = [...this.eventQueue];
+    this.eventQueue = [];
+    await this.sendEvents(events);
+  }
+  /**
+   * Shutdown the client.
+   */
+  async shutdown() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    stopAutocapture();
+    stopCalendarTracking();
+    stopSessionTracking();
+    this.sessionTracker = null;
+    await this.flush();
+  }
+  // ============================================
+  // INTERNAL METHODS
+  // ============================================
+  initSessionTracking() {
+    this.sessionTracker = initSessionTracking({
+      // Only emit engagement events when trackEngagement is enabled (default: true)
+      onEngagement: this.options.trackEngagement !== false ? (event) => this.enqueue(event) : () => {
+      },
+      idleTimeout: this.options.idleTimeout
+    });
+  }
+  initPageviewTracking() {
+    initPageviewTracking((url, referrer, title) => {
+      this.sessionTracker?.onNavigation(url);
+      const event = buildPageviewEvent({ url, referrer, title });
+      this.enqueue(event);
+    });
+  }
+  initFormTracking(denylist) {
+    const identityCallback2 = this.options.autoIdentify !== false ? (identity) => {
+      const traits = {};
+      if (identity.name) traits.name = identity.name;
+      if (identity.firstName) traits.firstName = identity.firstName;
+      if (identity.lastName) traits.lastName = identity.lastName;
+      this.identify({
+        email: identity.email,
+        traits: Object.keys(traits).length > 0 ? traits : void 0
+      });
+    } : void 0;
+    initFormTracking(
+      (url, formId, fields) => {
+        const event = buildFormEvent({
+          url,
+          referrer: document.referrer,
+          formId,
+          formFields: fields
+        });
+        this.enqueue(event);
+      },
+      denylist,
+      identityCallback2
+    );
+  }
+  initCalendarTracking() {
+    initCalendarTracking({
+      onCalendarBooked: (bookingEvent) => {
+        const event = buildCalendarEvent({
+          url: window.location.href,
+          referrer: document.referrer,
+          provider: bookingEvent.provider,
+          eventType: bookingEvent.eventType,
+          startTime: bookingEvent.startTime,
+          endTime: bookingEvent.endTime,
+          duration: bookingEvent.duration,
+          isRecurring: bookingEvent.isRecurring,
+          inviteeEmail: bookingEvent.inviteeEmail,
+          inviteeName: bookingEvent.inviteeName
+        });
+        this.enqueue(event);
+      }
+    });
+  }
+  enqueue(event) {
+    this.eventQueue.push(event);
+    if (this.eventQueue.length >= 10) {
+      this.flush();
+    }
+  }
+  startFlushTimer() {
+    if (this.flushTimer) return;
+    this.flushTimer = setInterval(() => {
+      this.flush();
+    }, this.flushInterval);
+  }
+  async sendEvents(events) {
+    if (events.length === 0) return;
+    if (!this.visitorId) return;
+    const userIdentity = this.currentUser ?? void 0;
+    const sessionId = this.sessionTracker?.getSessionId();
+    const payload = buildIngestPayload(this.visitorId, "client", events, userIdentity, sessionId);
+    const url = `${this.apiHost}/api/i/v1/${this.publicKey}/events`;
+    try {
+      if (typeof navigator !== "undefined" && navigator.sendBeacon) {
+        const blob = new Blob([JSON.stringify(payload)], { type: "application/json" });
+        const sent = navigator.sendBeacon(url, blob);
+        if (sent) return;
+        console.warn(
+          `[Outlit] sendBeacon failed for ${events.length} events, falling back to fetch`
+        );
+      }
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload),
+        keepalive: true
+      });
+      if (!response.ok) {
+        console.warn(
+          `[Outlit] Server returned ${response.status} when sending ${events.length} events`
+        );
+      }
+    } catch (error) {
+      console.warn(`[Outlit] Failed to send ${events.length} events:`, error);
+    }
+  }
+};
+
+// src/vue/plugin.ts
+var OutlitKey = /* @__PURE__ */ Symbol("outlit");
+var OutlitPlugin = {
+  install(app, options) {
+    const outlitRef = shallowRef(null);
+    const isInitialized = ref(false);
+    const isTrackingEnabled = ref(false);
+    const currentUser = ref(null);
+    const {
+      trackPageviews = true,
+      trackForms = true,
+      autoTrack = true,
+      autoIdentify = true,
+      ...rest
+    } = options;
+    outlitRef.value = new Outlit({
+      ...rest,
+      trackPageviews,
+      trackForms,
+      autoTrack,
+      autoIdentify
+    });
+    isInitialized.value = true;
+    isTrackingEnabled.value = outlitRef.value.isEnabled();
+    const enableTracking = () => {
+      if (outlitRef.value) {
+        outlitRef.value.enableTracking();
+        isTrackingEnabled.value = true;
+      }
+    };
+    const setUser = (user) => {
+      currentUser.value = user;
+    };
+    watch(
+      currentUser,
+      (user) => {
+        if (!outlitRef.value) return;
+        if (user && (user.email || user.userId)) {
+          outlitRef.value.setUser(user);
+        } else {
+          outlitRef.value.clearUser();
+        }
+      },
+      { immediate: true }
+    );
+    app.provide(OutlitKey, {
+      outlit: outlitRef,
+      isInitialized: readonly(isInitialized),
+      isTrackingEnabled: readonly(isTrackingEnabled),
+      enableTracking,
+      setUser
+    });
+    app.config.globalProperties.$outlit = outlitRef.value;
+  }
+};
+
+// src/vue/composables.ts
+import { inject, watch as watch2 } from "vue";
+function useOutlit() {
+  const instance = inject(OutlitKey);
+  if (!instance) {
+    throw new Error("[Outlit] Not initialized. Make sure to install OutlitPlugin in your Vue app.");
+  }
+  const { outlit, isInitialized, isTrackingEnabled, enableTracking } = instance;
+  const track = (eventName, properties) => {
+    if (!outlit.value) {
+      console.warn("[Outlit] Not initialized.");
+      return;
+    }
+    outlit.value.track(eventName, properties);
+  };
+  const identify = (options) => {
+    if (!outlit.value) {
+      console.warn("[Outlit] Not initialized.");
+      return;
+    }
+    outlit.value.identify(options);
+  };
+  const getVisitorId = () => {
+    if (!outlit.value) return null;
+    return outlit.value.getVisitorId();
+  };
+  const setUser = (identity) => {
+    if (!outlit.value) {
+      console.warn("[Outlit] Not initialized.");
+      return;
+    }
+    outlit.value.setUser(identity);
+  };
+  const clearUser = () => {
+    if (!outlit.value) {
+      console.warn("[Outlit] Not initialized.");
+      return;
+    }
+    outlit.value.clearUser();
+  };
+  return {
+    track,
+    identify,
+    getVisitorId,
+    setUser,
+    clearUser,
+    user: {
+      identify: (options) => outlit.value?.user.identify(options),
+      activate: (properties) => outlit.value?.user.activate(properties),
+      engaged: (properties) => outlit.value?.user.engaged(properties),
+      inactive: (properties) => outlit.value?.user.inactive(properties)
+    },
+    customer: {
+      trialing: (options) => outlit.value?.customer.trialing(options),
+      paid: (options) => outlit.value?.customer.paid(options),
+      churned: (options) => outlit.value?.customer.churned(options)
+    },
+    isInitialized,
+    isTrackingEnabled,
+    enableTracking
+  };
+}
+function useTrack() {
+  const { track } = useOutlit();
+  return track;
+}
+function useIdentify() {
+  const { identify } = useOutlit();
+  return identify;
+}
+function useOutlitUser(userRef) {
+  const instance = inject(OutlitKey);
+  if (!instance) {
+    throw new Error("[Outlit] Not initialized. Make sure to install OutlitPlugin in your Vue app.");
+  }
+  const { outlit } = instance;
+  watch2(
+    userRef,
+    (user) => {
+      if (!outlit.value) return;
+      if (user && (user.email || user.userId)) {
+        outlit.value.setUser(user);
+      } else {
+        outlit.value.clearUser();
+      }
+    },
+    { immediate: true, deep: true }
+  );
+}
+export {
+  OutlitKey,
+  OutlitPlugin,
+  useIdentify,
+  useOutlit,
+  useOutlitUser,
+  useTrack
+};
+//# sourceMappingURL=index.mjs.map