@intlayer/analytics 9.0.0-canary.16

package/dist/cjs/core/eventBuffer.cjs

@@ -0,0 +1,68 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#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
+exports.createEventBuffer = createEventBuffer;
+//# sourceMappingURL=eventBuffer.cjs.map

package/dist/cjs/core/eventBuffer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventBuffer.cjs","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/cjs/core/globalManager.cjs

@@ -0,0 +1,63 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#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
+exports.decrementAnalyticsClientRefCount = decrementAnalyticsClientRefCount;
+exports.getGlobalAnalyticsClient = getGlobalAnalyticsClient;
+exports.incrementAnalyticsClientRefCount = incrementAnalyticsClientRefCount;
+exports.setGlobalAnalyticsClient = setGlobalAnalyticsClient;
+//# sourceMappingURL=globalManager.cjs.map

package/dist/cjs/core/globalManager.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalManager.cjs","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/cjs/core/index.cjs

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_core_abTesting = require('./abTesting.cjs');
+const require_core_eventBuffer = require('./eventBuffer.cjs');
+const require_core_sampling = require('./sampling.cjs');
+const require_core_session = require('./session.cjs');
+const require_core_transport = require('./transport.cjs');
+const require_core_AnalyticsClient = require('./AnalyticsClient.cjs');
+const require_core_globalManager = require('./globalManager.cjs');
+const require_core_initAnalyticsClient = require('./initAnalyticsClient.cjs');
+
+exports.DEFAULT_FLUSH_INTERVAL = require_core_AnalyticsClient.DEFAULT_FLUSH_INTERVAL;
+exports.DEFAULT_MAX_BUFFER_SIZE = require_core_AnalyticsClient.DEFAULT_MAX_BUFFER_SIZE;
+exports.DEFAULT_SAMPLE_RATE = require_core_AnalyticsClient.DEFAULT_SAMPLE_RATE;
+exports.MAX_EVENTS_PER_SEND = require_core_AnalyticsClient.MAX_EVENTS_PER_SEND;
+exports.assignVariant = require_core_abTesting.assignVariant;
+exports.createAnalyticsClient = require_core_AnalyticsClient.createAnalyticsClient;
+exports.createEventBuffer = require_core_eventBuffer.createEventBuffer;
+exports.decrementAnalyticsClientRefCount = require_core_globalManager.decrementAnalyticsClientRefCount;
+exports.getGlobalAnalyticsClient = require_core_globalManager.getGlobalAnalyticsClient;
+exports.getSessionId = require_core_session.getSessionId;
+exports.incrementAnalyticsClientRefCount = require_core_globalManager.incrementAnalyticsClientRefCount;
+exports.initAnalyticsClient = require_core_initAnalyticsClient.initAnalyticsClient;
+exports.isSampledIn = require_core_sampling.isSampledIn;
+exports.sendEvents = require_core_transport.sendEvents;
+exports.setGlobalAnalyticsClient = require_core_globalManager.setGlobalAnalyticsClient;
+exports.stopAnalyticsClient = require_core_initAnalyticsClient.stopAnalyticsClient;

package/dist/cjs/core/initAnalyticsClient.cjs

@@ -0,0 +1,51 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_core_AnalyticsClient = require('./AnalyticsClient.cjs');
+const require_core_globalManager = require('./globalManager.cjs');
+let _intlayer_config_built = require("@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 = () => {
+	require_core_globalManager.incrementAnalyticsClientRefCount();
+	const existing = require_core_globalManager.getGlobalAnalyticsClient();
+	if (existing) return existing;
+	const client = require_core_AnalyticsClient.createAnalyticsClient({
+		backendURL: _intlayer_config_built.editor?.backendURL ?? "",
+		clientId: _intlayer_config_built.editor?.clientId,
+		flushInterval: _intlayer_config_built.analytics?.flushInterval ?? 2e4,
+		maxBufferSize: 500,
+		sampleRate: _intlayer_config_built.analytics?.sampleRate ?? 1
+	});
+	require_core_globalManager.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 (require_core_globalManager.decrementAnalyticsClientRefCount() > 0) return;
+	require_core_globalManager.getGlobalAnalyticsClient()?.stop();
+	require_core_globalManager.setGlobalAnalyticsClient(null);
+};
+
+//#endregion
+exports.initAnalyticsClient = initAnalyticsClient;
+exports.stopAnalyticsClient = stopAnalyticsClient;
+//# sourceMappingURL=initAnalyticsClient.cjs.map

