@intlayer/analytics 9.0.0-canary.16

package/dist/esm/core/AnalyticsClient.mjs

@@ -0,0 +1,177 @@
+import { onIdle } from "../utils/idle.mjs";
+import { assignVariant } from "./abTesting.mjs";
+import { createEventBuffer } from "./eventBuffer.mjs";
+import { isSampledIn } from "./sampling.mjs";
+import { getSessionId } from "./session.mjs";
+import { sendEvents } from "./transport.mjs";
+
+//#region src/core/AnalyticsClient.ts
+/** Default flush cadence — one network request per 20 seconds. */
+const DEFAULT_FLUSH_INTERVAL = 2e4;
+/** Default cap on distinct buffered events before an early flush. */
+const DEFAULT_MAX_BUFFER_SIZE = 500;
+/** Default sampling — keep every session. */
+const DEFAULT_SAMPLE_RATE = 1;
+/**
+* Maximum events per network request. `sendBeacon` and `fetch(keepalive)`
+* reject bodies over ~64KB, so large batches are split into multiple sends.
+*/
+const MAX_EVENTS_PER_SEND = 200;
+/** Identifies the producing SDK in the ingest envelope. */
+const SDK_VERSION = "intlayer-analytics/1";
+/**
+* Reads the current page pathname. Search params are intentionally excluded to
+* avoid capturing anything sensitive.
+*/
+const currentUrl = () => {
+	if (typeof window === "undefined" || !window.location) return "";
+	return window.location.pathname;
+};
+/**
+* Reduces the referrer to its host — never the full URL — for privacy.
+*/
+const referrerHost = () => {
+	if (typeof document === "undefined" || !document.referrer) return void 0;
+	try {
+		return new URL(document.referrer).host;
+	} catch {
+		return;
+	}
+};
+/**
+* Creates an analytics client. Prefer {@link initAnalyticsClient} in application
+* code — it manages a shared singleton so there is only ever one flush timer.
+*
+* @param config - Resolved client configuration.
+* @returns A started-on-demand {@link AnalyticsClient}.
+*/
+const createAnalyticsClient = (config) => {
+	const sessionId = getSessionId();
+	const sampledIn = isSampledIn(sessionId, config.sampleRate);
+	const buffer = createEventBuffer({ max: config.maxBufferSize });
+	const endpoint = `${config.backendURL.replace(/\/$/, "")}/api/analytics/events`;
+	let ambientLocale = "";
+	let flushTimer = null;
+	let started = false;
+	let detachListeners = null;
+	let seenExposureKeys = /* @__PURE__ */ new Set();
+	const flush = (useBeacon = false) => {
+		const events = buffer.drain();
+		for (let start = 0; start < events.length; start += 200) sendEvents(endpoint, {
+			clientId: config.clientId,
+			sessionId,
+			sdkVersion: SDK_VERSION,
+			events: events.slice(start, start + 200)
+		}, { useBeacon });
+	};
+	/** Pushes an event and triggers an early flush if the buffer is full. */
+	const enqueue = (event) => {
+		if (buffer.push(event) >= config.maxBufferSize) flush();
+	};
+	const setLocale = (locale) => {
+		ambientLocale = locale;
+	};
+	const trackPageView = (event = {}) => {
+		if (!sampledIn) return;
+		seenExposureKeys = /* @__PURE__ */ new Set();
+		enqueue({
+			type: "page_view",
+			t: Date.now(),
+			url: event.url ?? currentUrl(),
+			locale: event.locale ?? ambientLocale,
+			ref: event.ref ?? referrerHost(),
+			vw: event.vw ?? (typeof window !== "undefined" ? window.innerWidth : void 0),
+			vh: event.vh ?? (typeof window !== "undefined" ? window.innerHeight : void 0),
+			reason: event.reason ?? "initial"
+		});
+	};
+	const trackContentExposure = (event) => {
+		if (!sampledIn) return;
+		const locale = event.locale ?? ambientLocale;
+		const exposureKey = [
+			event.dictionaryKey,
+			event.keyPath,
+			locale,
+			event.experimentKey ?? "",
+			event.variant ?? ""
+		].join("
");
+		if (seenExposureKeys.has(exposureKey)) return;
+		seenExposureKeys.add(exposureKey);
+		enqueue({
+			...event,
+			type: "content_exposure",
+			t: Date.now(),
+			url: currentUrl(),
+			locale
+		});
+	};
+	const trackConversion = (event) => {
+		enqueue({
+			...event,
+			type: "conversion",
+			t: Date.now(),
+			url: currentUrl(),
+			locale: event.locale ?? ambientLocale
+		});
+		flush();
+	};
+	const getVariant = (experimentKey, variants, weights) => assignVariant(sessionId, experimentKey, variants, weights);
+	/** Attaches lifecycle + SPA-navigation listeners without blocking render. */
+	const attachListeners = () => {
+		if (typeof window === "undefined") return;
+		const onHidden = () => {
+			if (document.visibilityState === "hidden") flush(true);
+		};
+		const onPageHide = () => flush(true);
+		const onPopState = () => trackPageView({ reason: "route_change" });
+		document.addEventListener("visibilitychange", onHidden);
+		window.addEventListener("pagehide", onPageHide, { capture: true });
+		window.addEventListener("popstate", onPopState);
+		const history = window.history;
+		const originalPush = history.pushState;
+		const patchedPushState = function patchedPush(...args) {
+			const result = originalPush.apply(this, args);
+			trackPageView({ reason: "route_change" });
+			return result;
+		};
+		history.pushState = patchedPushState;
+		detachListeners = () => {
+			document.removeEventListener("visibilitychange", onHidden);
+			window.removeEventListener("pagehide", onPageHide, { capture: true });
+			window.removeEventListener("popstate", onPopState);
+			if (history.pushState === patchedPushState) history.pushState = originalPush;
+		};
+	};
+	const start = () => {
+		if (started) return;
+		started = true;
+		flushTimer = setInterval(flush, config.flushInterval);
+		flushTimer?.unref?.();
+		onIdle(attachListeners);
+	};
+	const stop = () => {
+		if (!started) return;
+		started = false;
+		if (flushTimer) {
+			clearInterval(flushTimer);
+			flushTimer = null;
+		}
+		detachListeners?.();
+		detachListeners = null;
+		flush(true);
+	};
+	return {
+		setLocale,
+		trackPageView,
+		trackContentExposure,
+		trackConversion,
+		getVariant,
+		flush,
+		start,
+		stop
+	};
+};
+
+//#endregion
+export { DEFAULT_FLUSH_INTERVAL, DEFAULT_MAX_BUFFER_SIZE, DEFAULT_SAMPLE_RATE, MAX_EVENTS_PER_SEND, createAnalyticsClient };
+//# sourceMappingURL=AnalyticsClient.mjs.map

package/dist/esm/core/AnalyticsClient.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnalyticsClient.mjs","names":[],"sources":["../../../src/core/AnalyticsClient.ts"],"sourcesContent":["import { onIdle } from '../utils/idle';\nimport { assignVariant } from './abTesting';\nimport { createEventBuffer, type EventBuffer } from './eventBuffer';\nimport { isSampledIn } from './sampling';\nimport { getSessionId } from './session';\nimport { sendEvents } from './transport';\nimport type {\n  AnalyticsClientConfig,\n  AnalyticsEvent,\n  ContentExposureEvent,\n  ConversionEvent,\n  PageViewEvent,\n  TrackableEvent,\n} from './types';\n\n/**\n * Caller-supplied fields for a page view. Everything is optional — the client\n * fills `url`, `locale`, viewport, and referrer from the environment when omitted.\n */\nexport type PageViewInput = {\n  /** Explicit pathname / screen name (native runtimes have no `location`). */\n  url?: string;\n  /** Explicit locale; falls back to the client's ambient locale. */\n  locale?: string;\n  /** Referrer host override. */\n  ref?: string;\n  /** Viewport width override. */\n  vw?: number;\n  /** Viewport height override. */\n  vh?: number;\n  /** Why the view was recorded. */\n  reason?: PageViewEvent['reason'];\n};\n\n/** Default flush cadence — one network request per 20 seconds. */\nexport const DEFAULT_FLUSH_INTERVAL = 20_000;\n/** Default cap on distinct buffered events before an early flush. */\nexport const DEFAULT_MAX_BUFFER_SIZE = 500;\n/** Default sampling — keep every session. */\nexport const DEFAULT_SAMPLE_RATE = 1;\n/**\n * Maximum events per network request. `sendBeacon` and `fetch(keepalive)`\n * reject bodies over ~64KB, so large batches are split into multiple sends.\n */\nexport const MAX_EVENTS_PER_SEND = 200;\n/** Identifies the producing SDK in the ingest envelope. */\nconst SDK_VERSION = 'intlayer-analytics/1';\n\n/**\n * The public surface of the analytics client singleton. Framework bindings hold\n * a reference to this and forward provider/node/conversion signals into it.\n */\nexport type AnalyticsClient = {\n  /** Sets the ambient locale stamped onto subsequent events. */\n  setLocale: (locale: string) => void;\n  /** Records a page/locale view (provider level). */\n  trackPageView: (event?: PageViewInput) => void;\n  /** Records a content exposure (node level). Sampled + deduped per page view. */\n  trackContentExposure: (\n    event: Omit<TrackableEvent<ContentExposureEvent>, 'type'>\n  ) => void;\n  /** Records a conversion tied to an experiment variant. */\n  trackConversion: (\n    event: Omit<TrackableEvent<ConversionEvent>, 'type'>\n  ) => void;\n  /** Deterministically resolves this session's variant for an experiment. */\n  getVariant: (\n    experimentKey: string,\n    variants: string[],\n    weights?: number[]\n  ) => string;\n  /** Sends the buffered batch now. */\n  flush: (useBeacon?: boolean) => void;\n  /** Starts the flush loop and lifecycle listeners (idempotent). */\n  start: () => void;\n  /** Stops timers/listeners and flushes any remaining events. */\n  stop: () => void;\n};\n\n/**\n * Reads the current page pathname. Search params are intentionally excluded to\n * avoid capturing anything sensitive.\n */\nconst currentUrl = (): string => {\n  if (typeof window === 'undefined' || !window.location) return '';\n  return window.location.pathname;\n};\n\n/**\n * Reduces the referrer to its host — never the full URL — for privacy.\n */\nconst referrerHost = (): string | undefined => {\n  if (typeof document === 'undefined' || !document.referrer) return undefined;\n  try {\n    return new URL(document.referrer).host;\n  } catch {\n    return undefined;\n  }\n};\n\n/**\n * Creates an analytics client. Prefer {@link initAnalyticsClient} in application\n * code — it manages a shared singleton so there is only ever one flush timer.\n *\n * @param config - Resolved client configuration.\n * @returns A started-on-demand {@link AnalyticsClient}.\n */\nexport const createAnalyticsClient = (\n  config: AnalyticsClientConfig\n): AnalyticsClient => {\n  const sessionId = getSessionId();\n  const sampledIn = isSampledIn(sessionId, config.sampleRate);\n  const buffer: EventBuffer = createEventBuffer({ max: config.maxBufferSize });\n  const endpoint = `${config.backendURL.replace(/\\/$/, '')}/api/analytics/events`;\n\n  let ambientLocale = '';\n  let flushTimer: ReturnType<typeof setInterval> | null = null;\n  let started = false;\n  let detachListeners: (() => void) | null = null;\n\n  // Exposure keys already recorded for the current page view. React (and other\n  // frameworks) resolve content nodes on every re-render; without this gate a\n  // component re-rendering 60×/s would count 60 exposures per second. The set\n  // is cleared on each page view so the recorded semantic is \"shown at least\n  // once during this page view\".\n  let seenExposureKeys = new Set<string>();\n\n  const flush = (useBeacon = false): void => {\n    const events = buffer.drain();\n\n    // Split into bounded chunks so no single request exceeds transport limits.\n    for (let start = 0; start < events.length; start += MAX_EVENTS_PER_SEND) {\n      sendEvents(\n        endpoint,\n        {\n          clientId: config.clientId,\n          sessionId,\n          sdkVersion: SDK_VERSION,\n          events: events.slice(start, start + MAX_EVENTS_PER_SEND),\n        },\n        { useBeacon }\n      );\n    }\n  };\n\n  /** Pushes an event and triggers an early flush if the buffer is full. */\n  const enqueue = (event: AnalyticsEvent): void => {\n    const size = buffer.push(event);\n    if (size >= config.maxBufferSize) flush();\n  };\n\n  const setLocale = (locale: string): void => {\n    ambientLocale = locale;\n  };\n\n  const trackPageView: AnalyticsClient['trackPageView'] = (event = {}) => {\n    if (!sampledIn) return;\n\n    // A new page view starts a fresh exposure window.\n    seenExposureKeys = new Set<string>();\n\n    enqueue({\n      type: 'page_view',\n      t: Date.now(),\n      url: event.url ?? currentUrl(),\n      locale: event.locale ?? ambientLocale,\n      ref: event.ref ?? referrerHost(),\n      vw:\n        event.vw ??\n        (typeof window !== 'undefined' ? window.innerWidth : undefined),\n      vh:\n        event.vh ??\n        (typeof window !== 'undefined' ? window.innerHeight : undefined),\n      reason: event.reason ?? 'initial',\n    });\n  };\n\n  const trackContentExposure: AnalyticsClient['trackContentExposure'] = (\n    event\n  ) => {\n    if (!sampledIn) return;\n\n    const locale = event.locale ?? ambientLocale;\n    // Joined with \\x01 (never present in content keys) so parts cannot collide.\n    const exposureKey = [\n      event.dictionaryKey,\n      event.keyPath,\n      locale,\n      event.experimentKey ?? '',\n      event.variant ?? '',\n    ].join('\u0001');\n\n    // Deduplicate within the current page view (see `seenExposureKeys`).\n    if (seenExposureKeys.has(exposureKey)) return;\n    seenExposureKeys.add(exposureKey);\n\n    enqueue({\n      ...event,\n      type: 'content_exposure',\n      t: Date.now(),\n      url: currentUrl(),\n      locale,\n    });\n  };\n\n  const trackConversion: AnalyticsClient['trackConversion'] = (event) => {\n    // Conversions are never sampled out — they are rare and decisive for A/B.\n    enqueue({\n      ...event,\n      type: 'conversion',\n      t: Date.now(),\n      url: currentUrl(),\n      locale: event.locale ?? ambientLocale,\n    });\n    // Flush conversions promptly so they are not lost on immediate navigation.\n    flush();\n  };\n\n  const getVariant: AnalyticsClient['getVariant'] = (\n    experimentKey,\n    variants,\n    weights\n  ) => assignVariant(sessionId, experimentKey, variants, weights);\n\n  /** Attaches lifecycle + SPA-navigation listeners without blocking render. */\n  const attachListeners = (): void => {\n    if (typeof window === 'undefined') return;\n\n    const onHidden = (): void => {\n      if (document.visibilityState === 'hidden') flush(true);\n    };\n    const onPageHide = (): void => flush(true);\n    const onPopState = (): void => trackPageView({ reason: 'route_change' });\n\n    document.addEventListener('visibilitychange', onHidden);\n    window.addEventListener('pagehide', onPageHide, { capture: true });\n    window.addEventListener('popstate', onPopState);\n\n    // Patch history.pushState so client-side route changes emit a page view.\n    // `replaceState` is intentionally left untouched: routers use it for\n    // same-page URL sync (scroll, params), which is not a navigation.\n    const history = window.history;\n    const originalPush = history.pushState;\n\n    const patchedPushState = function patchedPush(\n      this: History,\n      ...args: Parameters<History['pushState']>\n    ) {\n      const result = originalPush.apply(this, args);\n      trackPageView({ reason: 'route_change' });\n      return result;\n    };\n    history.pushState = patchedPushState;\n\n    detachListeners = (): void => {\n      document.removeEventListener('visibilitychange', onHidden);\n      window.removeEventListener('pagehide', onPageHide, { capture: true });\n      window.removeEventListener('popstate', onPopState);\n      // Only restore if nothing else re-patched pushState after us; restoring\n      // blindly would clobber another library's wrapper.\n      if (history.pushState === patchedPushState) {\n        history.pushState = originalPush;\n      }\n    };\n  };\n\n  const start = (): void => {\n    if (started) return;\n    started = true;\n\n    flushTimer = setInterval(flush, config.flushInterval);\n    // Some runtimes (Node during SSR) keep the process alive on timers.\n    (flushTimer as { unref?: () => void })?.unref?.();\n\n    onIdle(attachListeners);\n  };\n\n  const stop = (): void => {\n    if (!started) return;\n    started = false;\n\n    if (flushTimer) {\n      clearInterval(flushTimer);\n      flushTimer = null;\n    }\n    detachListeners?.();\n    detachListeners = null;\n    flush(true);\n  };\n\n  return {\n    setLocale,\n    trackPageView,\n    trackContentExposure,\n    trackConversion,\n    getVariant,\n    flush,\n    start,\n    stop,\n  };\n};\n"],"mappings":"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"}

package/dist/esm/core/abTesting.mjs

@@ -0,0 +1,43 @@
+import { hashString } from "../utils/hash.mjs";
+
+//#region src/core/abTesting.ts
+/**
+* Deterministically assigns a variant to a session for a given experiment.
+*
+* The assignment is a pure function of `sessionId` + `experimentKey`, so it is
+* stable for the whole session and requires **no** server round-trip before the
+* first render — avoiding layout shift / content flicker. Optional `weights`
+* bias the split (e.g. `[0.9, 0.1]` for a 90/10 rollout).
+*
+* @param sessionId - The current anonymous session id.
+* @param experimentKey - Unique key identifying the experiment.
+* @param variants - The candidate variant names (at least one).
+* @param weights - Optional relative weights, one per variant.
+* @returns The variant assigned to this session.
+*
+* @example
+* assignVariant('sid-1', 'homepage-hero', ['a', 'b']);          // stable 'a' | 'b'
+* assignVariant('sid-1', 'homepage-hero', ['a', 'b'], [9, 1]);  // ~90% 'a'
+*/
+const assignVariant = (sessionId, experimentKey, variants, weights) => {
+	if (variants.length === 0) throw new Error("assignVariant requires at least one variant");
+	if (variants.length === 1) return variants[0];
+	const bucket = hashString(`${sessionId}:${experimentKey}`) / 4294967296;
+	if (!weights || weights.length !== variants.length) {
+		const index = Math.floor(bucket * variants.length);
+		return variants[Math.min(index, variants.length - 1)];
+	}
+	const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
+	if (totalWeight <= 0) return variants[Math.floor(bucket * variants.length)];
+	let cumulative = 0;
+	const target = bucket * totalWeight;
+	for (let index = 0; index < variants.length; index++) {
+		cumulative += weights[index];
+		if (target < cumulative) return variants[index];
+	}
+	return variants[variants.length - 1];
+};
+
+//#endregion
+export { assignVariant };
+//# sourceMappingURL=abTesting.mjs.map

package/dist/esm/core/abTesting.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"abTesting.mjs","names":[],"sources":["../../../src/core/abTesting.ts"],"sourcesContent":["import { hashString } from '../utils/hash';\n\n/**\n * Deterministically assigns a variant to a session for a given experiment.\n *\n * The assignment is a pure function of `sessionId` + `experimentKey`, so it is\n * stable for the whole session and requires **no** server round-trip before the\n * first render — avoiding layout shift / content flicker. Optional `weights`\n * bias the split (e.g. `[0.9, 0.1]` for a 90/10 rollout).\n *\n * @param sessionId - The current anonymous session id.\n * @param experimentKey - Unique key identifying the experiment.\n * @param variants - The candidate variant names (at least one).\n * @param weights - Optional relative weights, one per variant.\n * @returns The variant assigned to this session.\n *\n * @example\n * assignVariant('sid-1', 'homepage-hero', ['a', 'b']);          // stable 'a' | 'b'\n * assignVariant('sid-1', 'homepage-hero', ['a', 'b'], [9, 1]);  // ~90% 'a'\n */\nexport const assignVariant = (\n  sessionId: string,\n  experimentKey: string,\n  variants: string[],\n  weights?: number[]\n): string => {\n  if (variants.length === 0) {\n    throw new Error('assignVariant requires at least one variant');\n  }\n  if (variants.length === 1) return variants[0]!;\n\n  // Uniform bucket in [0, 1) derived from the session + experiment.\n  const bucket = hashString(`${sessionId}:${experimentKey}`) / 0x100000000;\n\n  if (!weights || weights.length !== variants.length) {\n    const index = Math.floor(bucket * variants.length);\n    return variants[Math.min(index, variants.length - 1)];\n  }\n\n  const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);\n  if (totalWeight <= 0) {\n    return variants[Math.floor(bucket * variants.length)];\n  }\n\n  let cumulative = 0;\n  const target = bucket * totalWeight;\n  for (let index = 0; index < variants.length; index++) {\n    cumulative += weights[index];\n    if (target < cumulative) return variants[index];\n  }\n\n  return variants[variants.length - 1];\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,iBACX,WACA,eACA,UACA,YACW;AACX,KAAI,SAAS,WAAW,EACtB,OAAM,IAAI,MAAM,8CAA8C;AAEhE,KAAI,SAAS,WAAW,EAAG,QAAO,SAAS;CAG3C,MAAM,SAAS,WAAW,GAAG,UAAU,GAAG,gBAAgB,GAAG;AAE7D,KAAI,CAAC,WAAW,QAAQ,WAAW,SAAS,QAAQ;EAClD,MAAM,QAAQ,KAAK,MAAM,SAAS,SAAS,OAAO;AAClD,SAAO,SAAS,KAAK,IAAI,OAAO,SAAS,SAAS,EAAE;;CAGtD,MAAM,cAAc,QAAQ,QAAQ,KAAK,WAAW,MAAM,QAAQ,EAAE;AACpE,KAAI,eAAe,EACjB,QAAO,SAAS,KAAK,MAAM,SAAS,SAAS,OAAO;CAGtD,IAAI,aAAa;CACjB,MAAM,SAAS,SAAS;AACxB,MAAK,IAAI,QAAQ,GAAG,QAAQ,SAAS,QAAQ,SAAS;AACpD,gBAAc,QAAQ;AACtB,MAAI,SAAS,WAAY,QAAO,SAAS;;AAG3C,QAAO,SAAS,SAAS,SAAS"}

package/dist/esm/core/eventBuffer.mjs

@@ -0,0 +1,66 @@
+//#region src/core/eventBuffer.ts
+/** Field separator for coalescing keys — never present in content keys. */
+const KEY_SEPARATOR = "
";
+/**
+* Builds the coalescing key for a content-exposure event. Two exposures of the
+* same node, page, locale, experiment, and variant collapse into one event with
+* an incremented `count`.
+*/
+const exposureKey = (event) => [
+	event.url,
+	event.dictionaryKey,
+	event.keyPath,
+	event.locale,
+	event.experimentKey ?? "",
+	event.variant ?? ""
+].join(KEY_SEPARATOR);
+/**
+* Creates an {@link EventBuffer}.
+*
+* @param options - Buffer options.
+* @param options.max - Maximum number of distinct events to retain.
+* @returns A new buffer instance.
+*/
+const createEventBuffer = ({ max }) => {
+	let discreteEvents = [];
+	const exposures = /* @__PURE__ */ new Map();
+	const size = () => discreteEvents.length + exposures.size;
+	/** Evicts oldest exposures first, then oldest discrete events. */
+	const enforceCap = () => {
+		while (size() > max && exposures.size > 0) {
+			const oldestKey = exposures.keys().next().value;
+			exposures.delete(oldestKey);
+		}
+		if (size() > max) discreteEvents = discreteEvents.slice(size() - max);
+	};
+	const push = (event) => {
+		if (event.type === "content_exposure") {
+			const key = exposureKey(event);
+			const existing = exposures.get(key);
+			if (existing) {
+				existing.count = (existing.count ?? 1) + (event.count ?? 1);
+				existing.t = event.t;
+			} else exposures.set(key, {
+				...event,
+				count: event.count ?? 1
+			});
+		} else discreteEvents.push(event);
+		enforceCap();
+		return size();
+	};
+	const drain = () => {
+		const drained = [...discreteEvents, ...exposures.values()];
+		discreteEvents = [];
+		exposures.clear();
+		return drained;
+	};
+	return {
+		push,
+		drain,
+		size
+	};
+};
+
+//#endregion
+export { createEventBuffer };
+//# sourceMappingURL=eventBuffer.mjs.map

package/dist/esm/core/eventBuffer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventBuffer.mjs","names":[],"sources":["../../../src/core/eventBuffer.ts"],"sourcesContent":["import type { AnalyticsEvent, ContentExposureEvent } from './types';\n\n/** Field separator for coalescing keys — never present in content keys. */\nconst KEY_SEPARATOR = '\u0001';\n\n/**\n * Builds the coalescing key for a content-exposure event. Two exposures of the\n * same node, page, locale, experiment, and variant collapse into one event with\n * an incremented `count`.\n */\nconst exposureKey = (event: ContentExposureEvent): string =>\n  [\n    event.url,\n    event.dictionaryKey,\n    event.keyPath,\n    event.locale,\n    event.experimentKey ?? '',\n    event.variant ?? '',\n  ].join(KEY_SEPARATOR);\n\n/**\n * A bounded, coalescing in-memory buffer for analytics events.\n *\n * - `page_view` and `conversion` events are appended verbatim (they are rare\n *   and valuable — they are never evicted while exposures remain).\n * - `content_exposure` events are deduplicated by page/node/locale/variant with\n *   a running `count`, keeping the highest-volume signal cheap.\n * - When the total number of stored events exceeds `max`, the **oldest\n *   exposures** are evicted first (analytics is lossy by design; exposures are\n *   the expendable signal). Discrete events are only dropped once no exposures\n *   remain.\n */\nexport type EventBuffer = {\n  /** Adds an event, coalescing content exposures. Returns the current size. */\n  push: (event: AnalyticsEvent) => number;\n  /** Removes and returns every buffered event. */\n  drain: () => AnalyticsEvent[];\n  /** Current number of distinct buffered events. */\n  size: () => number;\n};\n\n/**\n * Creates an {@link EventBuffer}.\n *\n * @param options - Buffer options.\n * @param options.max - Maximum number of distinct events to retain.\n * @returns A new buffer instance.\n */\nexport const createEventBuffer = ({ max }: { max: number }): EventBuffer => {\n  // Insertion-ordered list of non-coalesced events (page views, conversions).\n  let discreteEvents: AnalyticsEvent[] = [];\n  // Coalesced content exposures keyed by page/node/locale/variant.\n  const exposures = new Map<string, ContentExposureEvent>();\n\n  const size = (): number => discreteEvents.length + exposures.size;\n\n  /** Evicts oldest exposures first, then oldest discrete events. */\n  const enforceCap = (): void => {\n    while (size() > max && exposures.size > 0) {\n      // Map iteration follows insertion order — the first key is the oldest.\n      const oldestKey = exposures.keys().next().value as string;\n      exposures.delete(oldestKey);\n    }\n    if (size() > max) {\n      discreteEvents = discreteEvents.slice(size() - max);\n    }\n  };\n\n  const push = (event: AnalyticsEvent): number => {\n    if (event.type === 'content_exposure') {\n      const key = exposureKey(event);\n      const existing = exposures.get(key);\n\n      if (existing) {\n        existing.count = (existing.count ?? 1) + (event.count ?? 1);\n        existing.t = event.t; // keep the most recent timestamp\n      } else {\n        exposures.set(key, { ...event, count: event.count ?? 1 });\n      }\n    } else {\n      discreteEvents.push(event);\n    }\n\n    enforceCap();\n\n    return size();\n  };\n\n  const drain = (): AnalyticsEvent[] => {\n    const drained: AnalyticsEvent[] = [\n      ...discreteEvents,\n      ...exposures.values(),\n    ];\n    discreteEvents = [];\n    exposures.clear();\n    return drained;\n  };\n\n  return { push, drain, size };\n};\n"],"mappings":";;AAGA,MAAM,gBAAgB;;;;;;AAOtB,MAAM,eAAe,UACnB;CACE,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM,iBAAiB;CACvB,MAAM,WAAW;CAClB,CAAC,KAAK,cAAc;;;;;;;;AA8BvB,MAAa,qBAAqB,EAAE,UAAwC;CAE1E,IAAI,iBAAmC,EAAE;CAEzC,MAAM,4BAAY,IAAI,KAAmC;CAEzD,MAAM,aAAqB,eAAe,SAAS,UAAU;;CAG7D,MAAM,mBAAyB;AAC7B,SAAO,MAAM,GAAG,OAAO,UAAU,OAAO,GAAG;GAEzC,MAAM,YAAY,UAAU,MAAM,CAAC,MAAM,CAAC;AAC1C,aAAU,OAAO,UAAU;;AAE7B,MAAI,MAAM,GAAG,IACX,kBAAiB,eAAe,MAAM,MAAM,GAAG,IAAI;;CAIvD,MAAM,QAAQ,UAAkC;AAC9C,MAAI,MAAM,SAAS,oBAAoB;GACrC,MAAM,MAAM,YAAY,MAAM;GAC9B,MAAM,WAAW,UAAU,IAAI,IAAI;AAEnC,OAAI,UAAU;AACZ,aAAS,SAAS,SAAS,SAAS,MAAM,MAAM,SAAS;AACzD,aAAS,IAAI,MAAM;SAEnB,WAAU,IAAI,KAAK;IAAE,GAAG;IAAO,OAAO,MAAM,SAAS;IAAG,CAAC;QAG3D,gBAAe,KAAK,MAAM;AAG5B,cAAY;AAEZ,SAAO,MAAM;;CAGf,MAAM,cAAgC;EACpC,MAAM,UAA4B,CAChC,GAAG,gBACH,GAAG,UAAU,QAAQ,CACtB;AACD,mBAAiB,EAAE;AACnB,YAAU,OAAO;AACjB,SAAO;;AAGT,QAAO;EAAE;EAAM;EAAO;EAAM"}

package/dist/esm/core/globalManager.mjs

@@ -0,0 +1,58 @@
+//#region src/core/globalManager.ts
+/**
+* Key on `window` used to share the client singleton across multiple module
+* instances. When bundlers include `@intlayer/analytics` more than once (e.g.
+* a framework package plus the app), each copy has its own module-level
+* variables; storing the client on `window` ensures they all share one buffer
+* and one flush timer.
+*/
+const CLIENT_KEY = "__intlayer_analytics_client__";
+/**
+* Key on `window` holding the provider reference count. It lives next to the
+* client (rather than in module scope) for the same reason the client does:
+* duplicated module instances must share one count, otherwise one copy's
+* `stopAnalyticsClient` could stop a client another copy still uses.
+*/
+const REF_COUNT_KEY = "__intlayer_analytics_ref_count__";
+/**
+* Returns the global analytics client, or `null` in SSR or before init.
+*/
+const getGlobalAnalyticsClient = () => {
+	if (typeof window === "undefined") return null;
+	return window[CLIENT_KEY] ?? null;
+};
+/**
+* Sets (or clears) the global analytics client singleton.
+*
+* @param client - The client to store globally, or `null` to clear it.
+*/
+const setGlobalAnalyticsClient = (client) => {
+	if (typeof window === "undefined") return;
+	window[CLIENT_KEY] = client;
+};
+/**
+* Increments the shared provider reference count.
+*
+* @returns The count after incrementing (`0` in SSR, where nothing is stored).
+*/
+const incrementAnalyticsClientRefCount = () => {
+	if (typeof window === "undefined") return 0;
+	const globals = window;
+	globals[REF_COUNT_KEY] = (globals[REF_COUNT_KEY] ?? 0) + 1;
+	return globals[REF_COUNT_KEY];
+};
+/**
+* Decrements the shared provider reference count, clamping at zero.
+*
+* @returns The count after decrementing (`0` in SSR, where nothing is stored).
+*/
+const decrementAnalyticsClientRefCount = () => {
+	if (typeof window === "undefined") return 0;
+	const globals = window;
+	globals[REF_COUNT_KEY] = Math.max(0, (globals[REF_COUNT_KEY] ?? 0) - 1);
+	return globals[REF_COUNT_KEY];
+};
+
+//#endregion
+export { decrementAnalyticsClientRefCount, getGlobalAnalyticsClient, incrementAnalyticsClientRefCount, setGlobalAnalyticsClient };
+//# sourceMappingURL=globalManager.mjs.map

package/dist/esm/core/globalManager.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalManager.mjs","names":[],"sources":["../../../src/core/globalManager.ts"],"sourcesContent":["import type { AnalyticsClient } from './AnalyticsClient';\n\n/**\n * Key on `window` used to share the client singleton across multiple module\n * instances. When bundlers include `@intlayer/analytics` more than once (e.g.\n * a framework package plus the app), each copy has its own module-level\n * variables; storing the client on `window` ensures they all share one buffer\n * and one flush timer.\n */\nconst CLIENT_KEY = '__intlayer_analytics_client__';\n\n/**\n * Key on `window` holding the provider reference count. It lives next to the\n * client (rather than in module scope) for the same reason the client does:\n * duplicated module instances must share one count, otherwise one copy's\n * `stopAnalyticsClient` could stop a client another copy still uses.\n */\nconst REF_COUNT_KEY = '__intlayer_analytics_ref_count__';\n\ntype WindowWithAnalyticsGlobals = typeof window & {\n  [CLIENT_KEY]?: AnalyticsClient | null;\n  [REF_COUNT_KEY]?: number;\n};\n\n/**\n * Returns the global analytics client, or `null` in SSR or before init.\n */\nexport const getGlobalAnalyticsClient = (): AnalyticsClient | null => {\n  if (typeof window === 'undefined') return null;\n  return (window as WindowWithAnalyticsGlobals)[CLIENT_KEY] ?? null;\n};\n\n/**\n * Sets (or clears) the global analytics client singleton.\n *\n * @param client - The client to store globally, or `null` to clear it.\n */\nexport const setGlobalAnalyticsClient = (\n  client: AnalyticsClient | null\n): void => {\n  if (typeof window === 'undefined') return;\n  (window as WindowWithAnalyticsGlobals)[CLIENT_KEY] = client;\n};\n\n/**\n * Increments the shared provider reference count.\n *\n * @returns The count after incrementing (`0` in SSR, where nothing is stored).\n */\nexport const incrementAnalyticsClientRefCount = (): number => {\n  if (typeof window === 'undefined') return 0;\n  const globals = window as WindowWithAnalyticsGlobals;\n  globals[REF_COUNT_KEY] = (globals[REF_COUNT_KEY] ?? 0) + 1;\n  return globals[REF_COUNT_KEY];\n};\n\n/**\n * Decrements the shared provider reference count, clamping at zero.\n *\n * @returns The count after decrementing (`0` in SSR, where nothing is stored).\n */\nexport const decrementAnalyticsClientRefCount = (): number => {\n  if (typeof window === 'undefined') return 0;\n  const globals = window as WindowWithAnalyticsGlobals;\n  globals[REF_COUNT_KEY] = Math.max(0, (globals[REF_COUNT_KEY] ?? 0) - 1);\n  return globals[REF_COUNT_KEY];\n};\n"],"mappings":";;;;;;;;AASA,MAAM,aAAa;;;;;;;AAQnB,MAAM,gBAAgB;;;;AAUtB,MAAa,iCAAyD;AACpE,KAAI,OAAO,WAAW,YAAa,QAAO;AAC1C,QAAQ,OAAsC,eAAe;;;;;;;AAQ/D,MAAa,4BACX,WACS;AACT,KAAI,OAAO,WAAW,YAAa;AACnC,CAAC,OAAsC,cAAc;;;;;;;AAQvD,MAAa,yCAAiD;AAC5D,KAAI,OAAO,WAAW,YAAa,QAAO;CAC1C,MAAM,UAAU;AAChB,SAAQ,kBAAkB,QAAQ,kBAAkB,KAAK;AACzD,QAAO,QAAQ;;;;;;;AAQjB,MAAa,yCAAiD;AAC5D,KAAI,OAAO,WAAW,YAAa,QAAO;CAC1C,MAAM,UAAU;AAChB,SAAQ,iBAAiB,KAAK,IAAI,IAAI,QAAQ,kBAAkB,KAAK,EAAE;AACvE,QAAO,QAAQ"}

package/dist/esm/core/index.mjs

@@ -0,0 +1,10 @@
+import { assignVariant } from "./abTesting.mjs";
+import { createEventBuffer } from "./eventBuffer.mjs";
+import { isSampledIn } from "./sampling.mjs";
+import { getSessionId } from "./session.mjs";
+import { sendEvents } from "./transport.mjs";
+import { DEFAULT_FLUSH_INTERVAL, DEFAULT_MAX_BUFFER_SIZE, DEFAULT_SAMPLE_RATE, MAX_EVENTS_PER_SEND, createAnalyticsClient } from "./AnalyticsClient.mjs";
+import { decrementAnalyticsClientRefCount, getGlobalAnalyticsClient, incrementAnalyticsClientRefCount, setGlobalAnalyticsClient } from "./globalManager.mjs";
+import { initAnalyticsClient, stopAnalyticsClient } from "./initAnalyticsClient.mjs";
+
+export { DEFAULT_FLUSH_INTERVAL, DEFAULT_MAX_BUFFER_SIZE, DEFAULT_SAMPLE_RATE, MAX_EVENTS_PER_SEND, assignVariant, createAnalyticsClient, createEventBuffer, decrementAnalyticsClientRefCount, getGlobalAnalyticsClient, getSessionId, incrementAnalyticsClientRefCount, initAnalyticsClient, isSampledIn, sendEvents, setGlobalAnalyticsClient, stopAnalyticsClient };

package/dist/esm/core/initAnalyticsClient.mjs

@@ -0,0 +1,49 @@
+import { DEFAULT_FLUSH_INTERVAL, DEFAULT_MAX_BUFFER_SIZE, DEFAULT_SAMPLE_RATE, createAnalyticsClient } from "./AnalyticsClient.mjs";
+import { decrementAnalyticsClientRefCount, getGlobalAnalyticsClient, incrementAnalyticsClientRefCount, setGlobalAnalyticsClient } from "./globalManager.mjs";
+import { analytics, editor } from "@intlayer/config/built";
+
+//#region src/core/initAnalyticsClient.ts
+/**
+* Initializes the Intlayer analytics client singleton.
+*
+* Behavior comes from the `analytics` config block (`flushInterval`,
+* `sampleRate`); attribution reuses the existing `editor` config
+* (`editor.backendURL` for the endpoint, `editor.clientId` for the project).
+*
+* Safe to call multiple times: returns the existing client and increments a
+* `window`-shared reference count so nested providers (or duplicated module
+* instances) don't stop the client prematurely.
+*
+* @returns The started analytics client singleton.
+*/
+const initAnalyticsClient = () => {
+	incrementAnalyticsClientRefCount();
+	const existing = getGlobalAnalyticsClient();
+	if (existing) return existing;
+	const client = createAnalyticsClient({
+		backendURL: editor?.backendURL ?? "",
+		clientId: editor?.clientId,
+		flushInterval: analytics?.flushInterval ?? 2e4,
+		maxBufferSize: 500,
+		sampleRate: analytics?.sampleRate ?? 1
+	});
+	setGlobalAnalyticsClient(client);
+	client.start();
+	return client;
+};
+/**
+* Decrements the shared reference count and stops the global analytics client
+* only when the last provider unmounts (flushing any remaining events).
+*
+* Callers must pair each `stopAnalyticsClient` with a prior
+* `initAnalyticsClient` — never call it when init was skipped or cancelled.
+*/
+const stopAnalyticsClient = () => {
+	if (decrementAnalyticsClientRefCount() > 0) return;
+	getGlobalAnalyticsClient()?.stop();
+	setGlobalAnalyticsClient(null);
+};
+
+//#endregion
+export { initAnalyticsClient, stopAnalyticsClient };
+//# sourceMappingURL=initAnalyticsClient.mjs.map

package/dist/esm/core/initAnalyticsClient.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"initAnalyticsClient.mjs","names":[],"sources":["../../../src/core/initAnalyticsClient.ts"],"sourcesContent":["import { analytics, editor } from '@intlayer/config/built';\nimport {\n  type AnalyticsClient,\n  createAnalyticsClient,\n  DEFAULT_FLUSH_INTERVAL,\n  DEFAULT_MAX_BUFFER_SIZE,\n  DEFAULT_SAMPLE_RATE,\n} from './AnalyticsClient';\nimport {\n  decrementAnalyticsClientRefCount,\n  getGlobalAnalyticsClient,\n  incrementAnalyticsClientRefCount,\n  setGlobalAnalyticsClient,\n} from './globalManager';\n\n/**\n * Initializes the Intlayer analytics client singleton.\n *\n * Behavior comes from the `analytics` config block (`flushInterval`,\n * `sampleRate`); attribution reuses the existing `editor` config\n * (`editor.backendURL` for the endpoint, `editor.clientId` for the project).\n *\n * Safe to call multiple times: returns the existing client and increments a\n * `window`-shared reference count so nested providers (or duplicated module\n * instances) don't stop the client prematurely.\n *\n * @returns The started analytics client singleton.\n */\nexport const initAnalyticsClient = (): AnalyticsClient => {\n  incrementAnalyticsClientRefCount();\n\n  const existing = getGlobalAnalyticsClient();\n  if (existing) return existing;\n\n  const client = createAnalyticsClient({\n    backendURL: editor?.backendURL ?? '',\n    clientId: editor?.clientId,\n    flushInterval: analytics?.flushInterval ?? DEFAULT_FLUSH_INTERVAL,\n    maxBufferSize: DEFAULT_MAX_BUFFER_SIZE,\n    sampleRate: analytics?.sampleRate ?? DEFAULT_SAMPLE_RATE,\n  });\n\n  setGlobalAnalyticsClient(client);\n  client.start();\n\n  return client;\n};\n\n/**\n * Decrements the shared reference count and stops the global analytics client\n * only when the last provider unmounts (flushing any remaining events).\n *\n * Callers must pair each `stopAnalyticsClient` with a prior\n * `initAnalyticsClient` — never call it when init was skipped or cancelled.\n */\nexport const stopAnalyticsClient = (): void => {\n  if (decrementAnalyticsClientRefCount() > 0) return;\n\n  const client = getGlobalAnalyticsClient();\n  client?.stop();\n  setGlobalAnalyticsClient(null);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AA4BA,MAAa,4BAA6C;AACxD,mCAAkC;CAElC,MAAM,WAAW,0BAA0B;AAC3C,KAAI,SAAU,QAAO;CAErB,MAAM,SAAS,sBAAsB;EACnC,YAAY,QAAQ,cAAc;EAClC,UAAU,QAAQ;EAClB,eAAe,WAAW;EAC1B;EACA,YAAY,WAAW;EACxB,CAAC;AAEF,0BAAyB,OAAO;AAChC,QAAO,OAAO;AAEd,QAAO;;;;;;;;;AAUT,MAAa,4BAAkC;AAC7C,KAAI,kCAAkC,GAAG,EAAG;AAG5C,CADe,0BACT,EAAE,MAAM;AACd,0BAAyB,KAAK"}

package/dist/esm/core/sampling.mjs

@@ -0,0 +1,27 @@
+import { hashString } from "../utils/hash.mjs";
+
+//#region src/core/sampling.ts
+/**
+* Deterministic per-session sampling gate. Using the session id (rather than a
+* fresh random draw per event) means a sampled-in session reports *all* of its
+* content exposures, keeping per-session funnels consistent instead of leaving
+* holes.
+*
+* @param sessionId - The current anonymous session id.
+* @param sampleRate - Fraction of sessions to keep, from 0 (none) to 1 (all).
+* @returns `true` when this session's events should be recorded.
+*
+* @example
+* isSampledIn('abc', 1);   // always true
+* isSampledIn('abc', 0);   // always false
+* isSampledIn('abc', 0.5); // stable per session
+*/
+const isSampledIn = (sessionId, sampleRate) => {
+	if (sampleRate >= 1) return true;
+	if (sampleRate <= 0) return false;
+	return hashString(sessionId) / 4294967295 < sampleRate;
+};
+
+//#endregion
+export { isSampledIn };
+//# sourceMappingURL=sampling.mjs.map

package/dist/esm/core/sampling.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampling.mjs","names":[],"sources":["../../../src/core/sampling.ts"],"sourcesContent":["import { hashString } from '../utils/hash';\n\n/**\n * Deterministic per-session sampling gate. Using the session id (rather than a\n * fresh random draw per event) means a sampled-in session reports *all* of its\n * content exposures, keeping per-session funnels consistent instead of leaving\n * holes.\n *\n * @param sessionId - The current anonymous session id.\n * @param sampleRate - Fraction of sessions to keep, from 0 (none) to 1 (all).\n * @returns `true` when this session's events should be recorded.\n *\n * @example\n * isSampledIn('abc', 1);   // always true\n * isSampledIn('abc', 0);   // always false\n * isSampledIn('abc', 0.5); // stable per session\n */\nexport const isSampledIn = (sessionId: string, sampleRate: number): boolean => {\n  if (sampleRate >= 1) return true;\n  if (sampleRate <= 0) return false;\n\n  const bucket = hashString(sessionId) / 0xffffffff;\n  return bucket < sampleRate;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiBA,MAAa,eAAe,WAAmB,eAAgC;AAC7E,KAAI,cAAc,EAAG,QAAO;AAC5B,KAAI,cAAc,EAAG,QAAO;AAG5B,QADe,WAAW,UAAU,GAAG,aACvB"}

package/dist/esm/core/session.mjs

@@ -0,0 +1,40 @@
+//#region src/core/session.ts
+/**
+* Anonymous, per-tab session identity. Stored in `sessionStorage` so it is
+* cleared when the tab closes and is never shared across sites — no durable
+* cookie, no cross-site tracking, no PII.
+*/
+const SESSION_STORAGE_KEY = "__intlayer_analytics_sid__";
+/**
+* Generates a random, opaque session identifier.
+*
+* @returns A URL-safe random string.
+*/
+const generateSessionId = () => {
+	const cryptoObj = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+	if (cryptoObj?.randomUUID) return cryptoObj.randomUUID();
+	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+};
+/**
+* Returns the current session id, creating and persisting one on first access.
+* Degrades gracefully to an in-memory id when `sessionStorage` is unavailable
+* (private mode, native runtimes).
+*
+* @returns The stable session id for the lifetime of the tab.
+*/
+const getSessionId = () => {
+	if (typeof window === "undefined" || !window.sessionStorage) return generateSessionId();
+	try {
+		const existing = window.sessionStorage.getItem(SESSION_STORAGE_KEY);
+		if (existing) return existing;
+		const created = generateSessionId();
+		window.sessionStorage.setItem(SESSION_STORAGE_KEY, created);
+		return created;
+	} catch {
+		return generateSessionId();
+	}
+};
+
+//#endregion
+export { getSessionId };
+//# sourceMappingURL=session.mjs.map

package/dist/esm/core/session.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.mjs","names":[],"sources":["../../../src/core/session.ts"],"sourcesContent":["/**\n * Anonymous, per-tab session identity. Stored in `sessionStorage` so it is\n * cleared when the tab closes and is never shared across sites — no durable\n * cookie, no cross-site tracking, no PII.\n */\n\nconst SESSION_STORAGE_KEY = '__intlayer_analytics_sid__';\n\n/**\n * Generates a random, opaque session identifier.\n *\n * @returns A URL-safe random string.\n */\nconst generateSessionId = (): string => {\n  const cryptoObj =\n    typeof globalThis !== 'undefined'\n      ? (globalThis.crypto as Crypto | undefined)\n      : undefined;\n\n  if (cryptoObj?.randomUUID) {\n    return cryptoObj.randomUUID();\n  }\n\n  // Fallback for environments without crypto.randomUUID (older RN/Lynx)\n  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;\n};\n\n/**\n * Returns the current session id, creating and persisting one on first access.\n * Degrades gracefully to an in-memory id when `sessionStorage` is unavailable\n * (private mode, native runtimes).\n *\n * @returns The stable session id for the lifetime of the tab.\n */\nexport const getSessionId = (): string => {\n  if (typeof window === 'undefined' || !window.sessionStorage) {\n    return generateSessionId();\n  }\n\n  try {\n    const existing = window.sessionStorage.getItem(SESSION_STORAGE_KEY);\n    if (existing) return existing;\n\n    const created = generateSessionId();\n    window.sessionStorage.setItem(SESSION_STORAGE_KEY, created);\n    return created;\n  } catch {\n    // sessionStorage can throw (Safari private mode, quota) — never break the app\n    return generateSessionId();\n  }\n};\n"],"mappings":";;;;;;AAMA,MAAM,sBAAsB;;;;;;AAO5B,MAAM,0BAAkC;CACtC,MAAM,YACJ,OAAO,eAAe,cACjB,WAAW,SACZ;AAEN,KAAI,WAAW,WACb,QAAO,UAAU,YAAY;AAI/B,QAAO,GAAG,KAAK,KAAK,CAAC,SAAS,GAAG,CAAC,GAAG,KAAK,QAAQ,CAAC,SAAS,GAAG,CAAC,MAAM,GAAG,GAAG;;;;;;;;;AAU9E,MAAa,qBAA6B;AACxC,KAAI,OAAO,WAAW,eAAe,CAAC,OAAO,eAC3C,QAAO,mBAAmB;AAG5B,KAAI;EACF,MAAM,WAAW,OAAO,eAAe,QAAQ,oBAAoB;AACnE,MAAI,SAAU,QAAO;EAErB,MAAM,UAAU,mBAAmB;AACnC,SAAO,eAAe,QAAQ,qBAAqB,QAAQ;AAC3D,SAAO;SACD;AAEN,SAAO,mBAAmB"}

package/dist/esm/core/transport.mjs

@@ -0,0 +1,45 @@
+//#region src/core/transport.ts
+/**
+* Sends a batch of events to the backend. Every path is non-blocking and
+* no-throw — analytics must never break, slow, or delay the host application.
+*
+* Strategy:
+* 1. `navigator.sendBeacon` for the flush-on-hide path — survives page unload
+*    and never blocks navigation. The payload is sent as `text/plain` (a
+*    CORS-safelisted content type): a JSON `Blob` would require a CORS
+*    preflight that browsers handle inconsistently during unload, silently
+*    dropping the beacon. The backend parses `text/plain` bodies as JSON.
+* 2. `fetch(..., { keepalive: true })` for interval flushes — survives short
+*    navigations without holding the main thread.
+* 3. Plain `fetch` fallback for runtimes without `keepalive` (older RN/Lynx).
+*
+* @param endpoint - Fully-qualified ingestion URL.
+* @param body - The batched payload.
+* @param options - Transport options.
+* @param options.useBeacon - Prefer `sendBeacon` (used when the page is hiding).
+* @returns `true` when a send was dispatched, `false` otherwise.
+*/
+const sendEvents = (endpoint, body, { useBeacon = false } = {}) => {
+	try {
+		const payload = JSON.stringify(body);
+		if (useBeacon && typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function") return navigator.sendBeacon(endpoint, payload);
+		if (typeof fetch === "function") {
+			fetch(endpoint, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: payload,
+				keepalive: true,
+				credentials: "omit",
+				mode: "cors"
+			}).catch(() => {});
+			return true;
+		}
+		return false;
+	} catch {
+		return false;
+	}
+};
+
+//#endregion
+export { sendEvents };
+//# sourceMappingURL=transport.mjs.map

package/dist/esm/core/transport.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.mjs","names":[],"sources":["../../../src/core/transport.ts"],"sourcesContent":["import type { AnalyticsIngestBody } from './types';\n\n/**\n * Sends a batch of events to the backend. Every path is non-blocking and\n * no-throw — analytics must never break, slow, or delay the host application.\n *\n * Strategy:\n * 1. `navigator.sendBeacon` for the flush-on-hide path — survives page unload\n *    and never blocks navigation. The payload is sent as `text/plain` (a\n *    CORS-safelisted content type): a JSON `Blob` would require a CORS\n *    preflight that browsers handle inconsistently during unload, silently\n *    dropping the beacon. The backend parses `text/plain` bodies as JSON.\n * 2. `fetch(..., { keepalive: true })` for interval flushes — survives short\n *    navigations without holding the main thread.\n * 3. Plain `fetch` fallback for runtimes without `keepalive` (older RN/Lynx).\n *\n * @param endpoint - Fully-qualified ingestion URL.\n * @param body - The batched payload.\n * @param options - Transport options.\n * @param options.useBeacon - Prefer `sendBeacon` (used when the page is hiding).\n * @returns `true` when a send was dispatched, `false` otherwise.\n */\nexport const sendEvents = (\n  endpoint: string,\n  body: AnalyticsIngestBody,\n  { useBeacon = false }: { useBeacon?: boolean } = {}\n): boolean => {\n  try {\n    const payload = JSON.stringify(body);\n\n    if (\n      useBeacon &&\n      typeof navigator !== 'undefined' &&\n      typeof navigator.sendBeacon === 'function'\n    ) {\n      // Note: unlike the fetch path below, sendBeacon always includes\n      // credentials; the ingest endpoint ignores them.\n      return navigator.sendBeacon(endpoint, payload);\n    }\n\n    if (typeof fetch === 'function') {\n      // keepalive lets the request outlive a same-tab navigation.\n      void fetch(endpoint, {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: payload,\n        keepalive: true,\n        // Analytics is best-effort; never send credentials.\n        credentials: 'omit',\n        mode: 'cors',\n      }).catch(() => {\n        /* swallow — best-effort delivery */\n      });\n      return true;\n    }\n\n    return false;\n  } catch {\n    // JSON serialization failed — drop the batch silently.\n    return false;\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,cACX,UACA,MACA,EAAE,YAAY,UAAmC,EAAE,KACvC;AACZ,KAAI;EACF,MAAM,UAAU,KAAK,UAAU,KAAK;AAEpC,MACE,aACA,OAAO,cAAc,eACrB,OAAO,UAAU,eAAe,WAIhC,QAAO,UAAU,WAAW,UAAU,QAAQ;AAGhD,MAAI,OAAO,UAAU,YAAY;AAE/B,GAAK,MAAM,UAAU;IACnB,QAAQ;IACR,SAAS,EAAE,gBAAgB,oBAAoB;IAC/C,MAAM;IACN,WAAW;IAEX,aAAa;IACb,MAAM;IACP,CAAC,CAAC,YAAY,GAEb;AACF,UAAO;;AAGT,SAAO;SACD;AAEN,SAAO"}

package/dist/esm/events/contentExposure.mjs

@@ -0,0 +1,36 @@
+//#region src/events/contentExposure.ts
+/**
+* Serializes a `KeyPath[]` into a compact, stable string used both as the
+* coalescing key in the buffer and as the stored `keyPath` on the wire.
+*
+* Only the `key` of each segment is kept (types are implied by the dictionary
+* shape), producing paths like `"faq.items.2.answer"`.
+*
+* @param keyPath - The interpreter key path locating a node.
+* @returns A dot-joined, stable path string.
+*
+* @example
+* serializeKeyPath([{ type: 'object', key: 'faq' }, { type: 'array', key: 2 }]);
+* // "faq.2"
+*/
+const serializeKeyPath = (keyPath) => keyPath.map((segment) => segment.key === void 0 ? "*" : String(segment.key)).join(".");
+/**
+* Builds a content-exposure payload from interpreter node metadata. Shared by
+* every framework binding's analytics node plugin so the wire shape stays
+* identical across React, Vue, Svelte, Angular, etc.
+*
+* @param params - Node metadata available on `NodeProps`.
+* @returns A trackable content-exposure event (minus buffer-stamped fields).
+*/
+const buildContentExposure = (params) => ({
+	dictionaryKey: params.dictionaryKey,
+	keyPath: serializeKeyPath(params.keyPath),
+	locale: params.locale,
+	nodeType: params.nodeType,
+	experimentKey: params.experimentKey,
+	variant: params.variant
+});
+
+//#endregion
+export { buildContentExposure, serializeKeyPath };
+//# sourceMappingURL=contentExposure.mjs.map