@clickroom/sdk-js 0.2.0

package/dist/index.js

@@ -0,0 +1,1004 @@
+// src/elements-chain.ts
+var MAX_DEPTH = 15;
+var MAX_TEXT_LEN = 255;
+var INTERESTING_TAGS = /* @__PURE__ */ new Set(["a", "button", "input", "select", "textarea", "label"]);
+var OPT_OUT_CLASS = "ch-no-capture";
+var OPT_OUT_ATTR = "data-ch-no-capture";
+function escapeValue(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/;/g, "\\;").replace(/\|/g, "\\|").replace(/\r?\n/g, " ").trim();
+}
+function nthChild(el) {
+  let n = 1;
+  let sib = el.previousElementSibling;
+  while (sib) {
+    n += 1;
+    sib = sib.previousElementSibling;
+  }
+  return n;
+}
+function nthOfType(el) {
+  let n = 1;
+  const tag = el.tagName;
+  let sib = el.previousElementSibling;
+  while (sib) {
+    if (sib.tagName === tag) {
+      n += 1;
+    }
+    sib = sib.previousElementSibling;
+  }
+  return n;
+}
+function elementText(el) {
+  const raw = el.innerText ?? el.textContent ?? "";
+  const trimmed = raw.replace(/\s+/g, " ").trim();
+  return trimmed.length > MAX_TEXT_LEN ? trimmed.slice(0, MAX_TEXT_LEN) : trimmed;
+}
+function serializeElement(el) {
+  const tag = el.tagName.toLowerCase();
+  const pairs = [];
+  const id = el.getAttribute("id");
+  if (id) {
+    pairs.push(`attr__id="${escapeValue(id)}"`);
+  }
+  const className = typeof el.className === "string" ? el.className : "";
+  if (className) {
+    pairs.push(`attr__class="${escapeValue(className)}"`);
+  }
+  if (tag === "a") {
+    const href = el.getAttribute("href");
+    if (href) {
+      pairs.push(`href="${escapeValue(href)}"`);
+    }
+  }
+  const text = elementText(el);
+  if (text) {
+    pairs.push(`text="${escapeValue(text)}"`);
+  }
+  pairs.push(`nth-child="${nthChild(el)}"`);
+  pairs.push(`nth-of-type="${nthOfType(el)}"`);
+  const attrs = el.attributes;
+  for (let i = 0; i < attrs.length; i += 1) {
+    const attr = attrs.item(i);
+    if (attr?.name.startsWith("data-")) {
+      pairs.push(`attr__${attr.name}="${escapeValue(attr.value)}"`);
+    }
+  }
+  return `${tag}:${pairs.join(";")}`;
+}
+function serializeElementsChain(target) {
+  const parts = [];
+  let el = target;
+  let depth = 0;
+  while (el && depth < MAX_DEPTH) {
+    const tag = el.tagName.toLowerCase();
+    if (tag === "body" || tag === "html") {
+      break;
+    }
+    parts.push(serializeElement(el));
+    el = el.parentElement;
+    depth += 1;
+  }
+  return parts.join("|");
+}
+function isOptedOut(el) {
+  let node = el;
+  while (node) {
+    if (node.classList?.contains(OPT_OUT_CLASS) || node.hasAttribute(OPT_OUT_ATTR)) {
+      return true;
+    }
+    node = node.parentElement;
+  }
+  return false;
+}
+function isInteresting(el) {
+  const tag = el.tagName.toLowerCase();
+  if (INTERESTING_TAGS.has(tag)) {
+    return true;
+  }
+  if (el.hasAttribute("data-ch-capture")) {
+    return true;
+  }
+  if (el.getAttribute("role")) {
+    return true;
+  }
+  if (el.hasAttribute("onclick")) {
+    return true;
+  }
+  return false;
+}
+function getEventTarget(el) {
+  let node = el;
+  let depth = 0;
+  while (node && depth < MAX_DEPTH) {
+    if (isOptedOut(node)) {
+      return null;
+    }
+    if (isInteresting(node)) {
+      return node;
+    }
+    node = node.parentElement;
+    depth += 1;
+  }
+  return null;
+}
+
+// src/autocapture.ts
+function locationProps() {
+  return {
+    $current_url: location.href,
+    $host: location.host,
+    $pathname: location.pathname
+  };
+}
+function initAutocapture(ctx) {
+  if (typeof document === "undefined" || typeof window === "undefined") {
+    return () => {
+    };
+  }
+  const handleInteraction = (event) => {
+    try {
+      const raw = event.target;
+      if (!(raw instanceof Element)) {
+        return;
+      }
+      const target = getEventTarget(raw);
+      if (!target) {
+        return;
+      }
+      const chain = serializeElementsChain(target);
+      ctx.capture(
+        "$autocapture",
+        {
+          $event_type: event.type,
+          ...locationProps()
+        },
+        chain
+      );
+    } catch {
+    }
+  };
+  const interactionEvents = ["click", "submit", "change"];
+  if (ctx.config.autocapture) {
+    for (const type of interactionEvents) {
+      document.addEventListener(type, handleInteraction, true);
+    }
+  }
+  let lastUrl = "";
+  const emitPageview = () => {
+    try {
+      if (!ctx.config.capture_pageview) {
+        return;
+      }
+      if (location.href === lastUrl) {
+        return;
+      }
+      lastUrl = location.href;
+      ctx.capture("$pageview", {
+        ...locationProps(),
+        $referrer: document.referrer
+      });
+    } catch {
+    }
+  };
+  const origPushState = history.pushState.bind(history);
+  const origReplaceState = history.replaceState.bind(history);
+  let patched = false;
+  if (ctx.config.capture_pageview) {
+    history.pushState = (...args) => {
+      origPushState(...args);
+      emitPageview();
+    };
+    history.replaceState = (...args) => {
+      origReplaceState(...args);
+      emitPageview();
+    };
+    patched = true;
+    window.addEventListener("popstate", emitPageview);
+    window.addEventListener("hashchange", emitPageview);
+    emitPageview();
+  }
+  return () => {
+    if (ctx.config.autocapture) {
+      for (const type of interactionEvents) {
+        document.removeEventListener(type, handleInteraction, true);
+      }
+    }
+    if (patched) {
+      history.pushState = origPushState;
+      history.replaceState = origReplaceState;
+      window.removeEventListener("popstate", emitPageview);
+      window.removeEventListener("hashchange", emitPageview);
+    }
+  };
+}
+
+// src/channel.ts
+var PAID_MEDIUM_RE = /^(cpc|ppc|paid|display)$/i;
+var SEARCH_ENGINE_DOMAINS = [
+  "google.",
+  "bing.com",
+  "duckduckgo.com",
+  "yahoo.",
+  "baidu.com",
+  "yandex.",
+  "ecosia.org",
+  "ask.com",
+  "aol.com"
+];
+var SOCIAL_DOMAINS = [
+  "facebook.com",
+  "fb.com",
+  "twitter.com",
+  "x.com",
+  "t.co",
+  "linkedin.com",
+  "instagram.com",
+  "tiktok.com",
+  "reddit.com",
+  "pinterest.",
+  "youtube.com",
+  "threads.net"
+];
+var matchesDomain = (domain, list) => list.some((needle) => domain.includes(needle));
+var extractDomain = (url) => {
+  if (!url) return void 0;
+  try {
+    return new URL(url).hostname.toLowerCase();
+  } catch {
+    return void 0;
+  }
+};
+function classifyChannel(referrer, utm, currentHostname) {
+  const referrerDomain = extractDomain(referrer);
+  const utmMedium = utm.$utm_medium;
+  const hasReferrer = Boolean(referrerDomain);
+  const hasUtm = Object.keys(utm).length > 0;
+  if (!hasReferrer && !hasUtm) return "direct";
+  if (utmMedium && PAID_MEDIUM_RE.test(utmMedium)) return "paid";
+  if (referrerDomain && matchesDomain(referrerDomain, SEARCH_ENGINE_DOMAINS))
+    return "organic search";
+  if (referrerDomain && matchesDomain(referrerDomain, SOCIAL_DOMAINS)) return "social";
+  if (utmMedium && utmMedium.toLowerCase() === "email") return "email";
+  if (referrerDomain && referrerDomain !== currentHostname.toLowerCase()) return "referral";
+  return "direct";
+}
+
+// src/device.ts
+var BROWSERS = [
+  { name: "Edge", re: /Edg(?:e|A|iOS)?\/(\d+)/ },
+  { name: "Opera", re: /(?:OPR|Opera)\/(\d+)/ },
+  { name: "Samsung Internet", re: /SamsungBrowser\/(\d+)/ },
+  { name: "Firefox", re: /(?:Firefox|FxiOS)\/(\d+)/ },
+  { name: "Chrome", re: /(?:Chrome|CriOS)\/(\d+)/ },
+  { name: "Safari", re: /Version\/(\d+).*Safari/ }
+];
+var detectBrowser = (ua) => {
+  for (const b of BROWSERS) {
+    const m = ua.match(b.re);
+    if (m) return { name: b.name, version: m[1] };
+  }
+  return {};
+};
+var detectOS = (ua) => {
+  if (/Windows/.test(ua)) return "Windows";
+  if (/iPhone|iPad|iPod/.test(ua)) return "iOS";
+  if (/Android/.test(ua)) return "Android";
+  if (/CrOS/.test(ua)) return "Chrome OS";
+  if (/Mac OS X|Macintosh/.test(ua)) return "macOS";
+  if (/Linux/.test(ua)) return "Linux";
+  return void 0;
+};
+var detectDeviceType = (ua) => {
+  if (/iPad/.test(ua)) return "Tablet";
+  if (/Android/.test(ua)) return /Mobile/.test(ua) ? "Mobile" : "Tablet";
+  if (/iPhone|iPod/.test(ua)) return "Mobile";
+  if (/Mobile/.test(ua)) return "Mobile";
+  return "Desktop";
+};
+function parseDevice(userAgent, language) {
+  const props = {};
+  const ua = userAgent ?? "";
+  if (ua) {
+    const browser = detectBrowser(ua);
+    if (browser.name) props.$browser = browser.name;
+    if (browser.version) props.$browser_version = browser.version;
+    const os = detectOS(ua);
+    if (os) props.$os = os;
+    props.$device_type = detectDeviceType(ua);
+  }
+  if (language) props.$lang = language;
+  return props;
+}
+
+// src/flags.ts
+var HASH_DENOM = Number(BigInt("0xfffffffffffffff"));
+var FLAGS_STORAGE_KEY = "ckrm_flags";
+var safeLocalStorage = () => {
+  try {
+    if (typeof localStorage === "undefined") return null;
+    return localStorage;
+  } catch {
+    return null;
+  }
+};
+function createFlagClient(deps) {
+  let cache = restoreCache();
+  function restoreCache() {
+    try {
+      const raw = safeLocalStorage()?.getItem(FLAGS_STORAGE_KEY);
+      if (!raw) return {};
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object") return parsed;
+    } catch {
+    }
+    return {};
+  }
+  const persist = (map) => {
+    try {
+      safeLocalStorage()?.setItem(FLAGS_STORAGE_KEY, JSON.stringify(map));
+    } catch {
+    }
+  };
+  let lastVersion;
+  const buildUrl = () => {
+    const base = deps.getApiHost().replace(/\/+$/, "");
+    return `${base}/v1/flags`;
+  };
+  const buildVersionUrl = () => {
+    const base = deps.getApiHost().replace(/\/+$/, "");
+    return `${base}/v1/flags/version`;
+  };
+  const fetchFlags = async () => {
+    try {
+      if (typeof fetch !== "function") return cache;
+      const res = await fetch(buildUrl(), {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${deps.getWriteKey()}`
+        },
+        body: JSON.stringify({
+          distinct_id: deps.getDistinctId(),
+          person_properties: deps.getPersonProperties()
+        })
+      });
+      if (!res.ok) return cache;
+      const data = await res.json();
+      const flags = data?.flags;
+      if (flags && typeof flags === "object") {
+        cache = flags;
+        persist(cache);
+      }
+      return cache;
+    } catch {
+      return cache;
+    }
+  };
+  const checkVersionAndMaybeFetch = async () => {
+    let changed = true;
+    let newVersion;
+    try {
+      if (typeof fetch === "function") {
+        const res = await fetch(buildVersionUrl(), {
+          method: "GET",
+          headers: {
+            authorization: `Bearer ${deps.getWriteKey()}`
+          }
+        });
+        if (res.ok) {
+          const data = await res.json();
+          newVersion = data?.version;
+          changed = lastVersion === void 0 || newVersion !== lastVersion;
+        }
+      }
+    } catch {
+    }
+    if (!changed) return { changed: false, flags: cache };
+    const flags = await fetchFlags();
+    if (newVersion !== void 0) lastVersion = newVersion;
+    return { changed: true, flags };
+  };
+  return {
+    getCache: () => cache,
+    isFeatureEnabled: (key) => cache[key]?.enabled ?? false,
+    getFeatureFlag: (key) => {
+      const r = cache[key];
+      if (!r?.enabled) return false;
+      return r.variant != null ? r.variant : true;
+    },
+    getFeatureFlagPayload: (key) => cache[key]?.payload ?? null,
+    fetchFlags,
+    checkVersionAndMaybeFetch,
+    clear: () => {
+      cache = {};
+      try {
+        safeLocalStorage()?.removeItem(FLAGS_STORAGE_KEY);
+      } catch {
+      }
+    }
+  };
+}
+
+// src/session.ts
+var IDLE_MS = 30 * 60 * 1e3;
+var MAX_MS = 24 * 60 * 60 * 1e3;
+var SID_KEY = "ckrm_sid";
+var parse = (raw) => {
+  if (!raw) return null;
+  try {
+    const v = JSON.parse(raw);
+    if (v && typeof v === "object" && typeof v.id === "string" && typeof v.start === "number" && typeof v.last === "number") {
+      return v;
+    }
+  } catch {
+  }
+  return null;
+};
+function createSessionManager({ now, storage, genId }) {
+  const load = () => {
+    try {
+      return parse(storage()?.getItem(SID_KEY) ?? null);
+    } catch {
+      return null;
+    }
+  };
+  const save = (s) => {
+    try {
+      storage()?.setItem(SID_KEY, JSON.stringify(s));
+    } catch {
+    }
+  };
+  const start = (t) => {
+    const s = { id: genId(), start: t, last: t };
+    save(s);
+    return s;
+  };
+  return {
+    getSessionId() {
+      const t = now();
+      const existing = load();
+      const expired = !existing || t - existing.last > IDLE_MS || t - existing.start > MAX_MS;
+      if (expired) {
+        return start(t).id;
+      }
+      existing.last = t;
+      save(existing);
+      return existing.id;
+    },
+    reset() {
+      try {
+        storage()?.removeItem(SID_KEY);
+      } catch {
+      }
+    }
+  };
+}
+
+// src/transport.ts
+var FLUSH_SIZE = 20;
+var BATCH_MAX = 100;
+var FLUSH_INTERVAL_MS = 3e3;
+var RETRY_BASE_MS = 1e3;
+var RETRY_CAP_MS = 3e4;
+var RETRY_MAX_EVENTS = 1e3;
+var isBrowser = () => typeof window !== "undefined";
+function createTransport(getConfig, getWriteKey) {
+  let buffer = [];
+  let retryBuffer = [];
+  let retryAttempt = 0;
+  let retryTimer = null;
+  let interval = null;
+  const buildUrl = () => {
+    const { api_host } = getConfig();
+    const base = api_host.replace(/\/+$/, "");
+    return `${base}/v1/capture?token=${encodeURIComponent(getWriteKey())}`;
+  };
+  const buildBody = (batch) => JSON.stringify({ batch });
+  const scheduleRetry = () => {
+    if (retryTimer !== null || retryBuffer.length === 0) return;
+    const delay = Math.min(RETRY_BASE_MS * 2 ** retryAttempt, RETRY_CAP_MS);
+    try {
+      retryTimer = setTimeout(() => {
+        retryTimer = null;
+        flush(false);
+      }, delay);
+    } catch {
+      retryTimer = null;
+    }
+  };
+  const requeue = (batch) => {
+    retryBuffer = retryBuffer.concat(batch);
+    if (retryBuffer.length > RETRY_MAX_EVENTS) {
+      retryBuffer = retryBuffer.slice(retryBuffer.length - RETRY_MAX_EVENTS);
+    }
+    retryAttempt = Math.min(retryAttempt + 1, 5);
+    scheduleRetry();
+  };
+  const sendBeacon = (url, body) => {
+    try {
+      if (typeof navigator === "undefined" || typeof navigator.sendBeacon !== "function") {
+        return false;
+      }
+      const blob = new Blob([body], { type: "text/plain" });
+      return navigator.sendBeacon(url, blob);
+    } catch {
+      return false;
+    }
+  };
+  const reportRejection = async (res, batch) => {
+    let detail;
+    try {
+      detail = await res.json();
+    } catch {
+    }
+    console.warn(
+      `[clickroom] capture() batch rejected by server (HTTP ${res.status}); dropping ${batch.length} event(s)`,
+      detail
+    );
+  };
+  const sendFetch = (url, body, batch) => {
+    try {
+      if (typeof fetch !== "function") {
+        requeue(batch);
+        return;
+      }
+      fetch(url, {
+        method: "POST",
+        keepalive: true,
+        headers: { "content-type": "application/json" },
+        body
+      }).then((res) => {
+        if (res.ok) {
+          retryAttempt = 0;
+          if (retryBuffer.length > 0) scheduleRetry();
+          return;
+        }
+        if (res.status >= 500) {
+          requeue(batch);
+          return;
+        }
+        void reportRejection(res, batch);
+      }).catch(() => {
+        requeue(batch);
+      });
+    } catch {
+      requeue(batch);
+    }
+  };
+  function flush(useBeacon = false) {
+    if (!isBrowser()) {
+      buffer = [];
+      return;
+    }
+    const pending = retryBuffer.concat(buffer);
+    buffer = [];
+    retryBuffer = [];
+    if (pending.length === 0) return;
+    try {
+      const url = buildUrl();
+      for (let i = 0; i < pending.length; i += BATCH_MAX) {
+        const batch = pending.slice(i, i + BATCH_MAX);
+        const body = buildBody(batch);
+        if (useBeacon && sendBeacon(url, body)) continue;
+        if (useBeacon) {
+          sendFetch(url, body, batch);
+          continue;
+        }
+        sendFetch(url, body, batch);
+      }
+    } catch {
+    }
+  }
+  const onVisibilityChange = () => {
+    try {
+      if (typeof document !== "undefined" && document.hidden) flush(true);
+    } catch {
+    }
+  };
+  const onPageHide = () => {
+    flush(true);
+  };
+  const enqueue = (event) => {
+    if (!isBrowser()) return;
+    try {
+      buffer.push(event);
+      if (buffer.length >= FLUSH_SIZE) flush(false);
+    } catch {
+    }
+  };
+  const teardown = () => {
+    try {
+      if (interval !== null) {
+        clearInterval(interval);
+        interval = null;
+      }
+      if (retryTimer !== null) {
+        clearTimeout(retryTimer);
+        retryTimer = null;
+      }
+      if (typeof document !== "undefined") {
+        document.removeEventListener("visibilitychange", onVisibilityChange);
+      }
+      if (typeof window !== "undefined") {
+        window.removeEventListener("pagehide", onPageHide);
+        window.removeEventListener("beforeunload", onPageHide);
+      }
+    } catch {
+    }
+  };
+  if (isBrowser()) {
+    try {
+      interval = setInterval(() => flush(false), FLUSH_INTERVAL_MS);
+      if (typeof document !== "undefined") {
+        document.addEventListener("visibilitychange", onVisibilityChange);
+      }
+      window.addEventListener("pagehide", onPageHide);
+      window.addEventListener("beforeunload", onPageHide);
+    } catch {
+    }
+  }
+  return { enqueue, flush, teardown };
+}
+
+// src/utm.ts
+var UTM_KEYS = ["source", "medium", "campaign", "term", "content"];
+function parseUtm(search) {
+  const props = {};
+  if (!search) return props;
+  try {
+    const params = new URLSearchParams(search);
+    for (const key of UTM_KEYS) {
+      const value = params.get(`utm_${key}`);
+      if (value) props[`$utm_${key}`] = value;
+    }
+  } catch {
+  }
+  return props;
+}
+
+// src/index.ts
+var PACKAGE_NAME = "@clickroom/sdk-js";
+var LIB_NAME = "clickroom-js";
+var LIB_VERSION = "0.1.0";
+var DID_KEY = "ckrm_did";
+var STORAGE_PREFIX = "ckrm_";
+var DEFAULT_CONFIG = {
+  api_host: "https://sdk.clickroom.co",
+  autocapture: true,
+  capture_pageview: true
+};
+var isBrowser2 = () => typeof window !== "undefined";
+var MIN_FLAG_POLL_INTERVAL_MS = 5e3;
+var state = {
+  initialized: false,
+  warnedNotInit: false,
+  writeKey: "",
+  config: { ...DEFAULT_CONFIG },
+  distinctId: "",
+  personProperties: {},
+  transport: null,
+  session: null,
+  sessionContext: null,
+  teardownAutocapture: null,
+  flagListeners: [],
+  flagClient: null,
+  flagsLoaded: false,
+  emittedFlagCalls: /* @__PURE__ */ new Set(),
+  flagPollId: null
+};
+var safeLocalStorage2 = () => {
+  try {
+    if (typeof localStorage === "undefined") return null;
+    return localStorage;
+  } catch {
+    return null;
+  }
+};
+var safeSessionStorage = () => {
+  try {
+    if (typeof sessionStorage === "undefined") return null;
+    return sessionStorage;
+  } catch {
+    return null;
+  }
+};
+var storageGet = (key) => {
+  try {
+    return safeLocalStorage2()?.getItem(key) ?? null;
+  } catch {
+    return null;
+  }
+};
+var storageSet = (key, value) => {
+  try {
+    safeLocalStorage2()?.setItem(key, value);
+  } catch {
+  }
+};
+var storageRemove = (key) => {
+  try {
+    safeLocalStorage2()?.removeItem(key);
+  } catch {
+  }
+};
+var generateId = () => {
+  try {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+      return crypto.randomUUID();
+    }
+  } catch {
+  }
+  return `ckrm_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 12)}`;
+};
+var loadOrCreateDistinctId = () => {
+  const existing = storageGet(DID_KEY);
+  if (existing) return existing;
+  const fresh = generateId();
+  storageSet(DID_KEY, fresh);
+  return fresh;
+};
+var baseProperties = () => {
+  const props = {
+    $lib: LIB_NAME,
+    $lib_version: LIB_VERSION
+  };
+  try {
+    if (typeof location !== "undefined") {
+      props.$current_url = location.href;
+      props.$host = location.host;
+      props.$pathname = location.pathname;
+    }
+    if (typeof document !== "undefined") {
+      props.$referrer = document.referrer;
+    }
+    if (typeof window !== "undefined" && window.screen) {
+      props.$screen_height = window.screen.height;
+      props.$screen_width = window.screen.width;
+    }
+    if (typeof window !== "undefined") {
+      props.$viewport_height = window.innerHeight;
+      props.$viewport_width = window.innerWidth;
+    }
+    if (typeof navigator !== "undefined") {
+      Object.assign(props, parseDevice(navigator.userAgent, navigator.language));
+    }
+  } catch {
+  }
+  return props;
+};
+var buildSessionContextProps = () => {
+  try {
+    const search = typeof location !== "undefined" ? location.search : "";
+    const referrer = typeof document !== "undefined" ? document.referrer : "";
+    const hostname = typeof location !== "undefined" ? location.hostname : "";
+    const utm = parseUtm(search);
+    return { ...utm, $channel_type: classifyChannel(referrer, utm, hostname) };
+  } catch {
+    return {};
+  }
+};
+var getSessionContextProps = (sessionId) => {
+  if (!sessionId) return buildSessionContextProps();
+  if (!state.sessionContext || state.sessionContext.sessionId !== sessionId) {
+    state.sessionContext = { sessionId, props: buildSessionContextProps() };
+  }
+  return state.sessionContext.props;
+};
+var warnNotInit = () => {
+  if (state.warnedNotInit) return;
+  state.warnedNotInit = true;
+  try {
+    console.warn("[clickroom] capture() called before init(); event dropped");
+  } catch {
+  }
+};
+var captureInternal = (event, properties, elementsChain) => {
+  if (!state.initialized || !state.transport) {
+    warnNotInit();
+    return;
+  }
+  try {
+    const sessionId = state.session?.getSessionId();
+    const sessionProps = sessionId ? { $session_id: sessionId } : {};
+    const payload = {
+      event,
+      distinct_id: state.distinctId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      properties: {
+        ...baseProperties(),
+        ...sessionProps,
+        ...getSessionContextProps(sessionId),
+        ...properties ?? {}
+      }
+    };
+    if (elementsChain) payload.elements_chain = elementsChain;
+    state.transport.enqueue(payload);
+  } catch {
+  }
+};
+var flagFlatMap = (cache) => {
+  const flat = {};
+  for (const [key, r] of Object.entries(cache)) {
+    if (!r.enabled) continue;
+    flat[key] = r.variant != null ? r.variant : true;
+  }
+  return flat;
+};
+var fireFlagListeners = () => {
+  if (!state.flagClient) return;
+  const flat = flagFlatMap(state.flagClient.getCache());
+  for (const cb of state.flagListeners) {
+    try {
+      cb(flat);
+    } catch {
+    }
+  }
+};
+var refreshFlags = () => {
+  if (!state.flagClient) return;
+  state.flagClient.checkVersionAndMaybeFetch().then(() => {
+    state.flagsLoaded = true;
+    fireFlagListeners();
+  }).catch(() => {
+  });
+};
+var maybeEmitFlagCall = (key, response) => {
+  try {
+    if (!state.flagsLoaded) return;
+    const resp = String(response);
+    const dedup = `${key}:${resp}`;
+    if (state.emittedFlagCalls.has(dedup)) return;
+    state.emittedFlagCalls.add(dedup);
+    captureInternal("$feature_flag_called", {
+      $feature_flag: key,
+      $feature_flag_response: resp
+    });
+  } catch {
+  }
+};
+function init(writeKey, opts) {
+  if (state.initialized) return;
+  if (!isBrowser2()) {
+    return;
+  }
+  state.writeKey = writeKey;
+  state.config = {
+    api_host: opts?.api_host ?? DEFAULT_CONFIG.api_host,
+    autocapture: opts?.autocapture ?? DEFAULT_CONFIG.autocapture,
+    capture_pageview: opts?.capture_pageview ?? DEFAULT_CONFIG.capture_pageview
+  };
+  state.distinctId = loadOrCreateDistinctId();
+  state.session = createSessionManager({
+    now: () => Date.now(),
+    storage: safeSessionStorage,
+    genId: generateId
+  });
+  state.transport = createTransport(
+    () => state.config,
+    () => state.writeKey
+  );
+  state.flagClient = createFlagClient({
+    getApiHost: () => state.config.api_host,
+    getWriteKey: () => state.writeKey,
+    getDistinctId: () => state.distinctId,
+    getPersonProperties: () => state.personProperties
+  });
+  state.initialized = true;
+  refreshFlags();
+  if (opts?.feature_flag_poll_interval) {
+    const intervalMs = Math.max(opts.feature_flag_poll_interval, MIN_FLAG_POLL_INTERVAL_MS);
+    state.flagPollId = setInterval(() => refreshFlags(), intervalMs);
+  }
+  if (state.config.autocapture) {
+    const ctx = {
+      config: state.config,
+      capture: captureInternal
+    };
+    try {
+      state.teardownAutocapture = initAutocapture(ctx);
+    } catch {
+    }
+  } else if (state.config.capture_pageview) {
+    captureInternal("$pageview");
+  }
+}
+function capture(event, properties) {
+  captureInternal(event, properties);
+}
+function identify(distinctId, personProps) {
+  if (!state.initialized) {
+    warnNotInit();
+    return;
+  }
+  const previousId = state.distinctId;
+  state.distinctId = distinctId;
+  storageSet(DID_KEY, distinctId);
+  if (personProps) state.personProperties = { ...state.personProperties, ...personProps };
+  captureInternal("$identify", {
+    $set: personProps ?? {},
+    ...previousId !== distinctId ? { $anon_distinct_id: previousId } : {}
+  });
+  state.emittedFlagCalls.clear();
+  refreshFlags();
+}
+function reset() {
+  try {
+    const ls = safeLocalStorage2();
+    if (ls) {
+      const toRemove = [];
+      for (let i = 0; i < ls.length; i += 1) {
+        const key = ls.key(i);
+        if (key?.startsWith(STORAGE_PREFIX)) toRemove.push(key);
+      }
+      for (const key of toRemove) storageRemove(key);
+    }
+  } catch {
+  }
+  state.distinctId = generateId();
+  storageSet(DID_KEY, state.distinctId);
+  state.session?.reset();
+  state.sessionContext = null;
+  state.personProperties = {};
+  state.flagsLoaded = false;
+  state.emittedFlagCalls.clear();
+  state.flagClient?.clear();
+}
+function isFeatureEnabled(key) {
+  const result = state.flagClient?.isFeatureEnabled(key) ?? false;
+  maybeEmitFlagCall(key, result);
+  return result;
+}
+function getFeatureFlag(key) {
+  const result = state.flagClient?.getFeatureFlag(key) ?? false;
+  maybeEmitFlagCall(key, result);
+  return result;
+}
+function getFeatureFlagPayload(key) {
+  return state.flagClient?.getFeatureFlagPayload(key) ?? null;
+}
+function onFeatureFlags(cb) {
+  state.flagListeners.push(cb);
+  if (state.flagsLoaded && state.flagClient) {
+    try {
+      cb(flagFlatMap(state.flagClient.getCache()));
+    } catch {
+    }
+  }
+}
+function refreshFeatureFlags() {
+  refreshFlags();
+}
+function stopFeatureFlagPolling() {
+  if (state.flagPollId !== null) {
+    clearInterval(state.flagPollId);
+    state.flagPollId = null;
+  }
+}
+var clickroom = {
+  init,
+  capture,
+  identify,
+  reset,
+  isFeatureEnabled,
+  getFeatureFlag,
+  getFeatureFlagPayload,
+  onFeatureFlags,
+  refreshFeatureFlags,
+  stopFeatureFlagPolling
+};
+var index_default = clickroom;
+export {
+  PACKAGE_NAME,
+  capture,
+  index_default as default,
+  getFeatureFlag,
+  getFeatureFlagPayload,
+  identify,
+  init,
+  isFeatureEnabled,
+  onFeatureFlags,
+  refreshFeatureFlags,
+  reset,
+  stopFeatureFlagPolling
+};
+//# sourceMappingURL=index.js.map