package/dist/cjs/core/initAnalyticsClient.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"initAnalyticsClient.cjs","names":["getGlobalAnalyticsClient","createAnalyticsClient","editor","analytics","decrementAnalyticsClientRefCount"],"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,8DAAkC;CAElC,MAAM,WAAWA,qDAA0B;AAC3C,KAAI,SAAU,QAAO;CAErB,MAAM,SAASC,mDAAsB;EACnC,YAAYC,+BAAQ,cAAc;EAClC,UAAUA,+BAAQ;EAClB,eAAeC,kCAAW;EAC1B;EACA,YAAYA,kCAAW;EACxB,CAAC;AAEF,qDAAyB,OAAO;AAChC,QAAO,OAAO;AAEd,QAAO;;;;;;;;;AAUT,MAAa,4BAAkC;AAC7C,KAAIC,6DAAkC,GAAG,EAAG;AAG5C,CADeJ,qDACT,EAAE,MAAM;AACd,qDAAyB,KAAK"}

package/dist/cjs/core/sampling.cjs

@@ -0,0 +1,28 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_utils_hash = require('../utils/hash.cjs');
+
+//#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 require_utils_hash.hashString(sessionId) / 4294967295 < sampleRate;
+};
+
+//#endregion
+exports.isSampledIn = isSampledIn;
+//# sourceMappingURL=sampling.cjs.map

package/dist/cjs/core/sampling.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampling.cjs","names":["hashString"],"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,QADeA,8BAAW,UAAU,GAAG,aACvB"}

package/dist/cjs/core/session.cjs

@@ -0,0 +1,42 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#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
+exports.getSessionId = getSessionId;
+//# sourceMappingURL=session.cjs.map

package/dist/cjs/core/session.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.cjs","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/cjs/core/transport.cjs

@@ -0,0 +1,47 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#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
+exports.sendEvents = sendEvents;
+//# sourceMappingURL=transport.cjs.map

package/dist/cjs/core/transport.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.cjs","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/cjs/events/contentExposure.cjs

@@ -0,0 +1,39 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#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
+exports.buildContentExposure = buildContentExposure;
+exports.serializeKeyPath = serializeKeyPath;
+//# sourceMappingURL=contentExposure.cjs.map

