@appfunnel-dev/sdk 0.5.0 → 0.6.0

package/dist/chunk-BUF5FDKC.cjs

@@ -0,0 +1,1303 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/runtime/integrations.ts
+var AppFunnelEventBus = class {
+  constructor(store, router, selectProduct) {
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.store = store;
+    this.router = router;
+    this.selectProduct = selectProduct;
+  }
+  /** Attach the event bus to window.appfunnel */
+  attach() {
+    if (typeof window === "undefined") return;
+    const self = this;
+    window.appfunnel = {
+      // Event subscriptions
+      on(eventType, callback) {
+        return self.on(eventType, callback);
+      },
+      off(eventType, callback) {
+        self.off(eventType, callback);
+      },
+      // Internal — called by FunnelTracker.emitToRuntime()
+      _emitEvent(eventType, data) {
+        self.emit(eventType, data);
+      },
+      // Getters for integration loaders that need them
+      getVariable(variableId) {
+        return self.store.get(variableId);
+      },
+      getVariables() {
+        return { ...self.store.getState() };
+      },
+      getCurrentPageId() {
+        return self.router.getCurrentPage()?.key ?? null;
+      },
+      getCustomerId() {
+        return self.store.get("user.stripeCustomerId") || null;
+      },
+      isPaymentAuthorized() {
+        return !!self.store.get("user.stripeCustomerId");
+      },
+      // Methods
+      setVariable(variableId, value) {
+        self.store.set(variableId, value);
+      },
+      selectProduct(productId) {
+        self.selectProduct(productId);
+      },
+      goToNextPage() {
+        self.router.goToNextPage(self.store.getState());
+      },
+      goBack() {
+        self.router.goBack();
+      },
+      openUrl(url) {
+        if (url) window.open(url, "_blank", "noopener,noreferrer");
+      },
+      callEvent(eventName, data) {
+        self.emit(eventName, data);
+      },
+      // Debug
+      debug: false,
+      setDebug(_enabled) {
+      }
+    };
+  }
+  /** Emit an event to all subscribers */
+  emit(eventType, data) {
+    const subs = this.subscriptions.get(eventType);
+    if (!subs || subs.length === 0) return;
+    for (const sub of subs) {
+      try {
+        sub.callback(data);
+      } catch (error) {
+        console.error(`[AppFunnel] Error in event handler for "${eventType}":`, error);
+      }
+    }
+  }
+  /** Clean up page-scoped subscriptions (called on page change) */
+  onPageChange() {
+    for (const [eventType, subs] of this.subscriptions.entries()) {
+      this.subscriptions.set(eventType, subs.filter((s) => s.scope === "global"));
+    }
+  }
+  /** Destroy and detach from window */
+  destroy() {
+    this.subscriptions.clear();
+    if (typeof window !== "undefined") {
+      delete window.appfunnel;
+    }
+  }
+  on(eventType, callback) {
+    if (!this.subscriptions.has(eventType)) {
+      this.subscriptions.set(eventType, []);
+    }
+    const sub = { callback, scope: "global" };
+    this.subscriptions.get(eventType).push(sub);
+    return () => this.off(eventType, callback);
+  }
+  off(eventType, callback) {
+    const subs = this.subscriptions.get(eventType);
+    if (!subs) return;
+    const index = subs.findIndex((s) => s.callback === callback);
+    if (index > -1) subs.splice(index, 1);
+  }
+};
+var loaders = {};
+function registerIntegration(id, loader) {
+  loaders[id] = loader;
+}
+function initializeIntegrations(integrations) {
+  if (typeof window === "undefined") return;
+  window.__INTEGRATIONS__ = integrations;
+  for (const [integrationId, config] of Object.entries(integrations)) {
+    const loader = loaders[integrationId];
+    if (loader) {
+      try {
+        loader(config);
+      } catch (err) {
+        console.error(`[AppFunnel] Error loading integration ${integrationId}:`, err);
+      }
+    }
+  }
+}
+
+// src/runtime/variableStore.ts
+var VariableStore = class {
+  constructor(initial) {
+    this.listeners = /* @__PURE__ */ new Set();
+    /** Tracks which keys changed in the last mutation — used by scoped notify */
+    this.changedKeys = [];
+    this.state = { ...initial };
+  }
+  getState() {
+    return this.state;
+  }
+  get(key) {
+    return this.state[key];
+  }
+  set(key, value) {
+    if (this.state[key] === value) return;
+    this.state = { ...this.state, [key]: value };
+    this.changedKeys = [key];
+    this.notify();
+  }
+  setState(updater) {
+    const prev = this.state;
+    const next = updater(prev);
+    if (next === prev) return;
+    this.state = next;
+    this.changedKeys = [];
+    for (const key of Object.keys(next)) {
+      if (next[key] !== prev[key]) this.changedKeys.push(key);
+    }
+    for (const key of Object.keys(prev)) {
+      if (!(key in next) && prev[key] !== void 0) this.changedKeys.push(key);
+    }
+    this.notify();
+  }
+  /** Batch set multiple variables at once */
+  setMany(updates) {
+    const changed = [];
+    const next = { ...this.state };
+    for (const [key, value] of Object.entries(updates)) {
+      if (next[key] !== value) {
+        next[key] = value;
+        changed.push(key);
+      }
+    }
+    if (changed.length === 0) return;
+    this.state = next;
+    this.changedKeys = changed;
+    this.notify();
+  }
+  /**
+   * Subscribe to store changes.
+   *
+   * @param listener - callback fired when relevant keys change
+   * @param scope - optional scope to limit notifications:
+   *   - `{ keys: ['data.x', 'user.email'] }` — only fire when these exact keys change
+   *   - `{ prefix: 'answers.' }` — only fire when any key starting with this prefix changes
+   *   - omit or `{}` — fire on every change (global listener)
+   */
+  subscribe(listener, scope) {
+    const entry = {
+      listener,
+      keys: scope?.keys || null,
+      prefix: scope?.prefix || null
+    };
+    this.listeners.add(entry);
+    return () => this.listeners.delete(entry);
+  }
+  notify() {
+    const changed = this.changedKeys;
+    for (const entry of this.listeners) {
+      if (!entry.keys && !entry.prefix) {
+        entry.listener();
+        continue;
+      }
+      if (entry.keys) {
+        if (changed.some((k) => entry.keys.includes(k))) {
+          entry.listener();
+        }
+        continue;
+      }
+      if (entry.prefix) {
+        if (changed.some((k) => k.startsWith(entry.prefix))) {
+          entry.listener();
+        }
+      }
+    }
+  }
+};
+var BUILTIN_USER_VARIABLES = {
+  "user.email": "",
+  "user.name": "",
+  "user.stripeCustomerId": "",
+  "user.paddleCustomerId": ""
+};
+var BUILTIN_QUERY_VARIABLES = {
+  "query.utm_source": "",
+  "query.utm_medium": "",
+  "query.utm_campaign": "",
+  "query.utm_content": "",
+  "query.utm_term": ""
+};
+function collectQueryVariables() {
+  if (typeof window === "undefined") return {};
+  const params = new URLSearchParams(window.location.search);
+  const result = {};
+  params.forEach((value, key) => {
+    result[`query.${key}`] = value;
+  });
+  return result;
+}
+function createVariableStore(config, sessionValues) {
+  const initial = {};
+  Object.assign(initial, BUILTIN_USER_VARIABLES);
+  Object.assign(initial, BUILTIN_QUERY_VARIABLES);
+  Object.assign(initial, collectQueryVariables());
+  if (config.responses) {
+    for (const [key, cfg] of Object.entries(config.responses)) {
+      initial[`answers.${key}`] = cfg.default ?? getDefaultForType(cfg.type);
+    }
+  }
+  if (config.queryParams) {
+    for (const [key, cfg] of Object.entries(config.queryParams)) {
+      if (initial[`query.${key}`] === void 0) {
+        initial[`query.${key}`] = cfg.default ?? getDefaultForType(cfg.type);
+      }
+    }
+  }
+  if (config.data) {
+    for (const [key, cfg] of Object.entries(config.data)) {
+      initial[`data.${key}`] = cfg.default ?? getDefaultForType(cfg.type);
+    }
+  }
+  if (sessionValues) {
+    for (const [key, value] of Object.entries(sessionValues)) {
+      if (value !== void 0) {
+        initial[key] = value;
+      }
+    }
+  }
+  return new VariableStore(initial);
+}
+function getDefaultForType(type) {
+  switch (type) {
+    case "string":
+      return "";
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "stringArray":
+      return [];
+    default:
+      return "";
+  }
+}
+
+// src/runtime/conditions.ts
+function isConditionGroup(condition) {
+  return "operator" in condition && "rules" in condition;
+}
+function evaluateCondition(condition, variables) {
+  if (isConditionGroup(condition)) {
+    return evaluateConditionGroup(condition, variables);
+  }
+  return evaluateSimpleCondition(condition, variables);
+}
+function evaluateConditionGroup(group, variables) {
+  const { operator, rules } = group;
+  if (!rules || rules.length === 0) return true;
+  const results = rules.map((rule) => evaluateCondition(rule, variables));
+  if (operator === "AND") {
+    return results.every(Boolean);
+  }
+  return results.some(Boolean);
+}
+function evaluateSimpleCondition(condition, variables) {
+  const variableValue = variables[condition.variable];
+  if (condition.equals !== void 0) {
+    if (Array.isArray(variableValue)) {
+      return variableValue.length === Number(condition.equals);
+    }
+    return variableValue == condition.equals;
+  }
+  if (condition.notEquals !== void 0) {
+    if (Array.isArray(variableValue)) {
+      return variableValue.length !== Number(condition.notEquals);
+    }
+    return variableValue != condition.notEquals;
+  }
+  if (condition.contains !== void 0) {
+    if (typeof variableValue !== "string") return false;
+    return variableValue.includes(condition.contains);
+  }
+  if (condition.greaterThan !== void 0) {
+    if (Array.isArray(variableValue)) {
+      return variableValue.length > condition.greaterThan;
+    }
+    return Number(variableValue) > condition.greaterThan;
+  }
+  if (condition.lessThan !== void 0) {
+    if (Array.isArray(variableValue)) {
+      return variableValue.length < condition.lessThan;
+    }
+    return Number(variableValue) < condition.lessThan;
+  }
+  if (condition.exists !== void 0) {
+    const exists = variableValue !== void 0 && variableValue !== null && variableValue !== "";
+    return condition.exists ? exists : !exists;
+  }
+  if (condition.isEmpty !== void 0) {
+    let empty;
+    if (Array.isArray(variableValue)) {
+      empty = variableValue.length === 0;
+    } else if (typeof variableValue === "string") {
+      empty = variableValue.trim() === "";
+    } else {
+      empty = !variableValue;
+    }
+    return condition.isEmpty ? empty : !empty;
+  }
+  if (condition.includes !== void 0) {
+    if (!Array.isArray(variableValue)) return false;
+    return variableValue.includes(condition.includes);
+  }
+  return true;
+}
+
+// src/runtime/router.ts
+var Router = class {
+  constructor(options) {
+    this.history = [];
+    this.listeners = /* @__PURE__ */ new Set();
+    const { config, initialPage, basePath, campaignSlug } = options;
+    this.config = config;
+    this.pageKeys = Object.keys(config.pages ?? {});
+    this.basePath = basePath || "";
+    const defaultInitial = config.initialPageKey || this.pageKeys[0] || "";
+    const isDev = typeof globalThis !== "undefined" && globalThis.__APPFUNNEL_DEV__;
+    if (initialPage && initialPage !== defaultInitial) {
+      if (isDev || !campaignSlug) {
+        this.initialKey = config.pages?.[initialPage] ? initialPage : defaultInitial;
+      } else {
+        const hasSession = this.hasSessionCookie(campaignSlug);
+        this.initialKey = hasSession && config.pages?.[initialPage] ? initialPage : defaultInitial;
+      }
+    } else {
+      this.initialKey = initialPage || defaultInitial;
+    }
+    this.currentKey = this.initialKey;
+  }
+  // ── Session check ──────────────────────────────────
+  hasSessionCookie(campaignSlug) {
+    if (!campaignSlug || typeof document === "undefined") return false;
+    const name = `fs_${campaignSlug}=`;
+    return document.cookie.split(";").some((c) => c.trim().startsWith(name));
+  }
+  // ── Subscriptions ────────────────────────────────────
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notify() {
+    for (const listener of this.listeners) listener();
+  }
+  /** Snapshot key for useSyncExternalStore — changes on every navigation. */
+  getSnapshot() {
+    return this.currentKey;
+  }
+  // ── Reads ────────────────────────────────────────────
+  getCurrentPage() {
+    if (!this.currentKey) return null;
+    const pageConfig = this.config.pages?.[this.currentKey];
+    if (!pageConfig) return null;
+    return {
+      key: this.currentKey,
+      name: pageConfig.name,
+      type: pageConfig.type,
+      slug: pageConfig.slug || this.currentKey,
+      index: this.pageKeys.indexOf(this.currentKey)
+    };
+  }
+  /** Build the full URL path for a page key. */
+  getPageUrl(pageKey) {
+    const pageConfig = this.config.pages?.[pageKey];
+    const slug = pageConfig?.slug || pageKey;
+    return this.basePath ? `${this.basePath}/${slug}` : `/${slug}`;
+  }
+  /** Resolve a page key from a URL slug. */
+  resolveSlug(slug) {
+    const pages = this.config.pages ?? {};
+    if (pages[slug]) return slug;
+    for (const [key, config] of Object.entries(pages)) {
+      if (config.slug === slug) return key;
+    }
+    return null;
+  }
+  getPageHistory() {
+    return [...this.history];
+  }
+  getProgress() {
+    const total = this.calculateExpectedPathLength();
+    const current = this.history.length + 1;
+    return {
+      current,
+      total,
+      percentage: total > 0 ? Math.min(100, Math.round(current / total * 100)) : 0
+    };
+  }
+  // ── Navigation ───────────────────────────────────────
+  /**
+   * Evaluate routes for the current page and navigate to the first matching target.
+   * Returns the new page key, or null if no route matched.
+   */
+  goToNextPage(variables) {
+    const routes = this.config.routes?.[this.currentKey];
+    if (!routes || routes.length === 0) return null;
+    for (const route of routes) {
+      if (!route.when || evaluateCondition(route.when, variables)) {
+        return this.navigateTo(route.to);
+      }
+    }
+    return null;
+  }
+  /** Navigate to a specific page by key. */
+  goToPage(pageKey) {
+    if (!this.config.pages?.[pageKey]) return null;
+    return this.navigateTo(pageKey);
+  }
+  /** Go back to the previous page in history. */
+  goBack() {
+    const previousKey = this.history.pop();
+    if (!previousKey) return null;
+    this.currentKey = previousKey;
+    this.notify();
+    return previousKey;
+  }
+  /** Set the current page directly (used for deep-link/reload restore). */
+  setCurrentPage(pageKey) {
+    if (this.config.pages?.[pageKey] && this.currentKey !== pageKey) {
+      this.currentKey = pageKey;
+      this.notify();
+    }
+  }
+  navigateTo(pageKey) {
+    this.history.push(this.currentKey);
+    this.currentKey = pageKey;
+    this.notify();
+    return pageKey;
+  }
+  calculateExpectedPathLength() {
+    const visited = /* @__PURE__ */ new Set();
+    let current = this.initialKey || null;
+    let length = 0;
+    while (current && !visited.has(current)) {
+      visited.add(current);
+      length++;
+      const routes = this.config.routes?.[current];
+      if (!routes || routes.length === 0) break;
+      const fallback = routes[routes.length - 1];
+      current = fallback?.to ?? null;
+    }
+    return length;
+  }
+};
+
+// src/runtime/tracker.ts
+function getCookieValue(name) {
+  if (typeof document === "undefined") return null;
+  const match = document.cookie.match(
+    new RegExp("(?:^|; )" + name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "=([^;]*)")
+  );
+  return match ? decodeURIComponent(match[1]) : null;
+}
+function collectAdAttribution() {
+  if (typeof window === "undefined") return {};
+  const attribution = {};
+  const params = new URLSearchParams(window.location.search);
+  const fbp = getCookieValue("_fbp");
+  if (fbp) attribution.fbp = fbp;
+  const fbc = getCookieValue("_fbc");
+  const fbclid = params.get("fbclid");
+  if (fbc) {
+    attribution.fbc = fbc;
+  } else if (fbclid) {
+    attribution.fbc = `fb.1.${Date.now()}.${fbclid}`;
+  }
+  const ttp = getCookieValue("_ttp");
+  if (ttp) attribution.ttp = ttp;
+  const ttclid = params.get("ttclid");
+  if (ttclid) attribution.ttclid = ttclid;
+  for (const key of ["gclid", "wbraid", "gbraid"]) {
+    const val = params.get(key);
+    if (val) attribution[key] = val;
+  }
+  return attribution;
+}
+function generateEventId() {
+  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 collectMetadata() {
+  if (typeof window === "undefined") return {};
+  const screen = `${window.screen.width}x${window.screen.height}`;
+  const language = navigator.language;
+  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const referrer = document.referrer || void 0;
+  const userAgent = navigator.userAgent.toLowerCase();
+  let device = "desktop";
+  if (/mobile|android|iphone|ipod|blackberry|windows phone/.test(userAgent)) {
+    device = "mobile";
+  } else if (/tablet|ipad/.test(userAgent)) {
+    device = "tablet";
+  }
+  let browser = "unknown";
+  if (userAgent.includes("firefox")) browser = "Firefox";
+  else if (userAgent.includes("safari") && !userAgent.includes("chrome")) browser = "Safari";
+  else if (userAgent.includes("chrome")) browser = "Chrome";
+  else if (userAgent.includes("edge")) browser = "Edge";
+  let os = "unknown";
+  if (userAgent.includes("win")) os = "Windows";
+  else if (userAgent.includes("mac")) os = "macOS";
+  else if (userAgent.includes("linux")) os = "Linux";
+  else if (userAgent.includes("android")) os = "Android";
+  else if (/ios|iphone|ipad/.test(userAgent)) os = "iOS";
+  return { device, browser, os, screen, language, timezone, referrer };
+}
+var COOKIE_MAX_AGE_DAYS = 30;
+function getSessionCookie(campaignSlug) {
+  if (typeof document === "undefined") return null;
+  const name = `fs_${campaignSlug}=`;
+  const cookies = document.cookie.split(";");
+  for (const cookie of cookies) {
+    const trimmed = cookie.trim();
+    if (trimmed.startsWith(name)) {
+      return trimmed.substring(name.length);
+    }
+  }
+  return null;
+}
+function setSessionCookie(campaignSlug, sessionId) {
+  if (typeof document === "undefined") return;
+  const maxAge = COOKIE_MAX_AGE_DAYS * 24 * 60 * 60;
+  document.cookie = `fs_${campaignSlug}=${sessionId}; path=/; max-age=${maxAge}; SameSite=Lax`;
+}
+var SAVABLE_PREFIXES = ["query.", "data.", "answers.", "user."];
+function filterSavable(variables) {
+  const result = {};
+  for (const key of Object.keys(variables)) {
+    if (SAVABLE_PREFIXES.some((p) => key.startsWith(p))) {
+      result[key] = variables[key];
+    }
+  }
+  return result;
+}
+var VariablePersistence = class {
+  constructor(save, DEBOUNCE_MS = 2e3, MAX_DELAY_MS = 5e3) {
+    this.save = save;
+    this.DEBOUNCE_MS = DEBOUNCE_MS;
+    this.MAX_DELAY_MS = MAX_DELAY_MS;
+    this.variables = null;
+    this.debounceTimer = null;
+    this.maxDelayTimer = null;
+  }
+  update(variables, canSave = true) {
+    this.variables = variables;
+    if (canSave) this.scheduleSave();
+  }
+  /** Get the filtered savable variables (for attaching to events). */
+  getSavable() {
+    if (!this.variables) return null;
+    return filterSavable(this.variables);
+  }
+  async flush() {
+    this.clearTimers();
+    if (this.variables) {
+      await this.save(filterSavable(this.variables));
+    }
+  }
+  destroy() {
+    this.clearTimers();
+  }
+  scheduleSave() {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.debounceTimer = setTimeout(() => this.executeSave(), this.DEBOUNCE_MS);
+    if (!this.maxDelayTimer) {
+      this.maxDelayTimer = setTimeout(() => this.executeSave(), this.MAX_DELAY_MS);
+    }
+  }
+  executeSave() {
+    this.clearTimers();
+    if (this.variables) {
+      this.save(filterSavable(this.variables)).catch((error) => {
+        console.error("[AppFunnel] Variable save failed:", error);
+      });
+    }
+  }
+  clearTimers() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.maxDelayTimer) {
+      clearTimeout(this.maxDelayTimer);
+      this.maxDelayTimer = null;
+    }
+  }
+};
+var API_BASE_URL = "https://api.appfunnel.net";
+var FunnelTracker = class {
+  constructor() {
+    this.campaignId = null;
+    this.funnelId = null;
+    this.campaignSlug = null;
+    this.sessionId = null;
+    this.experimentId = null;
+    this.initialized = false;
+    this.customerId = null;
+    this.adAttribution = {};
+    // Page time tracking
+    this.currentPageId = null;
+    this.pageStartTime = null;
+    this.pageActiveTime = 0;
+    this.lastActiveStart = 0;
+    this.isPageVisible = true;
+    this.handleVisibilityChange = () => {
+      if (document.visibilityState === "hidden") {
+        if (this.isPageVisible && this.lastActiveStart > 0) {
+          this.pageActiveTime += Date.now() - this.lastActiveStart;
+        }
+        this.isPageVisible = false;
+      } else {
+        this.isPageVisible = true;
+        this.lastActiveStart = Date.now();
+      }
+    };
+    this.handleBeforeUnload = () => {
+      if (!this.currentPageId || !this.pageStartTime || !this.initialized || !this.campaignId) return;
+      const durationMs = Date.now() - this.pageStartTime;
+      const activeMs = this.calculateActiveTime();
+      const eventId = generateEventId();
+      const payload = JSON.stringify({
+        campaignId: this.campaignId,
+        funnelId: this.funnelId || void 0,
+        eventId,
+        sessionId: this.sessionId || void 0,
+        experimentId: this.experimentId || void 0,
+        event: "page.exit",
+        data: { pageId: this.currentPageId, durationMs, activeMs },
+        userData: this.variablePersistence.getSavable() || void 0,
+        metadata: collectMetadata(),
+        adAttribution: Object.keys(this.adAttribution).length > 0 ? this.adAttribution : void 0
+      });
+      navigator.sendBeacon(`${API_BASE_URL}/campaign/${this.campaignId}/event`, payload);
+    };
+    this.variablePersistence = new VariablePersistence((data) => this.updateUserData(data));
+  }
+  // ── Session management ──────────────────────────────
+  init(campaignId, funnelId, campaignSlug, experimentId) {
+    if (typeof window === "undefined") return;
+    this.campaignId = campaignId;
+    this.funnelId = funnelId;
+    this.campaignSlug = campaignSlug || null;
+    this.experimentId = experimentId || null;
+    this.initialized = true;
+    this.adAttribution = collectAdAttribution();
+    if (campaignSlug) {
+      const cookieSessionId = getSessionCookie(campaignSlug);
+      if (cookieSessionId) {
+        this.sessionId = cookieSessionId;
+        return;
+      }
+    }
+    const storedSessionId = localStorage.getItem(`campaign_session_${campaignId}`);
+    if (storedSessionId) {
+      this.sessionId = storedSessionId;
+    }
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  getCustomerId() {
+    return this.customerId;
+  }
+  setSessionId(sessionId) {
+    this.persistSessionId(sessionId);
+  }
+  persistSessionId(sessionId) {
+    this.sessionId = sessionId;
+    if (this.campaignSlug) {
+      setSessionCookie(this.campaignSlug, sessionId);
+    }
+    if (this.campaignId) {
+      localStorage.setItem(`campaign_session_${this.campaignId}`, sessionId);
+    }
+  }
+  async track(event, data, userData) {
+    const eventId = data?.eventId || generateEventId();
+    if (!this.initialized || !this.campaignId) {
+      console.warn("[AppFunnel] Tracker not initialized. Call init() first.");
+      return eventId;
+    }
+    if (typeof window === "undefined") return eventId;
+    if (globalThis.__APPFUNNEL_DEV__) {
+      console.log(`[AppFunnel] track: ${event}`, data || "");
+      return eventId;
+    }
+    try {
+      const metadata = collectMetadata();
+      const response = await fetch(
+        `${API_BASE_URL}/campaign/${this.campaignId}/event`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            campaignId: this.campaignId,
+            funnelId: this.funnelId || void 0,
+            eventId,
+            sessionId: this.sessionId || void 0,
+            event,
+            data,
+            userData: userData || void 0,
+            metadata,
+            adAttribution: Object.keys(this.adAttribution).length > 0 ? this.adAttribution : void 0,
+            experimentId: this.experimentId || void 0
+          })
+        }
+      );
+      if (!response.ok) {
+        console.error("[AppFunnel] Failed to track event:", response.statusText);
+        return eventId;
+      }
+      const result = await response.json();
+      if (result.success && result.sessionId) {
+        this.persistSessionId(result.sessionId);
+        if (result.customerId && result.customerId !== this.customerId) {
+          this.customerId = result.customerId;
+        }
+      }
+    } catch (error) {
+      console.error("[AppFunnel] Error tracking event:", error);
+    }
+    return eventId;
+  }
+  /** Identify a user by email — fires user.registered event */
+  async identify(email) {
+    await this.track("user.registered", { email });
+  }
+  async updateUserData(userData) {
+    if (!this.sessionId || typeof window === "undefined") return;
+    try {
+      const response = await fetch(
+        `${API_BASE_URL}/campaign/${this.campaignId}/event/session/data`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ sessionId: this.sessionId, userData })
+        }
+      );
+      if (!response.ok) {
+        console.error("[AppFunnel] Failed to update user data:", response.statusText);
+      }
+    } catch (error) {
+      console.error("[AppFunnel] Error updating user data:", error);
+    }
+  }
+  // ── Variable persistence ────────────────────────────
+  setCurrentVariables(variables) {
+    this.variablePersistence.update(variables, !!this.sessionId);
+  }
+  async flushVariables() {
+    if (!this.sessionId) return;
+    await this.variablePersistence.flush();
+  }
+  // ── Page time tracking ──────────────────────────────
+  startPageTracking(pageId) {
+    if (typeof window === "undefined") return;
+    this.stopPageTracking();
+    this.currentPageId = pageId;
+    this.pageStartTime = Date.now();
+    this.pageActiveTime = 0;
+    this.lastActiveStart = Date.now();
+    this.isPageVisible = document.visibilityState === "visible";
+    document.addEventListener("visibilitychange", this.handleVisibilityChange);
+    window.addEventListener("beforeunload", this.handleBeforeUnload);
+  }
+  stopPageTracking() {
+    if (!this.currentPageId || !this.pageStartTime) return;
+    const durationMs = Date.now() - this.pageStartTime;
+    const activeMs = this.calculateActiveTime();
+    this.track(
+      "page.exit",
+      { pageId: this.currentPageId, durationMs, activeMs },
+      this.variablePersistence.getSavable() || void 0
+    );
+    this.cleanupPageTracking();
+  }
+  calculateActiveTime() {
+    let activeTime = this.pageActiveTime;
+    if (this.isPageVisible && this.lastActiveStart > 0) {
+      activeTime += Date.now() - this.lastActiveStart;
+    }
+    return activeTime;
+  }
+  cleanupPageTracking() {
+    if (typeof window === "undefined") return;
+    document.removeEventListener("visibilitychange", this.handleVisibilityChange);
+    window.removeEventListener("beforeunload", this.handleBeforeUnload);
+    this.currentPageId = null;
+    this.pageStartTime = null;
+    this.pageActiveTime = 0;
+    this.lastActiveStart = 0;
+    this.isPageVisible = true;
+  }
+  // ── Lifecycle ───────────────────────────────────────
+  reset() {
+    this.variablePersistence.destroy();
+    if (this.campaignId && typeof window !== "undefined") {
+      localStorage.removeItem(`campaign_session_${this.campaignId}`);
+    }
+    this.sessionId = null;
+    this.customerId = null;
+    this.cleanupPageTracking();
+  }
+};
+
+// src/runtime/products.ts
+function formatPrice(amount, currency) {
+  try {
+    return new Intl.NumberFormat(void 0, {
+      style: "currency",
+      currency: currency.toUpperCase()
+    }).format(amount);
+  } catch {
+    return `${currency.toUpperCase()} ${amount.toFixed(2)}`;
+  }
+}
+function calculatePeriodDays(interval, intervalCount) {
+  const map = { day: 1, week: 7, month: 30, year: 365, one_time: 0 };
+  return (map[interval] || 0) * intervalCount;
+}
+function calculatePeriodMonths(interval, intervalCount) {
+  const map = { day: 1 / 30, week: 1 / 4, month: 1, year: 12, one_time: 0 };
+  return (map[interval] || 0) * intervalCount;
+}
+function calculatePeriodWeeks(interval, intervalCount) {
+  const map = { day: 1 / 7, week: 1, month: 4, year: 52, one_time: 0 };
+  return (map[interval] || 0) * intervalCount;
+}
+function getIntervalLabel(interval, intervalCount) {
+  if (interval === "one_time") return { period: "one-time", periodly: "one-time" };
+  if (interval === "month" && intervalCount === 3) return { period: "quarter", periodly: "quarterly" };
+  if (interval === "month" && intervalCount === 6) return { period: "6 months", periodly: "semiannually" };
+  if (interval === "week" && intervalCount === 2) return { period: "2 weeks", periodly: "biweekly" };
+  if (intervalCount === 1) {
+    const periodlyMap = { day: "daily", week: "weekly", month: "monthly", year: "yearly" };
+    return { period: interval, periodly: periodlyMap[interval] || interval };
+  }
+  return {
+    period: `${intervalCount} ${interval}s`,
+    periodly: `every ${intervalCount} ${interval}s`
+  };
+}
+function buildRuntimeProduct(product, priceData, trialPriceData) {
+  if (!priceData) {
+    const c = "USD";
+    const f2 = (n) => formatPrice(n, c);
+    const fallbackTrialDays = product.trialDays || 0;
+    return {
+      id: product.id,
+      name: product.name,
+      storePriceId: product.storePriceId,
+      price: f2(0),
+      rawPrice: 0,
+      monthlyPrice: f2(0),
+      dailyPrice: f2(0),
+      weeklyPrice: f2(0),
+      yearlyPrice: f2(0),
+      period: "one_time",
+      periodly: "one-time",
+      periodDays: 0,
+      periodMonths: 0,
+      periodWeeks: 0,
+      currencyCode: c,
+      hasTrial: fallbackTrialDays > 0,
+      trialDays: fallbackTrialDays,
+      paidTrial: false,
+      trialRawPrice: 0,
+      trialPrice: f2(0),
+      trialDailyPrice: f2(0),
+      trialCurrencyCode: c,
+      trialStorePriceId: product.trialStorePriceId || "",
+      stripePriceId: "",
+      stripeProductId: "",
+      paddlePriceId: "",
+      paddleProductId: "",
+      displayName: product.name
+    };
+  }
+  const rawPrice = priceData.amount / 100;
+  const currency = priceData.currency.toUpperCase();
+  const f = (n) => formatPrice(n, currency);
+  const interval = priceData.interval || "one_time";
+  const intervalCount = priceData.intervalCount || 1;
+  const periodDays = calculatePeriodDays(interval, intervalCount);
+  const periodMonths = calculatePeriodMonths(interval, intervalCount);
+  const periodWeeks = calculatePeriodWeeks(interval, intervalCount);
+  const dailyPrice = periodDays > 0 ? rawPrice / periodDays : rawPrice;
+  const weeklyPrice = periodWeeks > 0 ? rawPrice / periodWeeks : rawPrice * 7;
+  const monthlyPrice = periodMonths > 0 ? rawPrice / periodMonths : rawPrice * 30;
+  const yearlyPrice = periodMonths > 0 ? rawPrice / periodMonths * 12 : rawPrice * 365;
+  const { period, periodly } = getIntervalLabel(interval, intervalCount);
+  const trialDays = product.trialDays || 0;
+  const hasTrial = trialDays > 0;
+  const trialRawPrice = trialPriceData ? trialPriceData.amount / 100 : 0;
+  const trialCurrency = trialPriceData ? trialPriceData.currency.toUpperCase() : currency;
+  const ft = (n) => formatPrice(n, trialCurrency);
+  const trialDailyPrice = trialDays > 0 ? trialRawPrice / trialDays : 0;
+  return {
+    id: product.id,
+    name: product.name,
+    storePriceId: product.storePriceId,
+    price: f(rawPrice),
+    rawPrice,
+    monthlyPrice: f(monthlyPrice),
+    dailyPrice: f(dailyPrice),
+    weeklyPrice: f(weeklyPrice),
+    yearlyPrice: f(yearlyPrice),
+    period,
+    periodly,
+    periodDays,
+    periodMonths,
+    periodWeeks,
+    currencyCode: currency,
+    hasTrial,
+    trialDays,
+    paidTrial: hasTrial && trialRawPrice > 0,
+    trialRawPrice,
+    trialPrice: ft(trialRawPrice),
+    trialDailyPrice: ft(trialDailyPrice),
+    trialCurrencyCode: trialCurrency,
+    trialStorePriceId: product.trialStorePriceId || "",
+    stripePriceId: priceData.stripePriceId || "",
+    stripeProductId: priceData.stripeProductId || "",
+    paddlePriceId: priceData.paddlePriceId || "",
+    paddleProductId: priceData.paddleProductId || "",
+    displayName: priceData.displayName || priceData.priceName || priceData.name || product.name
+  };
+}
+function buildRuntimeProducts(products, priceDataMap) {
+  return products.map((product) => {
+    const priceData = priceDataMap.get(product.storePriceId);
+    const trialPriceData = product.trialStorePriceId ? priceDataMap.get(product.trialStorePriceId) : void 0;
+    return buildRuntimeProduct(product, priceData, trialPriceData);
+  });
+}
+
+// src/runtime/systemVariables.ts
+var cachedBrowserInfo = null;
+function detectBrowserInfo() {
+  if (cachedBrowserInfo) return cachedBrowserInfo;
+  if (typeof window === "undefined") {
+    return {
+      userAgent: "unknown",
+      browserName: "Unknown",
+      browserVersion: "0",
+      deviceType: "desktop",
+      isMobile: false,
+      isTablet: false,
+      os: "Unknown",
+      screenWidth: 0,
+      screenHeight: 0,
+      viewportWidth: 0,
+      viewportHeight: 0,
+      language: "en",
+      timezone: "UTC",
+      colorDepth: 24,
+      pixelRatio: 1,
+      cookieEnabled: true,
+      online: true
+    };
+  }
+  const ua = navigator.userAgent;
+  const uaLower = ua.toLowerCase();
+  let browserName = "Unknown";
+  let browserVersion = "0";
+  if (uaLower.includes("firefox")) {
+    browserName = "Firefox";
+    browserVersion = extractVersion(ua, /Firefox\/(\d+[\d.]*)/);
+  } else if (uaLower.includes("edg")) {
+    browserName = "Edge";
+    browserVersion = extractVersion(ua, /Edg\/(\d+[\d.]*)/);
+  } else if (uaLower.includes("chrome") && !uaLower.includes("edg")) {
+    browserName = "Chrome";
+    browserVersion = extractVersion(ua, /Chrome\/(\d+[\d.]*)/);
+  } else if (uaLower.includes("safari") && !uaLower.includes("chrome")) {
+    browserName = "Safari";
+    browserVersion = extractVersion(ua, /Version\/(\d+[\d.]*)/);
+  }
+  let os = "Unknown";
+  if (uaLower.includes("win")) os = "Windows";
+  else if (uaLower.includes("mac")) os = "macOS";
+  else if (uaLower.includes("linux") && !uaLower.includes("android")) os = "Linux";
+  else if (uaLower.includes("android")) os = "Android";
+  else if (/iphone|ipad|ipod/.test(uaLower)) os = "iOS";
+  let deviceType = "desktop";
+  if (/mobile|android(?!.*tablet)|iphone|ipod/.test(uaLower)) deviceType = "mobile";
+  else if (/tablet|ipad/.test(uaLower)) deviceType = "tablet";
+  cachedBrowserInfo = {
+    userAgent: ua,
+    browserName,
+    browserVersion,
+    deviceType,
+    isMobile: deviceType === "mobile",
+    isTablet: deviceType === "tablet",
+    os,
+    screenWidth: window.screen?.width || 0,
+    screenHeight: window.screen?.height || 0,
+    viewportWidth: window.innerWidth || 0,
+    viewportHeight: window.innerHeight || 0,
+    language: navigator.language || "en",
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
+    colorDepth: window.screen?.colorDepth || 24,
+    pixelRatio: window.devicePixelRatio || 1,
+    cookieEnabled: navigator.cookieEnabled ?? true,
+    online: navigator.onLine ?? true
+  };
+  return cachedBrowserInfo;
+}
+function extractVersion(ua, regex) {
+  const match = ua.match(regex);
+  return match?.[1] || "0";
+}
+function computeSystemVariables(context) {
+  const browser = detectBrowserInfo();
+  const now = Date.now();
+  return {
+    // Session
+    "session.startedAt": context.sessionStartTime,
+    // Page
+    "page.currentId": context.currentPageKey,
+    "page.currentIndex": context.pageHistory.length,
+    "page.current": context.pageHistory.length + 1,
+    "page.total": context.totalPages,
+    "page.progressPercentage": context.totalPages > 0 ? Math.min(100, Math.round((context.pageHistory.length + 1) / context.totalPages * 100)) : 0,
+    "page.startedAt": context.pageStartTime || now,
+    // Device
+    "device.isMobile": browser.isMobile,
+    "device.isTablet": browser.isTablet,
+    "device.type": browser.deviceType,
+    "device.screenWidth": browser.screenWidth,
+    "device.screenHeight": browser.screenHeight,
+    "device.viewportWidth": browser.viewportWidth,
+    "device.viewportHeight": browser.viewportHeight,
+    "device.colorDepth": browser.colorDepth,
+    "device.pixelRatio": browser.pixelRatio,
+    // Browser
+    "browser.userAgent": browser.userAgent,
+    "browser.name": browser.browserName,
+    "browser.version": browser.browserVersion,
+    "browser.cookieEnabled": browser.cookieEnabled,
+    "browser.online": browser.online,
+    "browser.language": browser.language,
+    // OS
+    "os.name": browser.os,
+    "os.timezone": browser.timezone,
+    // Metadata
+    "metadata.webfunnelId": context.funnelId,
+    "metadata.campaignId": context.campaignId
+  };
+}
+
+// src/runtime/i18n.ts
+var I18n = class {
+  constructor(defaultLocale = "en") {
+    this.translations = {};
+    this.listeners = /* @__PURE__ */ new Set();
+    this.locale = defaultLocale;
+    this.fallbackLocale = defaultLocale;
+  }
+  /** Load all translations at once */
+  load(translations) {
+    this.translations = translations;
+  }
+  getLocale() {
+    return this.locale;
+  }
+  setLocale(locale) {
+    if (this.locale === locale) return;
+    this.locale = locale;
+    this.notify();
+  }
+  getAvailableLocales() {
+    return Object.keys(this.translations);
+  }
+  /**
+   * Translate a key with optional interpolation.
+   *
+   * Supports dot notation for nested keys and `{{var}}` interpolation:
+   *   t('checkout.title')
+   *   t('welcome', { name: 'John' })  → "Hello, John"
+   */
+  t(key, params) {
+    let value = this.resolve(this.locale, key) ?? this.resolve(this.fallbackLocale, key);
+    if (value === void 0) return key;
+    if (params) {
+      value = value.replace(/\{\{(\w+)\}\}/g, (_, name) => {
+        return params[name] !== void 0 ? String(params[name]) : `{{${name}}}`;
+      });
+    }
+    return value;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  resolve(locale, key) {
+    const dict = this.translations[locale];
+    if (!dict) return void 0;
+    if (dict[key] !== void 0) return dict[key];
+    return void 0;
+  }
+  notify() {
+    this.listeners.forEach((l) => l());
+  }
+};
+var FunnelContext = react.createContext(null);
+function useFunnelContext() {
+  const ctx = react.useContext(FunnelContext);
+  if (!ctx) {
+    throw new Error("useFunnelContext must be used within a <FunnelProvider>");
+  }
+  return ctx;
+}
+function FunnelProvider({
+  config,
+  children,
+  sessionData,
+  priceData,
+  campaignSlug,
+  basePath,
+  initialPage,
+  translations
+}) {
+  const campaignId = sessionData?.campaignId || config.projectId || "";
+  const funnelId = sessionData?.funnelId || config.projectId || "";
+  const storeRef = react.useRef(null);
+  const routerRef = react.useRef(null);
+  const trackerRef = react.useRef(null);
+  const eventBusRef = react.useRef(null);
+  const i18nRef = react.useRef(null);
+  if (!storeRef.current) {
+    storeRef.current = createVariableStore(
+      { responses: config.responses, queryParams: config.queryParams, data: config.data },
+      sessionData?.variables
+    );
+  }
+  if (!routerRef.current) {
+    routerRef.current = new Router({
+      config,
+      initialPage,
+      basePath,
+      campaignSlug
+    });
+  }
+  if (!trackerRef.current) {
+    trackerRef.current = new FunnelTracker();
+  }
+  if (!i18nRef.current) {
+    const i18n2 = new I18n(config.defaultLocale || "en");
+    if (translations) i18n2.load(translations);
+    if (typeof navigator !== "undefined") {
+      const browserLang = navigator.language?.split("-")[0];
+      if (browserLang && translations?.[browserLang]) {
+        i18n2.setLocale(browserLang);
+      }
+    }
+    i18nRef.current = i18n2;
+  }
+  const store = storeRef.current;
+  const router = routerRef.current;
+  const tracker = trackerRef.current;
+  const i18n = i18nRef.current;
+  const products = react.useMemo(() => {
+    if (!config.products?.items || !priceData) return [];
+    return buildRuntimeProducts(config.products.items, priceData);
+  }, [config.products, priceData]);
+  const defaultProductId = config.products?.defaultId || products[0]?.id || null;
+  const selectedProductIdRef = react.useRef(defaultProductId);
+  const selectProduct = react.useCallback((productId) => {
+    selectedProductIdRef.current = productId;
+    store.set("products.selectedProductId", productId);
+  }, [store]);
+  react.useEffect(() => {
+    const eventBus = new AppFunnelEventBus(store, router, selectProduct);
+    eventBus.attach();
+    eventBusRef.current = eventBus;
+    if (config.integrations && Object.keys(config.integrations).length > 0) {
+      initializeIntegrations(config.integrations);
+    }
+    return () => {
+      eventBus.destroy();
+      eventBusRef.current = null;
+    };
+  }, []);
+  react.useEffect(() => {
+    tracker.init(campaignId, funnelId, campaignSlug, sessionData?.experimentId);
+    if (sessionData?.sessionId) {
+      tracker.setSessionId(sessionData.sessionId);
+    }
+    const currentPage = router.getCurrentPage();
+    tracker.track("funnel.start");
+    if (currentPage) {
+      tracker.track("page.view", {
+        pageId: currentPage.key,
+        pageKey: currentPage.key,
+        pageName: currentPage.name,
+        isInitial: true
+      });
+      tracker.startPageTracking(currentPage.key);
+    }
+    return () => {
+      tracker.stopPageTracking();
+      tracker.flushVariables();
+    };
+  }, []);
+  const sessionStartTime = react.useRef(Date.now());
+  const pageStartTime = react.useRef(Date.now());
+  react.useEffect(() => {
+    const sysVars = computeSystemVariables({
+      currentPageKey: router.getCurrentPage()?.key || "",
+      pageHistory: router.getPageHistory(),
+      pageStartTime: pageStartTime.current,
+      sessionStartTime: sessionStartTime.current,
+      totalPages: Object.keys(config.pages ?? {}).length,
+      funnelId,
+      campaignId
+    });
+    store.setMany(sysVars);
+    if (defaultProductId) {
+      store.set("products.selectedProductId", defaultProductId);
+    }
+  }, []);
+  react.useEffect(() => {
+    return store.subscribe(() => {
+      tracker.setCurrentVariables(store.getState());
+    });
+  }, [store, tracker]);
+  const contextValue = react.useMemo(() => ({
+    config,
+    variableStore: store,
+    router,
+    tracker,
+    i18n,
+    products,
+    selectedProductId: selectedProductIdRef.current,
+    selectProduct,
+    funnelId,
+    campaignId,
+    sessionId: tracker.getSessionId()
+  }), [config, store, router, tracker, i18n, products, selectProduct, funnelId, campaignId]);
+  return /* @__PURE__ */ jsxRuntime.jsx(FunnelContext.Provider, { value: contextValue, children });
+}
+
+exports.FunnelProvider = FunnelProvider;
+exports.registerIntegration = registerIntegration;
+exports.useFunnelContext = useFunnelContext;
+//# sourceMappingURL=chunk-BUF5FDKC.cjs.map
+//# sourceMappingURL=chunk-BUF5FDKC.cjs.map