package/dist/cjs/events/contentExposure.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentExposure.cjs","names":[],"sources":["../../../src/events/contentExposure.ts"],"sourcesContent":["import type { KeyPath } from '@intlayer/types/keyPath';\nimport type { ContentExposureEvent, TrackableEvent } from '../core/types';\n\n/**\n * Serializes a `KeyPath[]` into a compact, stable string used both as the\n * coalescing key in the buffer and as the stored `keyPath` on the wire.\n *\n * Only the `key` of each segment is kept (types are implied by the dictionary\n * shape), producing paths like `\"faq.items.2.answer\"`.\n *\n * @param keyPath - The interpreter key path locating a node.\n * @returns A dot-joined, stable path string.\n *\n * @example\n * serializeKeyPath([{ type: 'object', key: 'faq' }, { type: 'array', key: 2 }]);\n * // \"faq.2\"\n */\nexport const serializeKeyPath = (keyPath: KeyPath[]): string =>\n  keyPath\n    .map((segment) => (segment.key === undefined ? '*' : String(segment.key)))\n    .join('.');\n\n/**\n * Builds a content-exposure payload from interpreter node metadata. Shared by\n * every framework binding's analytics node plugin so the wire shape stays\n * identical across React, Vue, Svelte, Angular, etc.\n *\n * @param params - Node metadata available on `NodeProps`.\n * @returns A trackable content-exposure event (minus buffer-stamped fields).\n */\nexport const buildContentExposure = (params: {\n  dictionaryKey: string;\n  keyPath: KeyPath[];\n  locale?: string;\n  nodeType?: string;\n  experimentKey?: string;\n  variant?: string;\n}): Omit<TrackableEvent<ContentExposureEvent>, 'type'> => ({\n  dictionaryKey: params.dictionaryKey,\n  keyPath: serializeKeyPath(params.keyPath),\n  // Left undefined when unknown so the client stamps its ambient locale.\n  locale: params.locale,\n  nodeType: params.nodeType,\n  experimentKey: params.experimentKey,\n  variant: params.variant,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,MAAa,oBAAoB,YAC/B,QACG,KAAK,YAAa,QAAQ,QAAQ,SAAY,MAAM,OAAO,QAAQ,IAAI,CAAE,CACzE,KAAK,IAAI;;;;;;;;;AAUd,MAAa,wBAAwB,YAOsB;CACzD,eAAe,OAAO;CACtB,SAAS,iBAAiB,OAAO,QAAQ;CAEzC,QAAQ,OAAO;CACf,UAAU,OAAO;CACjB,eAAe,OAAO;CACtB,SAAS,OAAO;CACjB"}

package/dist/cjs/index.cjs

@@ -0,0 +1,29 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_core_abTesting = require('./core/abTesting.cjs');
+const require_core_eventBuffer = require('./core/eventBuffer.cjs');
+const require_core_sampling = require('./core/sampling.cjs');
+const require_core_session = require('./core/session.cjs');
+const require_core_transport = require('./core/transport.cjs');
+const require_core_AnalyticsClient = require('./core/AnalyticsClient.cjs');
+const require_core_globalManager = require('./core/globalManager.cjs');
+const require_core_initAnalyticsClient = require('./core/initAnalyticsClient.cjs');
+const require_events_contentExposure = require('./events/contentExposure.cjs');
+
+exports.DEFAULT_FLUSH_INTERVAL = require_core_AnalyticsClient.DEFAULT_FLUSH_INTERVAL;
+exports.DEFAULT_MAX_BUFFER_SIZE = require_core_AnalyticsClient.DEFAULT_MAX_BUFFER_SIZE;
+exports.DEFAULT_SAMPLE_RATE = require_core_AnalyticsClient.DEFAULT_SAMPLE_RATE;
+exports.MAX_EVENTS_PER_SEND = require_core_AnalyticsClient.MAX_EVENTS_PER_SEND;
+exports.assignVariant = require_core_abTesting.assignVariant;
+exports.buildContentExposure = require_events_contentExposure.buildContentExposure;
+exports.createAnalyticsClient = require_core_AnalyticsClient.createAnalyticsClient;
+exports.createEventBuffer = require_core_eventBuffer.createEventBuffer;
+exports.decrementAnalyticsClientRefCount = require_core_globalManager.decrementAnalyticsClientRefCount;
+exports.getGlobalAnalyticsClient = require_core_globalManager.getGlobalAnalyticsClient;
+exports.getSessionId = require_core_session.getSessionId;
+exports.incrementAnalyticsClientRefCount = require_core_globalManager.incrementAnalyticsClientRefCount;
+exports.initAnalyticsClient = require_core_initAnalyticsClient.initAnalyticsClient;
+exports.isSampledIn = require_core_sampling.isSampledIn;
+exports.sendEvents = require_core_transport.sendEvents;
+exports.serializeKeyPath = require_events_contentExposure.serializeKeyPath;
+exports.setGlobalAnalyticsClient = require_core_globalManager.setGlobalAnalyticsClient;
+exports.stopAnalyticsClient = require_core_initAnalyticsClient.stopAnalyticsClient;

package/dist/cjs/isEnabled.cjs

@@ -0,0 +1,29 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _intlayer_config_built = require("@intlayer/config/built");
+
+//#region src/isEnabled.ts
+/**
+* Compile-time kill switch. Bundlers replace `process.env.INTLAYER_ANALYTICS_ENABLED`
+* (set to `'false'` by `@intlayer/config` unless `analytics.enabled` is `true`
+* AND an `editor.clientId` is configured) so the whole analytics integration is
+* dead-code-eliminated for apps that don't opt in.
+*/
+const TREE_SHAKE_ANALYTICS = process.env.INTLAYER_ANALYTICS_ENABLED === "false";
+/**
+* Runtime guard mirroring `@intlayer/editor`'s `isEnabled`, but inverted with
+* respect to the iframe: analytics runs for real end users on the **top**
+* window and stays off inside the editor/CMS preview iframe so editor sessions
+* are never counted as traffic.
+*
+* Enabled when:
+* - the bundler did not tree-shake analytics away, and
+* - the user opted in (`analytics.enabled === true`), and
+* - a project key is configured (`editor.clientId`), and
+* - we are on the client, and
+* - we are the top window (not embedded in the editor).
+*/
+const isEnabled = !TREE_SHAKE_ANALYTICS && _intlayer_config_built.analytics?.enabled === true && Boolean(_intlayer_config_built.editor?.clientId) && typeof window !== "undefined" && window.self === window.top;
+
+//#endregion
+exports.isEnabled = isEnabled;
+//# sourceMappingURL=isEnabled.cjs.map

package/dist/cjs/isEnabled.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEnabled.cjs","names":["analytics","editor"],"sources":["../../src/isEnabled.ts"],"sourcesContent":["import { analytics, editor } from '@intlayer/config/built';\n\n/**\n * Compile-time kill switch. Bundlers replace `process.env.INTLAYER_ANALYTICS_ENABLED`\n * (set to `'false'` by `@intlayer/config` unless `analytics.enabled` is `true`\n * AND an `editor.clientId` is configured) so the whole analytics integration is\n * dead-code-eliminated for apps that don't opt in.\n */\nconst TREE_SHAKE_ANALYTICS = process.env.INTLAYER_ANALYTICS_ENABLED === 'false';\n\n/**\n * Runtime guard mirroring `@intlayer/editor`'s `isEnabled`, but inverted with\n * respect to the iframe: analytics runs for real end users on the **top**\n * window and stays off inside the editor/CMS preview iframe so editor sessions\n * are never counted as traffic.\n *\n * Enabled when:\n * - the bundler did not tree-shake analytics away, and\n * - the user opted in (`analytics.enabled === true`), and\n * - a project key is configured (`editor.clientId`), and\n * - we are on the client, and\n * - we are the top window (not embedded in the editor).\n */\nexport const isEnabled =\n  !TREE_SHAKE_ANALYTICS &&\n  analytics?.enabled === true &&\n  Boolean(editor?.clientId) &&\n  typeof window !== 'undefined' &&\n  window.self === window.top;\n"],"mappings":";;;;;;;;;;AAQA,MAAM,uBAAuB,QAAQ,IAAI,+BAA+B;;;;;;;;;;;;;;AAexE,MAAa,YACX,CAAC,wBACDA,kCAAW,YAAY,QACvB,QAAQC,+BAAQ,SAAS,IACzB,OAAO,WAAW,eAClB,OAAO,SAAS,OAAO"}

package/dist/cjs/utils/hash.cjs

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/utils/hash.ts
+/**
+* FNV-1a 32-bit string hash. Small, fast, dependency-free, and stable across
+* runtimes — good enough for deterministic A/B bucketing and session seeding
+* (not for cryptographic use).
+*
+* @param input - The string to hash.
+* @returns An unsigned 32-bit integer hash.
+*
+* @example
+* hashString('session-1:homepage-hero'); // 3039336720
+*/
+const hashString = (input) => {
+	let hash = 2166136261;
+	for (let index = 0; index < input.length; index++) {
+		hash ^= input.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return hash >>> 0;
+};
+
+//#endregion
+exports.hashString = hashString;
+//# sourceMappingURL=hash.cjs.map

package/dist/cjs/utils/hash.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.cjs","names":[],"sources":["../../../src/utils/hash.ts"],"sourcesContent":["/**\n * FNV-1a 32-bit string hash. Small, fast, dependency-free, and stable across\n * runtimes — good enough for deterministic A/B bucketing and session seeding\n * (not for cryptographic use).\n *\n * @param input - The string to hash.\n * @returns An unsigned 32-bit integer hash.\n *\n * @example\n * hashString('session-1:homepage-hero'); // 3039336720\n */\nexport const hashString = (input: string): number => {\n  let hash = 0x811c9dc5; // FNV offset basis\n\n  for (let index = 0; index < input.length; index++) {\n    hash ^= input.charCodeAt(index);\n    // 32-bit FNV prime multiplication via shifts to stay within Number safe range\n    hash = Math.imul(hash, 0x01000193);\n  }\n\n  // Coerce to unsigned 32-bit\n  return hash >>> 0;\n};\n"],"mappings":";;;;;;;;;;;;;;AAWA,MAAa,cAAc,UAA0B;CACnD,IAAI,OAAO;AAEX,MAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS;AACjD,UAAQ,MAAM,WAAW,MAAM;AAE/B,SAAO,KAAK,KAAK,MAAM,SAAW;;AAIpC,QAAO,SAAS"}

package/dist/cjs/utils/idle.cjs

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/utils/idle.ts
+/**
+* Runs a callback when the browser is idle, without blocking first render.
+* Falls back to a short `setTimeout` where `requestIdleCallback` is unavailable
+* (Safari, React Native, Lynx).
+*
+* @param callback - Work to run once the main thread is free.
+*
+* @example
+* onIdle(() => attachVisibilityListeners());
+*/
+const onIdle = (callback) => {
+	if (typeof window === "undefined") return;
+	const requestIdle = window.requestIdleCallback;
+	if (typeof requestIdle === "function") {
+		requestIdle(() => callback());
+		return;
+	}
+	setTimeout(callback, 1);
+};
+
+//#endregion
+exports.onIdle = onIdle;
+//# sourceMappingURL=idle.cjs.map

package/dist/cjs/utils/idle.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"idle.cjs","names":[],"sources":["../../../src/utils/idle.ts"],"sourcesContent":["/**\n * Runs a callback when the browser is idle, without blocking first render.\n * Falls back to a short `setTimeout` where `requestIdleCallback` is unavailable\n * (Safari, React Native, Lynx).\n *\n * @param callback - Work to run once the main thread is free.\n *\n * @example\n * onIdle(() => attachVisibilityListeners());\n */\nexport const onIdle = (callback: () => void): void => {\n  if (typeof window === 'undefined') return;\n\n  const requestIdle = (\n    window as Window & {\n      requestIdleCallback?: (cb: () => void) => number;\n    }\n  ).requestIdleCallback;\n\n  if (typeof requestIdle === 'function') {\n    requestIdle(() => callback());\n    return;\n  }\n\n  setTimeout(callback, 1);\n};\n"],"mappings":";;;;;;;;;;;;;AAUA,MAAa,UAAU,aAA+B;AACpD,KAAI,OAAO,WAAW,YAAa;CAEnC,MAAM,cACJ,OAGA;AAEF,KAAI,OAAO,gBAAgB,YAAY;AACrC,oBAAkB,UAAU,CAAC;AAC7B;;AAGF,YAAW,UAAU,EAAE"}